@autoscriber/core 0.1.0

package/dist/index.cjs

@@ -0,0 +1,2005 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  AssistantClient: () => AssistantClient,
+  createAssistant: () => createAssistant
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/utils/event-bus.ts
+var EventBus = class {
+  constructor() {
+    this.listeners = /* @__PURE__ */ new Map();
+  }
+  on(event, listener) {
+    const listeners = this.listeners.get(event) ?? /* @__PURE__ */ new Set();
+    listeners.add(listener);
+    this.listeners.set(event, listeners);
+    return () => this.off(event, listener);
+  }
+  once(event, listener) {
+    const off = this.on(event, (payload) => {
+      off();
+      listener(payload);
+    });
+    return off;
+  }
+  off(event, listener) {
+    const listeners = this.listeners.get(event);
+    if (!listeners)
+      return;
+    listeners.delete(listener);
+    if (listeners.size === 0) {
+      this.listeners.delete(event);
+    }
+  }
+  emit(event, payload) {
+    const listeners = this.listeners.get(event);
+    if (!listeners)
+      return;
+    listeners.forEach((listener) => {
+      try {
+        listener(payload);
+      } catch (error) {
+        console.error("[EventBus] listener error", error);
+      }
+    });
+  }
+  clear() {
+    this.listeners.clear();
+  }
+};
+
+// src/utils/logger.ts
+var noop = () => {
+};
+function createLogger(overrides) {
+  return {
+    debug: overrides?.debug?.bind(overrides) ?? noop,
+    info: overrides?.info?.bind(overrides) ?? noop,
+    warn: overrides?.warn?.bind(overrides) ?? console.warn,
+    error: overrides?.error?.bind(overrides) ?? console.error
+  };
+}
+
+// src/utils/i18n.ts
+var TRANSLATIONS = {
+  en: {
+    askAnything: "Ask anything...",
+    typeOrHoldSpace: 'Type or hold "space" to talk',
+    paused: "Paused...",
+    listening: "Listening...",
+    title: "Assistant",
+    aiDisclaimer: "AI generated answers can be inaccurate.",
+    newChat: "New chat",
+    emergencyStop: "Recording emergency stopped",
+    transcriptionTimeout: "Transcription timeout - please try again",
+    voiceCommandFailed: "\u26A0\uFE0F Voice command failed to start - microphone unavailable",
+    transcriptionFailed: "\u26A0\uFE0F Transcription failed to start - microphone unavailable",
+    microphoneRequired: "\u26A0\uFE0F Microphone access required - please allow microphone access when prompted",
+    microphoneNotFound: "\u26A0\uFE0F No microphone found - please connect a microphone",
+    microphonePermissionError: "\u26A0\uFE0F Unable to check microphone permissions",
+    microphoneAccessError: "\u26A0\uFE0F Unable to access microphone - please check your browser settings",
+    microphoneAccessDenied: "\u26A0\uFE0F Microphone access denied - please enable in browser settings",
+    settings: "Settings",
+    microphone: "Microphone",
+    noMicrophonesFound: "No microphones found",
+    transcriptionStarted: "Transcription started",
+    transcriptionStopped: "Transcription stopped",
+    voiceCommandSilence: "Voice command cancelled - silence detected",
+    networkOffline: "\u26A0\uFE0F Network offline - messages will be sent when connection returns",
+    transcriptionStoppedOffline: "Transcription stopped - Network offline",
+    transcriptionBufferingOffline: "Transcription buffering - will resume when connection returns",
+    voiceCommandCancelledOffline: "Voice command cancelled - Network offline",
+    connectionRestored: "Connection restored",
+    offlineBuffering: "Message buffered - will resend once connected"
+  },
+  nl: {
+    askAnything: "Stel je vraag...",
+    typeOrHoldSpace: 'Typ of houd "spatie" ingedrukt om te praten',
+    paused: "Gepauzeerd...",
+    listening: "Luisteren...",
+    title: "Assistent",
+    aiDisclaimer: "AI-gegenereerde antwoorden kunnen onnauwkeurig zijn.",
+    newChat: "Nieuwe chat",
+    emergencyStop: "Opname noodstop uitgevoerd",
+    transcriptionTimeout: "Transcriptie timeout - probeer opnieuw",
+    voiceCommandFailed: "\u26A0\uFE0F Spraakopdracht starten mislukt - microfoon niet beschikbaar",
+    transcriptionFailed: "\u26A0\uFE0F Transcriptie starten mislukt - microfoon niet beschikbaar",
+    microphoneRequired: "\u26A0\uFE0F Microfoon toegang vereist - sta microfoon toegang toe wanneer gevraagd",
+    microphoneNotFound: "\u26A0\uFE0F Geen microfoon gevonden - sluit een microfoon aan",
+    microphonePermissionError: "\u26A0\uFE0F Kan microfoon machtigingen niet controleren",
+    microphoneAccessError: "\u26A0\uFE0F Kan microfoon niet benaderen - controleer uw browserinstellingen",
+    microphoneAccessDenied: "\u26A0\uFE0F Microfoon toegang geweigerd - schakel in browserinstellingen in",
+    settings: "Instellingen",
+    microphone: "Microfoon",
+    noMicrophonesFound: "Geen microfoons gevonden",
+    transcriptionStarted: "Transcriptie gestart",
+    transcriptionStopped: "Transcriptie gestopt",
+    voiceCommandSilence: "Spraakopdracht geannuleerd - stilte gedetecteerd",
+    networkOffline: "\u26A0\uFE0F Netwerk offline - berichten worden verzonden zodra de verbinding terug is",
+    transcriptionStoppedOffline: "Transcriptie gestopt - Netwerk offline",
+    transcriptionBufferingOffline: "Transcriptie wordt gebufferd - gaat verder zodra we weer online zijn",
+    voiceCommandCancelledOffline: "Spraakopdracht geannuleerd - Netwerk offline",
+    connectionRestored: "Verbinding hersteld",
+    offlineBuffering: "Bericht gebufferd - wordt verzonden zodra we weer online zijn"
+  },
+  de: {
+    askAnything: "Stellen Sie eine Frage...",
+    typeOrHoldSpace: "Tippen zum Schreiben oder Leertaste halten zum Sprechen",
+    paused: "Pausiert...",
+    listening: "H\xF6rt zu...",
+    title: "Assistent",
+    aiDisclaimer: "KI-generierte Antworten k\xF6nnen ungenau sein.",
+    newChat: "Neuer Chat",
+    emergencyStop: "Notfallstopp der Aufnahme ausgef\xFChrt",
+    transcriptionTimeout: "Transkriptions-Timeout \u2013 bitte erneut versuchen",
+    voiceCommandFailed: "\u26A0\uFE0F Sprachbefehl konnte nicht gestartet werden \u2013 Mikrofon nicht verf\xFCgbar",
+    transcriptionFailed: "\u26A0\uFE0F Transkription konnte nicht gestartet werden \u2013 Mikrofon nicht verf\xFCgbar",
+    microphoneRequired: "\u26A0\uFE0F Mikrofonzugriff erforderlich \u2013 bitte Zugriff bei Aufforderung erlauben",
+    microphoneNotFound: "\u26A0\uFE0F Kein Mikrofon gefunden \u2013 bitte Mikrofon anschlie\xDFen",
+    microphonePermissionError: "\u26A0\uFE0F Mikrofonberechtigungen k\xF6nnen nicht \xFCberpr\xFCft werden",
+    microphoneAccessError: "\u26A0\uFE0F Auf Mikrofon kann nicht zugegriffen werden \u2013 bitte Browsereinstellungen \xFCberpr\xFCfen",
+    microphoneAccessDenied: "\u26A0\uFE0F Mikrofonzugriff verweigert \u2013 bitte in den Browsereinstellungen aktivieren",
+    settings: "Einstellungen",
+    microphone: "Mikrofon",
+    noMicrophonesFound: "Keine Mikrofone gefunden",
+    transcriptionStarted: "Transkription gestartet",
+    transcriptionStopped: "Transkription gestoppt",
+    voiceCommandSilence: "Sprachbefehl abgebrochen \u2013 Stille erkannt",
+    networkOffline: "\u26A0\uFE0F Netzwerk offline \u2013 Nachrichten werden gesendet, sobald die Verbindung zur\xFCck ist",
+    transcriptionStoppedOffline: "Transkription gestoppt \u2013 Netzwerk offline",
+    transcriptionBufferingOffline: "Transkription wird gepuffert \u2013 l\xE4uft weiter, sobald die Verbindung zur\xFCck ist",
+    voiceCommandCancelledOffline: "Sprachbefehl abgebrochen \u2013 Netzwerk offline",
+    connectionRestored: "Verbindung wiederhergestellt",
+    offlineBuffering: "Nachricht gepuffert \u2013 wird gesendet, sobald wir wieder online sind"
+  }
+};
+var DEFAULT_LANGUAGE = "en";
+function translate(language, key, params = {}) {
+  const dictionary = TRANSLATIONS[language] ?? TRANSLATIONS[DEFAULT_LANGUAGE];
+  let text = dictionary[key] ?? TRANSLATIONS[DEFAULT_LANGUAGE][key] ?? key;
+  Object.entries(params).forEach(([placeholder, value]) => {
+    text = text.replace(new RegExp(`{{${placeholder}}}`, "g"), String(value));
+  });
+  return text;
+}
+function validateLanguage(lang) {
+  if (!lang)
+    return DEFAULT_LANGUAGE;
+  if (["en", "nl", "de"].includes(lang)) {
+    return lang;
+  }
+  console.warn(
+    `[Autoscriber] Unsupported language "${lang}" provided. Falling back to "${DEFAULT_LANGUAGE}".`
+  );
+  return DEFAULT_LANGUAGE;
+}
+
+// src/utils/id.ts
+function generateMessageId() {
+  return Math.random().toString(36).substring(2, 10);
+}
+
+// src/core/message-store.ts
+var MessageStore = class {
+  constructor() {
+    this.messages = [];
+    this.interactions = [];
+  }
+  createMessage(input = {}) {
+    const message = {
+      id: input.id ?? generateMessageId(),
+      request: input.request ?? null,
+      partialResults: [],
+      result: null,
+      type: input.type ?? "chat",
+      metadata: input.metadata ?? {}
+    };
+    this.messages.push(message);
+    return message;
+  }
+  addMessage(message) {
+    this.messages.push(message);
+  }
+  getMessageById(id) {
+    return this.messages.find((msg) => msg.id === id);
+  }
+  setMessageResult(id, result) {
+    const target = this.getMessageById(id);
+    if (!target)
+      return;
+    target.result = result;
+    target.partialResults = [];
+  }
+  setMessagePartialResult(id, payload, append = true) {
+    const target = this.getMessageById(id);
+    if (!target)
+      return;
+    if (!append) {
+      target.partialResults = [payload];
+    } else {
+      target.partialResults.push(payload);
+    }
+  }
+  applyJsonPatch(id, patchOperations) {
+    const target = this.getMessageById(id);
+    if (!target)
+      return;
+    if (!target.metadata)
+      target.metadata = {};
+    if (!target.metadata.transcriptData) {
+      target.metadata.transcriptData = {
+        resourceType: "Transcript",
+        entries: []
+      };
+    }
+    const transcriptData = target.metadata.transcriptData;
+    patchOperations.forEach((operation) => {
+      if (operation.op === "add" && operation.path === "/entries") {
+        if (Array.isArray(operation.value)) {
+          transcriptData.entries.push(...operation.value);
+        } else {
+          transcriptData.entries.push(operation.value);
+        }
+      }
+    });
+    const transcriptResult = {
+      mediaType: "application/fhir+json",
+      data: { ...transcriptData }
+    };
+    target.result = [transcriptResult];
+  }
+  setError(id, errorMessage, result) {
+    const target = this.getMessageById(id);
+    if (!target)
+      return;
+    target.errorMessage = errorMessage;
+    if (result) {
+      target.result = result;
+    }
+  }
+  upsertInteraction(pill) {
+    const existing = this.interactions.find((item) => item.id === pill.id);
+    if (existing) {
+      Object.assign(existing, pill);
+      return existing;
+    }
+    this.interactions.push(pill);
+    return pill;
+  }
+  updateInteractionStatus(id, status, metadata) {
+    const target = this.interactions.find((item) => item.id === id);
+    if (!target)
+      return;
+    target.status = status;
+    if (metadata) {
+      target.metadata = { ...target.metadata ?? {}, ...metadata };
+    }
+  }
+  getInteractions() {
+    return [...this.interactions];
+  }
+  getMessages() {
+    return [...this.messages];
+  }
+  reset() {
+    this.messages = [];
+    this.interactions = [];
+  }
+};
+
+// src/core/offline-queue.ts
+var OfflineQueue = class {
+  constructor() {
+    this.queue = [];
+  }
+  enqueue(item) {
+    this.queue.push(item);
+  }
+  drain() {
+    const items = [...this.queue];
+    this.queue = [];
+    return items;
+  }
+  clear() {
+    this.queue = [];
+  }
+  get size() {
+    return this.queue.length;
+  }
+  get items() {
+    return [...this.queue];
+  }
+};
+
+// src/core/websocket-client.ts
+var WebSocketClient = class {
+  constructor(options = {}) {
+    this.socket = null;
+    this.manualClose = false;
+    this.reconnectAttempts = 0;
+    this.bus = new EventBus();
+    this.reconnectDelay = options.reconnectDelay ?? 3e3;
+    this.autoReconnect = options.autoReconnect ?? true;
+    this.logger = {
+      ...console,
+      ...options.logger
+    };
+  }
+  on(event, listener) {
+    return this.bus.on(event, listener);
+  }
+  async connect(url) {
+    this.manualClose = false;
+    if (this.socket) {
+      this.logger.warn("[Autoscriber] WebSocket already connected - closing existing connection");
+      this.socket.close(4e3, "Reconnecting");
+      this.socket = null;
+    }
+    await this.openSocket(url);
+  }
+  openSocket(url) {
+    return new Promise((resolve, reject) => {
+      try {
+        const socket = new WebSocket(url);
+        this.socket = socket;
+        socket.onopen = (event) => {
+          this.logger.info("[Autoscriber] websocket open");
+          this.reconnectAttempts = 0;
+          this.bus.emit("open", event);
+          resolve();
+        };
+        socket.onclose = (event) => {
+          this.logger.warn("[Autoscriber] websocket closed", event.code, event.reason);
+          this.socket = null;
+          this.bus.emit("close", event);
+          if (!this.manualClose && this.autoReconnect) {
+            this.scheduleReconnect(url);
+          }
+        };
+        socket.onerror = (event) => {
+          const errorInfo = {
+            type: event.type,
+            timeStamp: event.timeStamp,
+            readyState: socket.readyState,
+            url: socket.url
+          };
+          if (event instanceof ErrorEvent) {
+            errorInfo.message = event.message;
+            errorInfo.filename = event.filename;
+            errorInfo.lineno = event.lineno;
+            errorInfo.colno = event.colno;
+            if (event.error) {
+              errorInfo.error = event.error instanceof Error ? { name: event.error.name, message: event.error.message, stack: event.error.stack } : String(event.error);
+            }
+          }
+          this.logger.error("[Autoscriber] websocket error", errorInfo);
+          this.bus.emit("error", event);
+          const errorMessage = event instanceof ErrorEvent && event.message ? event.message : `WebSocket error (readyState: ${socket.readyState}, url: ${socket.url})`;
+          const enhancedError = new Error(errorMessage);
+          enhancedError.originalEvent = event;
+          enhancedError.readyState = socket.readyState;
+          enhancedError.url = socket.url;
+          reject(enhancedError);
+        };
+        socket.onmessage = (event) => {
+          this.bus.emit("message", event);
+        };
+      } catch (error) {
+        reject(error);
+      }
+    });
+  }
+  scheduleReconnect(url) {
+    this.reconnectAttempts += 1;
+    const delay = this.reconnectDelay;
+    if (!this.autoReconnect) {
+      return;
+    }
+    this.logger.info("[Autoscriber] scheduling reconnect", { attempt: this.reconnectAttempts, delay });
+    this.bus.emit("reconnecting", this.reconnectAttempts);
+    setTimeout(() => {
+      if (this.manualClose)
+        return;
+      this.openSocket(url).catch((error) => {
+        this.logger.error("[Autoscriber] reconnect attempt failed", error);
+        this.scheduleReconnect(url);
+      });
+    }, delay);
+  }
+  send(payload) {
+    if (!this.socket || this.socket.readyState !== WebSocket.OPEN) {
+      throw new Error("WebSocket not connected");
+    }
+    this.socket.send(payload);
+  }
+  close(code, reason) {
+    this.manualClose = true;
+    this.socket?.close(code, reason);
+    this.socket = null;
+  }
+  get readyState() {
+    return this.socket?.readyState ?? WebSocket.CLOSED;
+  }
+};
+
+// src/utils/base64.ts
+function arrayBufferToBase64(buffer) {
+  let binary = "";
+  const bytes = new Uint8Array(buffer);
+  const len = bytes.byteLength;
+  for (let i = 0; i < len; i += 1) {
+    binary += String.fromCharCode(bytes[i]);
+  }
+  return btoa(binary);
+}
+function base64ToArray(base64) {
+  const binaryString = atob(base64);
+  const len = binaryString.length;
+  const bytes = new Uint8Array(len);
+  for (let i = 0; i < len; i += 1) {
+    bytes[i] = binaryString.charCodeAt(i);
+  }
+  return bytes.buffer;
+}
+
+// src/audio/worklets.ts
+var PCM_PLAYER_PROCESSOR = `
+  class PCMPlayerProcessor extends AudioWorkletProcessor {
+    constructor() {
+      super();
+      this.bufferSize = 24000 * 180;
+      this.buffer = new Float32Array(this.bufferSize);
+      this.writeIndex = 0;
+      this.readIndex = 0;
+      this.port.onmessage = (event) => {
+        if (event.data.command === 'endOfAudio') {
+          this.readIndex = this.writeIndex;
+          return;
+        }
+        const int16Samples = new Int16Array(event.data);
+        this._enqueue(int16Samples);
+      };
+    }
+    _enqueue(int16Samples) {
+      for (let i = 0; i < int16Samples.length; i++) {
+        const floatVal = int16Samples[i] / 32768;
+        this.buffer[this.writeIndex] = floatVal;
+        this.writeIndex = (this.writeIndex + 1) % this.bufferSize;
+        if (this.writeIndex === this.readIndex) {
+          this.readIndex = (this.readIndex + 1) % this.bufferSize;
+        }
+      }
+    }
+    process(inputs, outputs) {
+      const output = outputs[0];
+      const framesPerBlock = output[0].length;
+      for (let frame = 0; frame < framesPerBlock; frame++) {
+        output[0][frame] = this.buffer[this.readIndex];
+        if (output.length > 1) {
+          output[1][frame] = this.buffer[this.readIndex];
+        }
+        if (this.readIndex !== this.writeIndex) {
+          this.readIndex = (this.readIndex + 1) % this.bufferSize;
+        }
+      }
+      return true;
+    }
+  }
+  registerProcessor('pcm-player-processor', PCMPlayerProcessor);
+`;
+var PCM_RECORDER_PROCESSOR = `
+  class PCMProcessor extends AudioWorkletProcessor {
+    process(inputs) {
+      if (inputs.length > 0 && inputs[0].length > 0) {
+        const inputChannel = inputs[0][0];
+        const inputCopy = new Float32Array(inputChannel);
+        this.port.postMessage(inputCopy);
+      }
+      return true;
+    }
+  }
+  registerProcessor("pcm-recorder-processor", PCMProcessor);
+`;
+
+// src/audio/resampler.ts
+function resamplePCM16(inputBuffer, inputSampleRate, outputSampleRate) {
+  if (inputSampleRate === outputSampleRate) {
+    return inputBuffer;
+  }
+  const inputSamples = new Int16Array(inputBuffer.buffer, inputBuffer.byteOffset, inputBuffer.length / 2);
+  const inputLength = inputSamples.length;
+  const ratio = inputSampleRate / outputSampleRate;
+  const outputLength = Math.round(inputLength / ratio);
+  const outputSamples = new Int16Array(outputLength);
+  for (let i = 0; i < outputLength; i++) {
+    const srcIndex = i * ratio;
+    const srcIndexFloor = Math.floor(srcIndex);
+    const srcIndexCeil = Math.min(srcIndexFloor + 1, inputLength - 1);
+    const fraction = srcIndex - srcIndexFloor;
+    const sample1 = inputSamples[srcIndexFloor];
+    const sample2 = inputSamples[srcIndexCeil];
+    outputSamples[i] = Math.round(sample1 + (sample2 - sample1) * fraction);
+  }
+  return new Uint8Array(outputSamples.buffer);
+}
+
+// src/audio/audio-manager.ts
+var AudioManager = class {
+  constructor() {
+    this.recorderContext = null;
+    this.recorderNode = null;
+    this.playerContext = null;
+    this.playerNode = null;
+    this.micStream = null;
+    this.actualSampleRate = null;
+    this.targetSampleRate = 16e3;
+  }
+  async init(options = {}) {
+    this.targetSampleRate = options.targetSampleRate ?? 16e3;
+    await this.setupRecorder(options);
+    await this.setupPlayer(options);
+  }
+  async setupPlayer(options = {}) {
+    if (this.playerContext)
+      return;
+    if (this.actualSampleRate === null) {
+      const tempContext = new AudioContext();
+      this.actualSampleRate = tempContext.sampleRate;
+      tempContext.close();
+    }
+    const audioContext = new AudioContext({
+      sampleRate: this.actualSampleRate
+    });
+    const blob = new Blob([PCM_PLAYER_PROCESSOR], { type: "application/javascript" });
+    const workletURL = URL.createObjectURL(blob);
+    await audioContext.audioWorklet.addModule(workletURL);
+    URL.revokeObjectURL(workletURL);
+    const playerNode = new AudioWorkletNode(audioContext, "pcm-player-processor");
+    playerNode.connect(audioContext.destination);
+    this.playerContext = audioContext;
+    this.playerNode = playerNode;
+  }
+  async setupRecorder(options = {}) {
+    if (this.recorderContext)
+      return;
+    const constraints = { channelCount: 1 };
+    if (options.deviceId) {
+      constraints.deviceId = { exact: options.deviceId };
+    }
+    const stream = await navigator.mediaDevices.getUserMedia({
+      audio: constraints
+    });
+    if (this.actualSampleRate === null) {
+      const tempContext = new AudioContext();
+      const tempSource = tempContext.createMediaStreamSource(stream);
+      this.actualSampleRate = tempContext.sampleRate;
+      tempSource.disconnect();
+      tempContext.close();
+    }
+    const audioContext = new AudioContext({
+      sampleRate: this.actualSampleRate
+    });
+    const blob = new Blob([PCM_RECORDER_PROCESSOR], { type: "application/javascript" });
+    const workletURL = URL.createObjectURL(blob);
+    await audioContext.audioWorklet.addModule(workletURL);
+    URL.revokeObjectURL(workletURL);
+    const source = audioContext.createMediaStreamSource(stream);
+    const recorderNode = new AudioWorkletNode(audioContext, "pcm-recorder-processor");
+    recorderNode.port.onmessage = (event) => {
+      const float32 = event.data;
+      let pcm16 = this.convertFloat32ToPCM(float32);
+      if (this.actualSampleRate && this.actualSampleRate !== this.targetSampleRate) {
+        pcm16 = resamplePCM16(pcm16, this.actualSampleRate, this.targetSampleRate);
+      }
+      options.onRecorderData?.(pcm16);
+    };
+    source.connect(recorderNode);
+    this.recorderContext = audioContext;
+    this.recorderNode = recorderNode;
+    this.micStream = stream;
+  }
+  stop() {
+    this.stopRecorder();
+    this.stopPlayer();
+  }
+  stopRecorder() {
+    this.recorderNode?.disconnect();
+    this.recorderNode = null;
+    this.recorderContext?.close();
+    this.recorderContext = null;
+    if (this.micStream) {
+      this.micStream.getTracks().forEach((track) => track.stop());
+    }
+    this.micStream = null;
+    if (!this.playerContext) {
+      this.actualSampleRate = null;
+    }
+  }
+  stopPlayer() {
+    this.playerNode?.disconnect();
+    this.playerNode = null;
+    this.playerContext?.close();
+    this.playerContext = null;
+    if (!this.recorderContext) {
+      this.actualSampleRate = null;
+    }
+  }
+  teardown() {
+    this.stop();
+  }
+  playbackPcm(buffer) {
+    if (!this.playerNode)
+      return;
+    this.playerNode.port.postMessage(buffer);
+  }
+  endOfAudio() {
+    this.playerNode?.port.postMessage({ command: "endOfAudio" });
+  }
+  convertFloat32ToPCM(inputData) {
+    const pcm16 = new Int16Array(inputData.length);
+    for (let i = 0; i < inputData.length; i += 1) {
+      pcm16[i] = Math.max(-1, Math.min(1, inputData[i])) * 32767;
+    }
+    return new Uint8Array(pcm16.buffer);
+  }
+};
+
+// src/audio/silence-detector.ts
+function convertPCMToFloat32(pcmBuffer) {
+  const int16View = new Int16Array(
+    pcmBuffer.buffer,
+    pcmBuffer.byteOffset,
+    pcmBuffer.byteLength / 2
+  );
+  const float32Array = new Float32Array(int16View.length);
+  for (let i = 0; i < int16View.length; i += 1) {
+    float32Array[i] = int16View[i] / 32768;
+  }
+  return float32Array;
+}
+function analyseAudioAmplitude(channelData, silenceThreshold = 0.01, silenceRatio = 0.95) {
+  let silentSamples = 0;
+  const totalSamples = channelData.length;
+  for (let i = 0; i < channelData.length; i += 1) {
+    const amplitude = Math.abs(channelData[i]);
+    if (amplitude < silenceThreshold) {
+      silentSamples += 1;
+    }
+  }
+  const silencePercentage = silentSamples / totalSamples;
+  const isSilence = silencePercentage > silenceRatio;
+  return {
+    isSilence,
+    silencePercentage,
+    totalSamples,
+    silentSamples
+  };
+}
+function analyseAudioEnergy(channelData, energyThreshold = 1e-3, silenceRatio = 0.9) {
+  const windowSize = 1024;
+  const energyLevels = [];
+  for (let i = 0; i < channelData.length; i += windowSize) {
+    let energy = 0;
+    const windowEnd = Math.min(i + windowSize, channelData.length);
+    for (let j = i; j < windowEnd; j += 1) {
+      energy += channelData[j] * channelData[j];
+    }
+    energy = energy / (windowEnd - i);
+    energyLevels.push(energy);
+  }
+  const silentWindows = energyLevels.filter((energy) => energy < energyThreshold).length;
+  const silencePercentage = energyLevels.length === 0 ? 1 : silentWindows / energyLevels.length;
+  const averageEnergy = energyLevels.length === 0 ? 0 : energyLevels.reduce((a, b) => a + b, 0) / energyLevels.length;
+  return {
+    isSilence: silencePercentage > silenceRatio,
+    silencePercentage,
+    averageEnergy,
+    energyLevels
+  };
+}
+function detectSilence(pcmBuffer) {
+  try {
+    const channelData = convertPCMToFloat32(pcmBuffer);
+    const amplitudeResult = analyseAudioAmplitude(channelData);
+    if (amplitudeResult.isSilence) {
+      const energyResult = analyseAudioEnergy(channelData);
+      if (energyResult.isSilence) {
+        return {
+          isSilence: true,
+          amplitudeAnalysis: amplitudeResult,
+          energyAnalysis: {
+            silencePercentage: energyResult.silencePercentage,
+            averageEnergy: energyResult.averageEnergy
+          }
+        };
+      }
+      return {
+        isSilence: false,
+        amplitudeAnalysis: amplitudeResult,
+        energyAnalysis: {
+          silencePercentage: energyResult.silencePercentage,
+          averageEnergy: energyResult.averageEnergy
+        }
+      };
+    }
+    return {
+      isSilence: false,
+      amplitudeAnalysis: amplitudeResult
+    };
+  } catch (error) {
+    console.error("[Autoscriber] silence detection failed", error);
+    return {
+      isSilence: false,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+
+// src/audio/permissions.ts
+async function checkMicrophonePermission(language) {
+  const lang = validateLanguage(language);
+  if (!("navigator" in globalThis) || !navigator.mediaDevices) {
+    return {
+      granted: false,
+      state: "denied",
+      message: translate(lang, "microphoneAccessError")
+    };
+  }
+  try {
+    if ("permissions" in navigator && "query" in navigator.permissions) {
+      try {
+        const permissionResult = await navigator.permissions.query({ name: "microphone" });
+        if (permissionResult.state === "granted") {
+          return { granted: true, state: "granted" };
+        }
+        if (permissionResult.state === "denied") {
+          return {
+            granted: false,
+            state: "denied",
+            message: translate(lang, "microphoneAccessDenied")
+          };
+        }
+      } catch (error) {
+        console.warn("[Autoscriber] permissions API error", error);
+      }
+    }
+    const stream = await navigator.mediaDevices.getUserMedia({ audio: { channelCount: 1 } });
+    stream.getTracks().forEach((track) => track.stop());
+    return { granted: true, state: "granted" };
+  } catch (error) {
+    const err = error;
+    if (err?.name === "NotAllowedError" || err?.name === "PermissionDeniedError") {
+      return {
+        granted: false,
+        state: "denied",
+        message: translate(lang, "microphoneRequired")
+      };
+    }
+    if (err?.name === "NotFoundError" || err?.name === "DevicesNotFoundError") {
+      return {
+        granted: false,
+        state: "denied",
+        message: translate(lang, "microphoneNotFound")
+      };
+    }
+    return {
+      granted: false,
+      state: "denied",
+      message: translate(lang, "microphoneAccessError")
+    };
+  }
+}
+async function getAvailableMicrophones(language) {
+  const lang = validateLanguage(language);
+  if (!("navigator" in globalThis) || !navigator.mediaDevices?.enumerateDevices) {
+    console.warn("[Autoscriber] media devices API unavailable");
+    return [];
+  }
+  try {
+    const devices = await navigator.mediaDevices.enumerateDevices();
+    return devices.filter((device) => device.kind === "audioinput").map((device) => ({
+      deviceId: device.deviceId,
+      label: device.label || `${translate(lang, "microphone")} ${device.deviceId.slice(0, 8)}`,
+      groupId: device.groupId
+    }));
+  } catch (error) {
+    console.error("[Autoscriber] failed to enumerate microphones", error);
+    return [];
+  }
+}
+
+// src/utils/token.ts
+function decodeJwtPayload(token) {
+  const parts = token.split(".");
+  if (parts.length !== 3) {
+    return null;
+  }
+  try {
+    const payload = JSON.parse(atob(parts[1]));
+    return payload;
+  } catch (error) {
+    console.error("[Autoscriber] failed to decode JWT payload", error);
+    return null;
+  }
+}
+function getSessionIdFromToken(token) {
+  const payload = decodeJwtPayload(token);
+  if (!payload)
+    return null;
+  const sessionId = payload.sessionId ?? payload.session_id;
+  return typeof sessionId === "string" ? sessionId : null;
+}
+function isTokenExpiredOrExpiring(token, secondsBuffer = 10) {
+  const payload = decodeJwtPayload(token);
+  if (!payload)
+    return true;
+  const exp = payload.exp;
+  if (typeof exp !== "number")
+    return true;
+  const current = Math.floor(Date.now() / 1e3);
+  return current >= exp - secondsBuffer;
+}
+
+// src/audio/wake-lock.ts
+var WakeLockManager = class _WakeLockManager {
+  constructor() {
+    this.wakeLock = null;
+  }
+  /**
+   * Check if Wake Lock API is supported in the current browser
+   */
+  static isSupported() {
+    return typeof navigator !== "undefined" && "wakeLock" in navigator;
+  }
+  /**
+   * Request a wake lock to prevent the screen from sleeping
+   * @returns Promise that resolves when wake lock is acquired, or rejects if not supported/failed
+   */
+  async request() {
+    if (!_WakeLockManager.isSupported()) {
+      throw new Error("Wake Lock API is not supported in this browser");
+    }
+    try {
+      this.wakeLock = await navigator.wakeLock.request("screen");
+      this.wakeLock.addEventListener("release", () => {
+        this.wakeLock = null;
+      });
+    } catch (error) {
+      throw new Error(`Failed to acquire wake lock: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  /**
+   * Release the wake lock if it's currently active
+   */
+  async release() {
+    if (this.wakeLock) {
+      try {
+        await this.wakeLock.release();
+      } catch (error) {
+        console.warn("[WakeLock] Error releasing wake lock", error);
+      } finally {
+        this.wakeLock = null;
+      }
+    }
+  }
+  /**
+   * Check if a wake lock is currently active
+   */
+  isActive() {
+    return this.wakeLock !== null;
+  }
+  /**
+   * Clean up resources (release wake lock and remove listeners)
+   */
+  async destroy() {
+    await this.release();
+  }
+};
+
+// src/core/assistant-client.ts
+var TOKEN_REFRESH_THROTTLE_MS = 15e3;
+var AssistantClient = class {
+  constructor(options) {
+    this.bus = new EventBus();
+    this.logger = createLogger();
+    this.messageStore = new MessageStore();
+    this.offlineQueue = new OfflineQueue();
+    this.audioManager = new AudioManager();
+    this.wakeLockManager = new WakeLockManager();
+    this.bufferTimer = null;
+    this.audioBuffer = [];
+    this.voiceCommandBuffer = [];
+    this.manualDisconnect = false;
+    this.pendingRequests = /* @__PURE__ */ new Map();
+    this.reconnectTimer = null;
+    this.lastTokenRefreshAttempt = null;
+    this.tokenRefreshInFlight = false;
+    this.hasConnected = false;
+    this.handleBrowserOnline = () => {
+      this.snapshot.connection.online = true;
+      if (this.snapshot.connection.reason === "offline") {
+        this.snapshot.connection.reason = "reconnecting";
+      }
+      this.emitConnection();
+      this.manualDisconnect = false;
+      if (this.websocket.readyState !== WebSocket.OPEN) {
+        void this.connectWebsocket();
+      } else {
+        this.flushOfflineQueue();
+      }
+    };
+    this.handleBrowserOffline = () => {
+      if (!this.snapshot.connection.online && this.snapshot.connection.reason === "offline") {
+        return;
+      }
+      this.snapshot.connection.online = false;
+      this.snapshot.connection.reason = "offline";
+      if (this.snapshot.connection.websocketStatus === "open") {
+        this.snapshot.connection.websocketStatus = "closing";
+      }
+      this.snapshot.connection.buffering = this.offlineQueue.size > 0 || this.snapshot.offlineQueueLength > 0;
+      this.emitConnection();
+      if (this.snapshot.recording.isRecording) {
+        if (this.snapshot.recording.mode === "transcription") {
+          this.pushInteraction({
+            id: generateMessageId(),
+            label: translate(this.snapshot.language, "transcriptionBufferingOffline"),
+            status: "pending",
+            type: "transcription",
+            metadata: { reason: "offline" }
+          });
+        } else if (this.snapshot.recording.mode === "voice_command") {
+          this.snapshot.recording.wasTranscriptionActive = false;
+          this.snapshot.recording.transcriptionPausedState = false;
+          this.pushInteraction({
+            id: generateMessageId(),
+            label: translate(this.snapshot.language, "voiceCommandCancelledOffline"),
+            status: "error",
+            type: "voice"
+          });
+          this.stopRecording();
+        }
+      }
+      this.pushInteraction({
+        id: generateMessageId(),
+        label: translate(this.snapshot.language, "networkOffline"),
+        status: "error",
+        type: "info"
+      });
+      const readyState = this.websocket.readyState;
+      if (readyState === WebSocket.OPEN || readyState === WebSocket.CONNECTING) {
+        this.manualDisconnect = true;
+        this.websocket.close(4001, "Browser offline");
+      }
+    };
+    if (!options?.token) {
+      throw new Error("Autoscriber Assistant requires a token");
+    }
+    this.options = options;
+    this.logger = createLogger(options.logger);
+    this.token = options.token;
+    const language = validateLanguage(options.language);
+    this.snapshot = {
+      language,
+      debugMode: options.debugMode ?? false,
+      messages: [],
+      interactions: [],
+      connection: {
+        websocketStatus: "idle",
+        online: typeof navigator !== "undefined" ? navigator.onLine : true,
+        buffering: false
+      },
+      microphones: {
+        available: [],
+        permission: "unknown"
+      },
+      recording: {
+        mode: "idle",
+        transcriptionId: null,
+        isRecording: false,
+        isPaused: false,
+        bufferedChunks: 0,
+        wasTranscriptionActive: false,
+        transcriptionPausedState: false
+      },
+      offlineQueueLength: 0,
+      lastUpdatedAt: Date.now()
+    };
+    this.websocket = new WebSocketClient({
+      logger: options.logger,
+      reconnectDelay: options.websocketReconnectDelay,
+      autoReconnect: false
+    });
+    this.registerWebsocketEvents();
+    this.setupNetworkListeners();
+    this.initializeMicrophones();
+    this.connectWebsocket();
+    const sessionId = getSessionIdFromToken(this.token);
+    this.logStructured("info", "Session created", {
+      sessionId: sessionId ?? "unknown",
+      language,
+      websocketUrl: options.websocketUrl ?? "default",
+      debugMode: options.debugMode ?? false
+    });
+  }
+  /**
+   * Internal structured logging helper for Datadog monitoring
+   * Formats logs as structured JSON for better parsing and filtering
+   */
+  logStructured(level, message, metadata) {
+    try {
+      const structuredLog = {
+        message,
+        level,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        sdk: "autoscriber-core",
+        ...metadata
+      };
+      const logMessage = `[Autoscriber] ${message}${metadata ? ` ${JSON.stringify(metadata)}` : ""}`;
+      if (this.options.onLog) {
+        try {
+          this.options.onLog(level, message, structuredLog);
+        } catch (error) {
+          this.logger.warn("[Autoscriber] onLog callback failed", error);
+        }
+      }
+      switch (level) {
+        case "info":
+          this.logger.info(logMessage, structuredLog);
+          break;
+        case "warn":
+          this.logger.warn(logMessage, structuredLog);
+          break;
+        case "error":
+          this.logger.error(logMessage, structuredLog);
+          break;
+      }
+    } catch (error) {
+      this.logger.error(`[Autoscriber] Failed to log structured message: ${message}`, error);
+    }
+  }
+  on(event, listener) {
+    return this.bus.on(event, listener);
+  }
+  getSnapshot() {
+    return { ...this.snapshot, messages: this.messageStore.getMessages(), interactions: this.messageStore.getInteractions() };
+  }
+  setDebugMode(enabled) {
+    const next = Boolean(enabled);
+    if (this.snapshot.debugMode === next) {
+      return;
+    }
+    this.snapshot.debugMode = next;
+    this.emitSnapshot();
+  }
+  setLanguage(language) {
+    const validatedLanguage = validateLanguage(language);
+    if (this.snapshot.language === validatedLanguage) {
+      return;
+    }
+    const oldLanguage = this.snapshot.language;
+    this.snapshot.language = validatedLanguage;
+    this.emitSnapshot();
+    this.bus.emit("language:changed", validatedLanguage);
+    const sessionId = getSessionIdFromToken(this.token);
+    this.logStructured("info", "Language changed", {
+      oldLanguage,
+      newLanguage: validatedLanguage,
+      sessionId: sessionId ?? "unknown"
+    });
+  }
+  destroy() {
+    this.manualDisconnect = true;
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    this.websocket.close(1e3, "Destroyed");
+    this.audioManager.teardown();
+    void this.wakeLockManager.destroy().catch((error) => {
+      this.logger.warn("[Autoscriber] Error releasing wake lock on destroy", error);
+    });
+    if (typeof window !== "undefined") {
+      window.removeEventListener("online", this.handleBrowserOnline);
+      window.removeEventListener("offline", this.handleBrowserOffline);
+    }
+    if (this.bufferTimer) {
+      clearInterval(this.bufferTimer);
+      this.bufferTimer = null;
+    }
+    this.messageStore.reset();
+    this.bus.clear();
+  }
+  /** Chat related methods */
+  sendTextMessage(text) {
+    const trimmed = text.trim();
+    if (!trimmed) {
+      throw new Error("Cannot send empty message");
+    }
+    const id = generateMessageId();
+    const message = this.messageStore.createMessage({
+      id,
+      request: trimmed,
+      type: "chat"
+    });
+    this.emitMessages();
+    this.sendMessage({
+      jsonrpc: "2.0",
+      id,
+      method: "chat",
+      params: {
+        mediaType: "text/plain",
+        data: trimmed
+      }
+    });
+    return message;
+  }
+  /** Recording controls */
+  async startTranscription(customId) {
+    if (this.snapshot.recording.isRecording) {
+      this.logger.warn("[Autoscriber] startTranscription called while recording");
+      return this.snapshot.recording.transcriptionId ?? "";
+    }
+    const permission = await checkMicrophonePermission(this.snapshot.language);
+    this.updateMicrophonePermission(permission.state);
+    if (!permission.granted) {
+      if (permission.message) {
+        this.pushInteraction({
+          id: generateMessageId(),
+          label: permission.message,
+          status: "error",
+          type: "transcription"
+        });
+      }
+      return "";
+    }
+    const transcriptionId = customId ?? generateMessageId();
+    await this.audioManager.init({
+      deviceId: this.snapshot.microphones.selected?.deviceId,
+      targetSampleRate: this.options.targetSampleRate,
+      onRecorderData: (pcm16) => this.handleRecorderData(pcm16, "transcription")
+    });
+    try {
+      await this.wakeLockManager.request();
+    } catch (error) {
+      this.logger.warn("[Autoscriber] Failed to acquire wake lock", error);
+    }
+    this.audioBuffer = [];
+    this.snapshot.recording = {
+      ...this.snapshot.recording,
+      mode: "transcription",
+      transcriptionId,
+      isRecording: true,
+      isPaused: false,
+      bufferedChunks: 0
+    };
+    this.emitRecording();
+    const sessionId = getSessionIdFromToken(this.token);
+    this.logStructured("info", "Transcription started", {
+      transcriptionId,
+      mode: "transcription",
+      sessionId: sessionId ?? "unknown",
+      deviceId: this.snapshot.microphones.selected?.deviceId
+    });
+    this.pushInteraction({
+      id: transcriptionId,
+      label: translate(this.snapshot.language, "transcriptionStarted"),
+      status: "pending",
+      type: "transcription"
+    });
+    if (this.bufferTimer) {
+      clearInterval(this.bufferTimer);
+    }
+    this.bufferTimer = window.setInterval(() => {
+      if (this.snapshot.recording.mode === "transcription" && this.audioBuffer.length > 0 && !this.snapshot.recording.isPaused) {
+        this.sendBufferedAudio();
+      }
+    }, 5e3);
+    return transcriptionId;
+  }
+  pauseTranscription() {
+    if (this.snapshot.recording.mode !== "transcription")
+      return;
+    this.snapshot.recording.isPaused = !this.snapshot.recording.isPaused;
+    this.emitRecording();
+  }
+  stopRecording() {
+    if (!this.snapshot.recording.isRecording)
+      return;
+    const currentMode = this.snapshot.recording.mode;
+    const shouldResumeTranscription = currentMode === "voice_command" && this.snapshot.recording.wasTranscriptionActive;
+    const resumePausedState = this.snapshot.recording.transcriptionPausedState;
+    if (currentMode === "transcription") {
+      const transcriptionId = this.snapshot.recording.transcriptionId ?? generateMessageId();
+      this.pushInteraction({
+        id: transcriptionId,
+        label: translate(this.snapshot.language, "transcriptionStopped"),
+        status: "success",
+        type: "transcription"
+      });
+      if (this.audioBuffer.length > 0) {
+        this.sendBufferedAudio(true);
+      }
+      const sessionId = getSessionIdFromToken(this.token);
+      this.logStructured("info", "Transcription stopped", {
+        transcriptionId,
+        mode: "transcription",
+        sessionId: sessionId ?? "unknown",
+        bufferedChunks: this.snapshot.recording.bufferedChunks
+      });
+    } else if (currentMode === "voice_command") {
+      if (this.voiceCommandBuffer.length > 0) {
+        this.sendVoiceCommandAudio();
+      }
+    }
+    this.audioManager.stop();
+    void this.wakeLockManager.release().catch((error) => {
+      this.logger.warn("[Autoscriber] Failed to release wake lock", error);
+    });
+    if (shouldResumeTranscription) {
+      void this.resumeTranscriptionAfterVoiceCommand(resumePausedState);
+    } else {
+      this.resetRecordingState();
+    }
+  }
+  async startVoiceCommand() {
+    if (this.snapshot.recording.mode === "transcription") {
+      this.snapshot.recording.wasTranscriptionActive = true;
+      this.snapshot.recording.transcriptionPausedState = this.snapshot.recording.isPaused;
+      this.snapshot.recording.isPaused = true;
+    }
+    const permission = await checkMicrophonePermission(this.snapshot.language);
+    this.updateMicrophonePermission(permission.state);
+    if (!permission.granted) {
+      if (permission.message) {
+        this.pushInteraction({
+          id: generateMessageId(),
+          label: permission.message,
+          status: "error",
+          type: "voice"
+        });
+      }
+      return;
+    }
+    await this.audioManager.init({
+      deviceId: this.snapshot.microphones.selected?.deviceId,
+      targetSampleRate: this.options.targetSampleRate,
+      onRecorderData: (pcm16) => this.handleRecorderData(pcm16, "voice_command")
+    });
+    try {
+      await this.wakeLockManager.request();
+    } catch (error) {
+      this.logger.warn("[Autoscriber] Failed to acquire wake lock", error);
+    }
+    this.voiceCommandBuffer = [];
+    this.snapshot.recording = {
+      ...this.snapshot.recording,
+      mode: "voice_command",
+      isRecording: true,
+      isPaused: false,
+      bufferedChunks: 0
+    };
+    this.emitRecording();
+    const sessionId = getSessionIdFromToken(this.token);
+    this.logStructured("info", "Voice command started", {
+      mode: "voice_command",
+      sessionId: sessionId ?? "unknown",
+      deviceId: this.snapshot.microphones.selected?.deviceId
+    });
+  }
+  /** FHIR context */
+  setFhirContext(resource) {
+    const id = generateMessageId();
+    const resourceType = typeof resource === "object" && resource && "resourceType" in resource ? String(resource.resourceType) : "Resource";
+    this.pushInteraction({
+      id,
+      label: `Updating ${resourceType} context`,
+      status: "pending",
+      type: "fhir",
+      metadata: { resourceType }
+    });
+    this.sendMessage({
+      jsonrpc: "2.0",
+      id,
+      method: "fhirContext",
+      params: {
+        mediaType: "application/fhir+json",
+        data: resource
+      }
+    });
+    this.pendingRequests.set(id, { id, method: "fhirContext" });
+    return id;
+  }
+  fillQuestionnaire(context) {
+    const id = generateMessageId();
+    const message = this.messageStore.createMessage({
+      id,
+      request: null,
+      type: "questionnaire"
+    });
+    this.emitMessages();
+    this.pushInteraction({
+      id,
+      label: "Summarising",
+      status: "pending",
+      type: "questionnaire"
+    });
+    this.sendMessage({
+      jsonrpc: "2.0",
+      id,
+      method: "tool",
+      params: {
+        name: "fillQuestionnaire",
+        args: context ? { context } : {}
+      }
+    });
+    this.pendingRequests.set(id, { id, method: "fillQuestionnaire" });
+    return id;
+  }
+  /** Microphone controls */
+  async refreshMicrophones() {
+    const microphones = await getAvailableMicrophones(this.snapshot.language);
+    const selected = this.snapshot.microphones.selected;
+    const stillAvailable = selected && microphones.find((mic) => mic.deviceId === selected.deviceId);
+    this.snapshot.microphones = {
+      ...this.snapshot.microphones,
+      available: microphones,
+      selected: stillAvailable ?? microphones[0] ?? selected
+    };
+    this.emitMicrophones();
+  }
+  setSelectedMicrophone(device) {
+    this.snapshot.microphones = {
+      ...this.snapshot.microphones,
+      selected: device
+    };
+    if (typeof window !== "undefined" && window.localStorage) {
+      window.localStorage.setItem(
+        "autoscriber_selected_microphone",
+        JSON.stringify(device)
+      );
+    }
+    this.emitMicrophones();
+  }
+  /** Internal plumbing */
+  registerWebsocketEvents() {
+    this.websocket.on("open", () => {
+      const wasOffline = this.hasConnected && (this.snapshot.connection.reason === "offline" || this.snapshot.connection.reason === "reconnecting");
+      if (this.reconnectTimer) {
+        clearTimeout(this.reconnectTimer);
+        this.reconnectTimer = null;
+      }
+      this.snapshot.connection.websocketStatus = "open";
+      this.snapshot.connection.reason = void 0;
+      this.snapshot.connection.lastError = void 0;
+      this.snapshot.connection.buffering = this.offlineQueue.size > 0;
+      this.emitConnection();
+      if (wasOffline) {
+        this.pushInteraction({
+          id: generateMessageId(),
+          label: translate(this.snapshot.language, "connectionRestored"),
+          status: "success",
+          type: "info"
+        });
+      }
+      this.flushOfflineQueue();
+      this.hasConnected = true;
+    });
+    this.websocket.on("close", () => {
+      const preserveOffline = this.snapshot.connection.reason === "offline";
+      this.snapshot.connection.websocketStatus = "closed";
+      if (!preserveOffline) {
+        this.snapshot.connection.reason = this.manualDisconnect ? "manual" : "closed";
+      }
+      this.emitConnection();
+      this.scheduleReconnectAttempt();
+    });
+    this.websocket.on("error", (event) => {
+      this.snapshot.connection.websocketStatus = "closed";
+      if (this.snapshot.connection.reason !== "offline") {
+        this.snapshot.connection.reason = "error";
+      }
+      let errorMessage;
+      let errorDetails = {};
+      if (event instanceof ErrorEvent) {
+        errorMessage = event.message || "WebSocket error event";
+        errorDetails = {
+          type: event.type,
+          filename: event.filename,
+          lineno: event.lineno,
+          colno: event.colno,
+          error: event.error ? String(event.error) : void 0
+        };
+      } else if (event instanceof Event) {
+        errorMessage = `WebSocket error: ${event.type}`;
+        errorDetails = {
+          type: event.type,
+          target: event.target ? String(event.target) : void 0,
+          currentTarget: event.currentTarget ? String(event.currentTarget) : void 0,
+          timeStamp: event.timeStamp
+        };
+      } else {
+        errorMessage = "WebSocket error";
+        errorDetails = {
+          errorType: typeof event,
+          errorValue: String(event)
+        };
+      }
+      this.snapshot.connection.lastError = errorMessage;
+      this.emitConnection();
+      const sessionId = getSessionIdFromToken(this.token);
+      const wsUrl = this.buildWebsocketUrl();
+      this.logStructured("error", "WebSocket error event", {
+        error: errorMessage,
+        ...errorDetails,
+        websocketUrl: wsUrl,
+        sessionId: sessionId ?? "unknown",
+        readyState: this.websocket.readyState
+      });
+      this.scheduleReconnectAttempt();
+    });
+    this.websocket.on("reconnecting", () => {
+      if (this.snapshot.connection.reason === "offline")
+        return;
+      this.snapshot.connection.websocketStatus = "connecting";
+      this.snapshot.connection.reason = "reconnecting";
+      this.emitConnection();
+    });
+    this.websocket.on("message", (event) => {
+      this.handleMessage(event.data);
+    });
+  }
+  setupNetworkListeners() {
+    if (typeof window === "undefined")
+      return;
+    window.addEventListener("online", this.handleBrowserOnline);
+    window.addEventListener("offline", this.handleBrowserOffline);
+    if (!navigator.onLine) {
+      this.handleBrowserOffline();
+    }
+  }
+  scheduleReconnectAttempt() {
+    if (this.manualDisconnect) {
+      return;
+    }
+    if (!this.snapshot.connection.online) {
+      return;
+    }
+    if (this.reconnectTimer) {
+      return;
+    }
+    const delay = this.options.websocketReconnectDelay ?? 3e3;
+    if (this.hasConnected && this.snapshot.connection.reason !== "offline") {
+      this.snapshot.connection.reason = "reconnecting";
+    }
+    if (this.snapshot.connection.websocketStatus !== "open") {
+      this.snapshot.connection.websocketStatus = "connecting";
+    }
+    this.emitConnection();
+    this.reconnectTimer = setTimeout(() => {
+      this.reconnectTimer = null;
+      if (this.manualDisconnect || !this.snapshot.connection.online) {
+        return;
+      }
+      void this.connectWebsocket();
+    }, delay);
+  }
+  async initializeMicrophones() {
+    if (typeof window !== "undefined" && window.localStorage) {
+      try {
+        const stored = window.localStorage.getItem("autoscriber_selected_microphone");
+        if (stored) {
+          const parsed = JSON.parse(stored);
+          this.snapshot.microphones.selected = parsed;
+        }
+      } catch (error) {
+        this.logger.warn("[Autoscriber] unable to parse stored microphone", error);
+      }
+    }
+    await this.refreshMicrophones();
+  }
+  async connectWebsocket() {
+    try {
+      if (this.options.refreshToken && !this.tokenRefreshInFlight) {
+        const isExpired = isTokenExpiredOrExpiring(this.token, 0);
+        const isExpiringSoon = isTokenExpiredOrExpiring(this.token);
+        if (isExpired || isExpiringSoon) {
+          const now = Date.now();
+          const throttleElapsed = !this.lastTokenRefreshAttempt || now - this.lastTokenRefreshAttempt >= TOKEN_REFRESH_THROTTLE_MS;
+          if (isExpired || throttleElapsed) {
+            this.lastTokenRefreshAttempt = now;
+            const sessionId = getSessionIdFromToken(this.token);
+            if (sessionId) {
+              this.tokenRefreshInFlight = true;
+              try {
+                const newToken = await this.options.refreshToken(sessionId);
+                if (newToken) {
+                  this.token = newToken;
+                  this.lastTokenRefreshAttempt = null;
+                  this.logStructured("info", "Token refresh succeeded", {
+                    sessionId,
+                    wasExpired: isExpired
+                  });
+                } else if (isExpired) {
+                  this.logger.warn("[Autoscriber] refresh returned no token while current token expired");
+                  this.lastTokenRefreshAttempt = null;
+                  this.logStructured("warn", "Token refresh returned no token", {
+                    sessionId,
+                    wasExpired: true
+                  });
+                }
+              } catch (refreshError) {
+                this.logger.error("[Autoscriber] token refresh failed", refreshError);
+                this.logStructured("error", "Token refresh failed", {
+                  sessionId,
+                  wasExpired: isExpired,
+                  error: refreshError instanceof Error ? refreshError.message : String(refreshError)
+                });
+                if (isExpired) {
+                  this.lastTokenRefreshAttempt = null;
+                }
+              } finally {
+                this.tokenRefreshInFlight = false;
+              }
+            }
+          }
+          if (isExpired && isTokenExpiredOrExpiring(this.token, 0)) {
+            throw new Error("Token expired and refresh unavailable");
+          }
+        }
+      }
+      const wsUrl = this.buildWebsocketUrl();
+      this.snapshot.connection.websocketStatus = "connecting";
+      if (this.hasConnected && this.snapshot.connection.reason !== "offline") {
+        this.snapshot.connection.reason = "reconnecting";
+      }
+      this.emitConnection();
+      await this.websocket.connect(wsUrl);
+    } catch (error) {
+      this.logger.error("[Autoscriber] failed to connect websocket", error);
+      let errorMessage;
+      let errorDetails = {};
+      if (error instanceof Error) {
+        errorMessage = error.message;
+        errorDetails = {
+          name: error.name,
+          stack: error.stack
+        };
+      } else if (error instanceof ErrorEvent) {
+        errorMessage = error.message || "WebSocket error event";
+        errorDetails = {
+          type: error.type,
+          filename: error.filename,
+          lineno: error.lineno,
+          colno: error.colno,
+          error: error.error ? String(error.error) : void 0
+        };
+      } else if (error instanceof Event) {
+        errorMessage = `WebSocket error: ${error.type}`;
+        errorDetails = {
+          type: error.type,
+          target: error.target ? String(error.target) : void 0,
+          currentTarget: error.currentTarget ? String(error.currentTarget) : void 0,
+          timeStamp: error.timeStamp
+        };
+      } else {
+        errorMessage = String(error);
+        errorDetails = {
+          errorType: typeof error,
+          errorValue: String(error)
+        };
+      }
+      this.snapshot.connection.lastError = errorMessage;
+      this.snapshot.connection.websocketStatus = "closed";
+      if (this.snapshot.connection.reason !== "offline") {
+        this.snapshot.connection.reason = "error";
+      }
+      this.emitConnection();
+      const sessionId = getSessionIdFromToken(this.token);
+      const wsUrl = this.buildWebsocketUrl();
+      this.logStructured("error", "WebSocket connection failed", {
+        error: errorMessage,
+        ...errorDetails,
+        websocketUrl: wsUrl,
+        sessionId: sessionId ?? "unknown"
+      });
+      this.scheduleReconnectAttempt();
+    }
+  }
+  buildWebsocketUrl() {
+    if (this.options.websocketUrl) {
+      return `${this.options.websocketUrl}?token=${this.token}`;
+    }
+    if (typeof window === "undefined") {
+      throw new Error("Window is not available to resolve WebSocket URL");
+    }
+    const origin = window.location.origin;
+    const wsBase = origin.replace(/^http/, "ws");
+    return `${wsBase}/ws?token=${this.token}`;
+  }
+  sendMessage(payload) {
+    if (this.snapshot.connection.online && this.websocket.readyState === WebSocket.OPEN) {
+      const message = JSON.stringify(payload);
+      this.websocket.send(message);
+      return;
+    }
+    const wasEmpty = this.offlineQueue.size === 0;
+    this.offlineQueue.enqueue(payload);
+    this.snapshot.offlineQueueLength = this.offlineQueue.size;
+    this.snapshot.connection.buffering = true;
+    if (wasEmpty) {
+      this.pushInteraction({
+        id: generateMessageId(),
+        label: translate(this.snapshot.language, "offlineBuffering"),
+        status: "pending",
+        type: "info"
+      });
+    }
+    this.emitConnection();
+  }
+  flushOfflineQueue() {
+    if (this.offlineQueue.size === 0) {
+      if (this.snapshot.connection.buffering) {
+        this.snapshot.connection.buffering = false;
+        this.emitConnection();
+      }
+      return;
+    }
+    const items = this.offlineQueue.drain();
+    this.snapshot.offlineQueueLength = 0;
+    items.forEach((payload) => this.sendMessage(payload));
+    const hasQueued = this.offlineQueue.size > 0;
+    this.snapshot.connection.buffering = hasQueued;
+    this.snapshot.offlineQueueLength = hasQueued ? this.offlineQueue.size : 0;
+    this.emitConnection();
+  }
+  emitSnapshot() {
+    this.snapshot.lastUpdatedAt = Date.now();
+    this.bus.emit("snapshot", this.getSnapshot());
+  }
+  emitMessages() {
+    const messages = this.messageStore.getMessages();
+    this.snapshot.messages = messages;
+    this.bus.emit("messages:updated", messages);
+    this.emitSnapshot();
+  }
+  emitInteractions() {
+    const interactions = this.messageStore.getInteractions();
+    this.snapshot.interactions = interactions;
+    this.bus.emit("interactions:updated", interactions);
+    this.emitSnapshot();
+  }
+  emitConnection() {
+    this.bus.emit("connection:changed", this.snapshot.connection);
+    this.emitSnapshot();
+  }
+  emitRecording() {
+    this.bus.emit("recording:changed", this.snapshot.recording);
+    this.emitSnapshot();
+  }
+  emitMicrophones() {
+    this.bus.emit("microphones:changed", this.snapshot.microphones);
+    this.emitSnapshot();
+  }
+  pushInteraction(pill) {
+    this.messageStore.upsertInteraction(pill);
+    this.emitInteractions();
+  }
+  updateMicrophonePermission(state) {
+    this.snapshot.microphones.permission = state;
+    this.emitMicrophones();
+  }
+  handleRecorderData(pcm16, mode) {
+    if (mode === "transcription") {
+      if (!this.snapshot.recording.isRecording || this.snapshot.recording.mode !== "transcription") {
+        return;
+      }
+      if (!this.snapshot.recording.isPaused) {
+        this.audioBuffer.push(pcm16);
+        this.snapshot.recording.bufferedChunks = this.audioBuffer.length;
+      }
+    } else if (mode === "voice_command") {
+      if (!this.snapshot.recording.isRecording || this.snapshot.recording.mode !== "voice_command") {
+        return;
+      }
+      this.voiceCommandBuffer.push(pcm16);
+    }
+  }
+  sendBufferedAudio(isFinal = false) {
+    if (!this.snapshot.recording.transcriptionId || this.audioBuffer.length === 0) {
+      return;
+    }
+    const combined = this.concatPcmChunks(this.audioBuffer);
+    this.audioBuffer = [];
+    this.snapshot.recording.bufferedChunks = 0;
+    this.emitRecording();
+    const payload = {
+      jsonrpc: "2.0",
+      method: "transcribe",
+      params: {
+        id: this.snapshot.recording.transcriptionId,
+        mediaType: "audio/pcm",
+        data: arrayBufferToBase64(combined.buffer),
+        isFinal
+      }
+    };
+    if (!this.messageStore.getMessageById(this.snapshot.recording.transcriptionId)) {
+      const message = {
+        id: this.snapshot.recording.transcriptionId,
+        request: null,
+        partialResults: [],
+        result: null,
+        type: "transcription"
+      };
+      this.messageStore.addMessage(message);
+      payload.id = this.snapshot.recording.transcriptionId;
+    }
+    this.sendMessage(payload);
+  }
+  concatPcmChunks(chunks) {
+    const totalLength = chunks.reduce((acc, chunk) => acc + chunk.length, 0);
+    const combined = new Uint8Array(totalLength);
+    let offset = 0;
+    chunks.forEach((chunk) => {
+      combined.set(chunk, offset);
+      offset += chunk.length;
+    });
+    return combined;
+  }
+  async resumeTranscriptionAfterVoiceCommand(shouldBePaused) {
+    this.audioBuffer = [];
+    const transcriptionId = generateMessageId();
+    try {
+      await this.audioManager.init({
+        deviceId: this.snapshot.microphones.selected?.deviceId,
+        targetSampleRate: this.options.targetSampleRate,
+        onRecorderData: (pcm16) => this.handleRecorderData(pcm16, "transcription")
+      });
+      try {
+        await this.wakeLockManager.request();
+      } catch (error) {
+        this.logger.warn("[Autoscriber] Failed to acquire wake lock", error);
+      }
+      this.snapshot.recording = {
+        mode: "transcription",
+        transcriptionId,
+        isRecording: true,
+        isPaused: shouldBePaused,
+        bufferedChunks: 0,
+        wasTranscriptionActive: false,
+        transcriptionPausedState: false
+      };
+      this.emitRecording();
+      if (this.bufferTimer) {
+        clearInterval(this.bufferTimer);
+      }
+      this.bufferTimer = window.setInterval(() => {
+        if (this.snapshot.recording.mode === "transcription" && this.audioBuffer.length > 0 && !this.snapshot.recording.isPaused) {
+          this.sendBufferedAudio();
+        }
+      }, 5e3);
+    } catch (error) {
+      this.logger.error("[Autoscriber] failed to resume transcription", error);
+      this.resetRecordingState();
+    }
+  }
+  sendVoiceCommandAudio() {
+    if (this.voiceCommandBuffer.length === 0)
+      return;
+    const combined = this.concatPcmChunks(this.voiceCommandBuffer);
+    this.voiceCommandBuffer = [];
+    const silence = detectSilence(combined);
+    if (silence.isSilence) {
+      this.pushInteraction({
+        id: generateMessageId(),
+        label: translate(this.snapshot.language, "voiceCommandSilence"),
+        status: "error",
+        type: "voice"
+      });
+      return;
+    }
+    const messageId = generateMessageId();
+    const message = this.messageStore.createMessage({
+      id: messageId,
+      request: "VOICE_COMMAND_ICON",
+      type: "voice"
+    });
+    this.emitMessages();
+    this.sendMessage({
+      jsonrpc: "2.0",
+      id: messageId,
+      method: "voiceCommand",
+      params: {
+        mediaType: "audio/pcm",
+        data: arrayBufferToBase64(combined.buffer)
+      }
+    });
+    this.pendingRequests.set(messageId, { id: messageId, method: "voiceCommand" });
+  }
+  handleMessage(data) {
+    let payload;
+    try {
+      payload = JSON.parse(data);
+    } catch (error) {
+      this.logger.error("[Autoscriber] failed to parse websocket payload", error);
+      return;
+    }
+    if (payload.error) {
+      this.handleErrorResponse(payload);
+      return;
+    }
+    if (payload.result) {
+      this.handleResultResponse(payload);
+      return;
+    }
+    if (payload.method === "partialResult") {
+      this.handlePartialResult(payload.params);
+      return;
+    }
+    if (payload.method === "voiceTranscription") {
+      this.handleVoiceTranscription(payload.params);
+    }
+  }
+  handleErrorResponse(payload) {
+    const id = payload.id;
+    const message = this.messageStore.getMessageById(id);
+    const errorMessage = payload.error?.message ?? "Unknown error";
+    const errorCode = payload.error?.code;
+    if (message) {
+      this.messageStore.setError(id, `Error: ${errorMessage}`, {
+        code: String(errorCode ?? ""),
+        message: errorMessage
+      });
+      this.emitMessages();
+    } else {
+      this.logger.error("[Autoscriber] error for unknown message", payload);
+    }
+    const pending = this.pendingRequests.get(id);
+    if (pending) {
+      this.updateInteractionFromResult(id, { code: String(errorCode ?? ""), message: errorMessage });
+    }
+    this.bus.emit("error", { code: errorCode, message: errorMessage });
+    const sessionId = getSessionIdFromToken(this.token);
+    this.logStructured("error", "Error response received", {
+      messageId: id,
+      errorCode: String(errorCode ?? ""),
+      errorMessage,
+      method: pending?.method,
+      sessionId: sessionId ?? "unknown"
+    });
+  }
+  handleResultResponse(payload) {
+    this.logStructured("info", "Result response received", {
+      messageId: payload.id,
+      result: payload.result
+    });
+    const id = payload.id;
+    const result = payload.result;
+    if (result?.mediaType === "audio/pcm" && result?.data) {
+      const buffer = base64ToArray(result.data);
+      this.audioManager.playbackPcm(buffer);
+      return;
+    }
+    const message = this.messageStore.getMessageById(id);
+    if (message) {
+      const data = result?.data ?? result;
+      if (Array.isArray(data) || typeof data === "string") {
+        this.messageStore.setMessageResult(id, data);
+      } else if (result?.mediaType === "application/fhir+json") {
+        this.messageStore.setMessageResult(id, [
+          {
+            mediaType: "application/fhir+json",
+            data
+          }
+        ]);
+        this.bus.emit("fhir:data", data);
+        const sessionId = getSessionIdFromToken(this.token);
+        const resourceType = typeof data === "object" && data && "resourceType" in data ? String(data.resourceType) : "unknown";
+        this.logStructured("info", "FHIR data received", {
+          messageId: id,
+          resourceType,
+          sessionId: sessionId ?? "unknown"
+        });
+      } else {
+        this.messageStore.setMessageResult(id, data);
+      }
+      this.emitMessages();
+    }
+    this.updateInteractionFromResult(id, result);
+  }
+  updateInteractionFromResult(id, result) {
+    const pending = this.pendingRequests.get(id);
+    if (!pending)
+      return;
+    const isSuccess = String(result?.code ?? "200") === "200";
+    this.messageStore.updateInteractionStatus(id, isSuccess ? "success" : "error", {
+      result
+    });
+    this.emitInteractions();
+    this.pendingRequests.delete(id);
+  }
+  handlePartialResult(params) {
+    const id = params.id;
+    const message = this.messageStore.getMessageById(id);
+    if (!message)
+      return;
+    if (params.mediaType === "application/json-patch+json") {
+      this.messageStore.applyJsonPatch(id, params.data);
+    } else if (params.mediaType === "application/fhir+json" && params.data?.resourceType === "Transcript") {
+      this.messageStore.setMessageResult(id, [
+        {
+          mediaType: "application/fhir+json",
+          data: params.data
+        }
+      ]);
+    } else if (typeof params.data === "string") {
+      this.messageStore.setMessagePartialResult(id, params.data);
+    }
+    this.emitMessages();
+  }
+  handleVoiceTranscription(params) {
+    const id = params.id;
+    const text = params.text;
+    const message = this.messageStore.getMessageById(id);
+    if (!message)
+      return;
+    message.request = text;
+    this.emitMessages();
+    this.bus.emit("voice:transcription", {
+      transcriptionId: id,
+      finalText: text
+    });
+  }
+  resetRecordingState() {
+    if (this.bufferTimer) {
+      clearInterval(this.bufferTimer);
+      this.bufferTimer = null;
+    }
+    this.snapshot.recording = {
+      mode: "idle",
+      transcriptionId: null,
+      isRecording: false,
+      isPaused: false,
+      bufferedChunks: 0,
+      wasTranscriptionActive: false,
+      transcriptionPausedState: false
+    };
+    this.emitRecording();
+  }
+};
+
+// src/headless/create-assistant.ts
+function createAssistant(options) {
+  const client = new AssistantClient(options);
+  return {
+    client,
+    getSnapshot: () => client.getSnapshot(),
+    subscribe: (event, listener) => client.on(event, listener)
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AssistantClient,
+  createAssistant
+});