@360labs/live-transcribe 0.1.0

package/dist/index.js

@@ -0,0 +1,4777 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+/* @360labs/live-transcribe - MIT License - Built by 360labs */
+
+// src/core/EventEmitter.ts
+var EventEmitter = class {
+  constructor() {
+    this.events = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Subscribe to an event
+   * @param event - Event name to subscribe to
+   * @param listener - Callback function
+   */
+  on(event, listener) {
+    if (!this.events.has(event)) {
+      this.events.set(event, /* @__PURE__ */ new Set());
+    }
+    this.events.get(event).add(listener);
+    return this;
+  }
+  /**
+   * Unsubscribe from an event
+   * @param event - Event name to unsubscribe from
+   * @param listener - Callback function to remove
+   */
+  off(event, listener) {
+    const listeners = this.events.get(event);
+    if (listeners) {
+      listeners.delete(listener);
+      if (listeners.size === 0) {
+        this.events.delete(event);
+      }
+    }
+    return this;
+  }
+  /**
+   * Subscribe to an event for one-time notification
+   * @param event - Event name to subscribe to
+   * @param listener - Callback function
+   */
+  once(event, listener) {
+    const onceWrapper = ((...args) => {
+      this.off(event, onceWrapper);
+      listener.apply(this, args);
+    });
+    return this.on(event, onceWrapper);
+  }
+  /**
+   * Emit an event to all subscribers
+   * @param event - Event name to emit
+   * @param args - Arguments to pass to listeners
+   */
+  emit(event, ...args) {
+    const listeners = this.events.get(event);
+    if (!listeners || listeners.size === 0) {
+      return false;
+    }
+    listeners.forEach((listener) => {
+      try {
+        listener.apply(this, args);
+      } catch (error) {
+        console.error(`Error in event listener for "${String(event)}":`, error);
+      }
+    });
+    return true;
+  }
+  /**
+   * Remove all listeners for an event, or all listeners if no event specified
+   * @param event - Optional event name
+   */
+  removeAllListeners(event) {
+    if (event !== void 0) {
+      this.events.delete(event);
+    } else {
+      this.events.clear();
+    }
+    return this;
+  }
+  /**
+   * Get the number of listeners for an event
+   * @param event - Event name
+   */
+  listenerCount(event) {
+    const listeners = this.events.get(event);
+    return listeners ? listeners.size : 0;
+  }
+  /**
+   * Get all event names that have listeners
+   */
+  eventNames() {
+    return Array.from(this.events.keys());
+  }
+};
+
+// src/types/config.ts
+var TranscriptionProvider = /* @__PURE__ */ ((TranscriptionProvider2) => {
+  TranscriptionProvider2["WebSpeechAPI"] = "web-speech";
+  TranscriptionProvider2["Deepgram"] = "deepgram";
+  TranscriptionProvider2["AssemblyAI"] = "assemblyai";
+  TranscriptionProvider2["Custom"] = "custom";
+  return TranscriptionProvider2;
+})(TranscriptionProvider || {});
+var AudioEncoding = /* @__PURE__ */ ((AudioEncoding2) => {
+  AudioEncoding2["LINEAR16"] = "linear16";
+  AudioEncoding2["MULAW"] = "mulaw";
+  AudioEncoding2["ALAW"] = "alaw";
+  AudioEncoding2["OPUS"] = "opus";
+  return AudioEncoding2;
+})(AudioEncoding || {});
+var DEFAULT_AUDIO_CONFIG = {
+  sampleRate: 16e3,
+  channels: 1,
+  bitDepth: 16,
+  encoding: "linear16" /* LINEAR16 */
+};
+var DEFAULT_TRANSCRIPTION_CONFIG = {
+  language: "en-US",
+  interimResults: true,
+  profanityFilter: false,
+  punctuation: true
+};
+
+// src/types/session.ts
+var SessionState = /* @__PURE__ */ ((SessionState2) => {
+  SessionState2["IDLE"] = "idle";
+  SessionState2["INITIALIZING"] = "initializing";
+  SessionState2["ACTIVE"] = "active";
+  SessionState2["PAUSED"] = "paused";
+  SessionState2["STOPPING"] = "stopping";
+  SessionState2["STOPPED"] = "stopped";
+  SessionState2["ERROR"] = "error";
+  return SessionState2;
+})(SessionState || {});
+var DEFAULT_SESSION_CONFIG = {
+  recordAudio: false,
+  maxDuration: 0,
+  // 0 means no limit
+  silenceTimeout: 0,
+  // 0 means no auto-stop
+  enableVAD: false,
+  vadThreshold: 0.5
+};
+
+// src/types/events.ts
+var ErrorCode = /* @__PURE__ */ ((ErrorCode2) => {
+  ErrorCode2["INITIALIZATION_FAILED"] = "initialization_failed";
+  ErrorCode2["CONNECTION_FAILED"] = "connection_failed";
+  ErrorCode2["AUTHENTICATION_FAILED"] = "authentication_failed";
+  ErrorCode2["MICROPHONE_ACCESS_DENIED"] = "microphone_access_denied";
+  ErrorCode2["UNSUPPORTED_BROWSER"] = "unsupported_browser";
+  ErrorCode2["NETWORK_ERROR"] = "network_error";
+  ErrorCode2["PROVIDER_ERROR"] = "provider_error";
+  ErrorCode2["INVALID_CONFIG"] = "invalid_config";
+  ErrorCode2["SESSION_EXPIRED"] = "session_expired";
+  ErrorCode2["UNKNOWN_ERROR"] = "unknown_error";
+  return ErrorCode2;
+})(ErrorCode || {});
+var TranscriptionError = class _TranscriptionError extends Error {
+  constructor(message, code, provider, details) {
+    super(message);
+    this.name = "TranscriptionError";
+    this.code = code;
+    this.provider = provider;
+    this.details = details;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, _TranscriptionError);
+    }
+  }
+};
+
+// src/core/BaseTranscriber.ts
+var BaseTranscriber = class extends EventEmitter {
+  /**
+   * Create a new BaseTranscriber instance
+   * @param config - Transcription configuration
+   */
+  constructor(config) {
+    super();
+    /** Current session state */
+    this.state = "idle" /* IDLE */;
+    /** Recorded audio chunks */
+    this.audioRecording = [];
+    /** Word count in current session */
+    this.wordCount = 0;
+    this.config = { ...DEFAULT_TRANSCRIPTION_CONFIG, ...config };
+    this.sessionMetadata = this.initializeMetadata();
+    this.validateConfig();
+  }
+  // ==================== Public Helper Methods ====================
+  /**
+   * Get the current session state
+   */
+  getState() {
+    return this.state;
+  }
+  /**
+   * Get session metadata
+   */
+  getMetadata() {
+    return {
+      ...this.sessionMetadata,
+      duration: this.calculateDuration(),
+      wordCount: this.wordCount
+    };
+  }
+  /**
+   * Get recorded audio data
+   * @returns Combined audio data or null if not recording
+   */
+  getRecording() {
+    if (this.audioRecording.length === 0) {
+      return null;
+    }
+    const totalLength = this.audioRecording.reduce((acc, chunk) => acc + chunk.byteLength, 0);
+    const combined = new ArrayBuffer(totalLength);
+    const view = new Uint8Array(combined);
+    let offset = 0;
+    for (const chunk of this.audioRecording) {
+      view.set(new Uint8Array(chunk), offset);
+      offset += chunk.byteLength;
+    }
+    return combined;
+  }
+  // ==================== Protected Helper Methods ====================
+  /**
+   * Update session state and emit state change event
+   * @param newState - New session state
+   */
+  setState(newState) {
+    const previousState = this.state;
+    this.state = newState;
+    if (newState === "active" /* ACTIVE */ && !this.startTime) {
+      this.startTime = Date.now();
+      this.sessionMetadata.startTime = this.startTime;
+    }
+    if (newState === "stopped" /* STOPPED */ || newState === "error" /* ERROR */) {
+      this.sessionMetadata.endTime = Date.now();
+      this.sessionMetadata.duration = this.calculateDuration();
+    }
+    if (previousState !== newState) {
+      this.emit("stateChange", newState);
+    }
+  }
+  /**
+   * Handle incoming transcription result
+   * @param result - Transcription result from provider
+   */
+  handleTranscript(result) {
+    if (result.isFinal && result.text) {
+      const words = result.text.trim().split(/\s+/).filter((w) => w.length > 0);
+      this.wordCount += words.length;
+    }
+    this.emit("transcript", result);
+    if (result.isFinal) {
+      this.emit("final", result);
+    } else {
+      this.emit("interim", result);
+    }
+  }
+  /**
+   * Handle errors and emit error event
+   * @param error - Error to handle
+   */
+  handleError(error) {
+    let transcriptionError;
+    if (error instanceof TranscriptionError) {
+      transcriptionError = error;
+    } else {
+      transcriptionError = new TranscriptionError(
+        error.message,
+        "unknown_error" /* UNKNOWN_ERROR */,
+        this.config.provider,
+        error
+      );
+    }
+    this.setState("error" /* ERROR */);
+    this.emit("error", transcriptionError);
+  }
+  /**
+   * Validate configuration
+   * @throws TranscriptionError if configuration is invalid
+   */
+  validateConfig() {
+    if (!this.config.provider) {
+      throw new TranscriptionError(
+        "Provider must be specified in configuration",
+        "invalid_config" /* INVALID_CONFIG */
+      );
+    }
+    const cloudProviders = ["deepgram", "assemblyai"];
+    if (cloudProviders.includes(this.config.provider) && !this.config.apiKey) {
+      throw new TranscriptionError(
+        `API key is required for ${this.config.provider} provider`,
+        "invalid_config" /* INVALID_CONFIG */,
+        this.config.provider
+      );
+    }
+  }
+  /**
+   * Record audio data if recording is enabled
+   * @param data - Audio data to record
+   */
+  recordAudioData(data) {
+    this.audioRecording.push(data.slice(0));
+  }
+  /**
+   * Calculate session duration
+   * @returns Duration in milliseconds
+   */
+  calculateDuration() {
+    if (!this.startTime) {
+      return 0;
+    }
+    const endTime = this.sessionMetadata.endTime || Date.now();
+    return endTime - this.startTime;
+  }
+  /**
+   * Clear recording data
+   */
+  clearRecording() {
+    this.audioRecording = [];
+  }
+  /**
+   * Reset session state for new session
+   */
+  resetSession() {
+    this.state = "idle" /* IDLE */;
+    this.startTime = void 0;
+    this.wordCount = 0;
+    this.audioRecording = [];
+    this.sessionMetadata = this.initializeMetadata();
+  }
+  // ==================== Private Helper Methods ====================
+  /**
+   * Generate a unique session ID
+   */
+  generateSessionId() {
+    return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+      const r = Math.random() * 16 | 0;
+      const v = c === "x" ? r : r & 3 | 8;
+      return v.toString(16);
+    });
+  }
+  /**
+   * Initialize session metadata
+   */
+  initializeMetadata() {
+    return {
+      id: this.generateSessionId(),
+      startTime: 0,
+      wordCount: 0,
+      provider: this.config.provider
+    };
+  }
+};
+
+// src/utils/exporters/JSONExporter.ts
+var JSONExporter = class {
+  /**
+   * Export session to minified JSON string
+   * @param session - Session data to export
+   * @returns JSON string
+   */
+  static export(session) {
+    const exportData = {
+      version: "1.0.0",
+      session: {
+        metadata: session.metadata,
+        transcripts: session.transcripts,
+        config: {}
+      },
+      exportedAt: Date.now()
+    };
+    return JSON.stringify(exportData);
+  }
+  /**
+   * Export session to formatted/pretty JSON string
+   * @param session - Session data to export
+   * @param indent - Indentation spaces (default: 2)
+   * @returns Formatted JSON string
+   */
+  static exportPretty(session, indent = 2) {
+    const exportData = {
+      version: "1.0.0",
+      session: {
+        metadata: session.metadata,
+        transcripts: session.transcripts,
+        config: {}
+      },
+      exportedAt: Date.now()
+    };
+    return JSON.stringify(exportData, null, indent);
+  }
+  /**
+   * Parse JSON and validate structure
+   * @param json - JSON string to parse
+   * @returns Parsed session export data
+   */
+  static parse(json) {
+    const data = JSON.parse(json);
+    if (!data.version || !data.session) {
+      throw new Error("Invalid session export format");
+    }
+    return data;
+  }
+};
+
+// src/utils/exporters/TextExporter.ts
+var TextExporter = class {
+  /**
+   * Export session transcripts to plain text
+   * @param session - Session data to export
+   * @param options - Export options
+   * @returns Plain text string
+   */
+  static export(session, options = {}) {
+    const {
+      includeTimestamps = false,
+      includeSpeakers = false,
+      includeConfidence = false,
+      paragraphBreaks = false
+    } = options;
+    const lines = [];
+    const finalTranscripts = session.transcripts.filter((t) => t.isFinal);
+    for (const transcript of finalTranscripts) {
+      let line = "";
+      if (includeTimestamps && transcript.timestamp) {
+        const time = new Date(transcript.timestamp).toISOString().substr(11, 8);
+        line += `[${time}] `;
+      }
+      if (includeSpeakers && transcript.speaker) {
+        line += `${transcript.speaker}: `;
+      }
+      line += transcript.text;
+      if (includeConfidence && transcript.confidence !== void 0) {
+        line += ` (${Math.round(transcript.confidence * 100)}%)`;
+      }
+      lines.push(line);
+    }
+    const separator = paragraphBreaks ? "\n\n" : " ";
+    return lines.join(separator).trim();
+  }
+  /**
+   * Export as continuous text without any formatting
+   * @param session - Session data to export
+   * @returns Plain text string
+   */
+  static exportPlain(session) {
+    return session.transcripts.filter((t) => t.isFinal).map((t) => t.text).join(" ").trim();
+  }
+};
+
+// src/utils/exporters/SRTExporter.ts
+var SRTExporter = class {
+  /**
+   * Export session transcripts to SRT format
+   * @param session - Session data to export
+   * @returns SRT formatted string
+   */
+  static export(session) {
+    const finalTranscripts = session.transcripts.filter((t) => t.isFinal);
+    const lines = [];
+    let sequenceNumber = 1;
+    let currentTime = 0;
+    for (const transcript of finalTranscripts) {
+      if (!transcript.text.trim()) continue;
+      let startTime = currentTime;
+      let endTime;
+      if (transcript.words && transcript.words.length > 0) {
+        startTime = transcript.words[0].start;
+        endTime = transcript.words[transcript.words.length - 1].end;
+      } else {
+        const wordCount = transcript.text.split(/\s+/).length;
+        const durationMs = wordCount / 150 * 60 * 1e3;
+        endTime = startTime + Math.max(durationMs, 1e3);
+      }
+      lines.push(String(sequenceNumber));
+      lines.push(`${this.formatTime(startTime)} --> ${this.formatTime(endTime)}`);
+      lines.push(transcript.text);
+      lines.push("");
+      sequenceNumber++;
+      currentTime = endTime + 100;
+    }
+    return lines.join("\n");
+  }
+  /**
+   * Format milliseconds to SRT timestamp format (HH:MM:SS,mmm)
+   * @param ms - Time in milliseconds
+   * @returns Formatted timestamp
+   */
+  static formatTime(ms) {
+    const totalSeconds = Math.floor(ms / 1e3);
+    const hours = Math.floor(totalSeconds / 3600);
+    const minutes = Math.floor(totalSeconds % 3600 / 60);
+    const seconds = totalSeconds % 60;
+    const milliseconds = Math.floor(ms % 1e3);
+    return `${this.pad(hours, 2)}:${this.pad(minutes, 2)}:${this.pad(seconds, 2)},${this.pad(milliseconds, 3)}`;
+  }
+  /**
+   * Pad number with leading zeros
+   * @param num - Number to pad
+   * @param length - Target length
+   * @returns Padded string
+   */
+  static pad(num, length) {
+    return String(num).padStart(length, "0");
+  }
+};
+
+// src/utils/exporters/VTTExporter.ts
+var VTTExporter = class {
+  /**
+   * Export session transcripts to WebVTT format
+   * @param session - Session data to export
+   * @returns WebVTT formatted string
+   */
+  static export(session) {
+    const finalTranscripts = session.transcripts.filter((t) => t.isFinal);
+    const lines = ["WEBVTT", ""];
+    let currentTime = 0;
+    for (const transcript of finalTranscripts) {
+      if (!transcript.text.trim()) continue;
+      let startTime = currentTime;
+      let endTime;
+      if (transcript.words && transcript.words.length > 0) {
+        startTime = transcript.words[0].start;
+        endTime = transcript.words[transcript.words.length - 1].end;
+      } else {
+        const wordCount = transcript.text.split(/\s+/).length;
+        const durationMs = wordCount / 150 * 60 * 1e3;
+        endTime = startTime + Math.max(durationMs, 1e3);
+      }
+      lines.push(`${this.formatTime(startTime)} --> ${this.formatTime(endTime)}`);
+      if (transcript.speaker) {
+        lines.push(`<v ${transcript.speaker}>${transcript.text}`);
+      } else {
+        lines.push(transcript.text);
+      }
+      lines.push("");
+      currentTime = endTime + 100;
+    }
+    return lines.join("\n");
+  }
+  /**
+   * Export with cue identifiers
+   * @param session - Session data to export
+   * @param cuePrefix - Prefix for cue identifiers
+   * @returns WebVTT formatted string with cue IDs
+   */
+  static exportWithCues(session, cuePrefix = "cue") {
+    const finalTranscripts = session.transcripts.filter((t) => t.isFinal);
+    const lines = ["WEBVTT", ""];
+    let cueNumber = 1;
+    let currentTime = 0;
+    for (const transcript of finalTranscripts) {
+      if (!transcript.text.trim()) continue;
+      let startTime = currentTime;
+      let endTime;
+      if (transcript.words && transcript.words.length > 0) {
+        startTime = transcript.words[0].start;
+        endTime = transcript.words[transcript.words.length - 1].end;
+      } else {
+        const wordCount = transcript.text.split(/\s+/).length;
+        const durationMs = wordCount / 150 * 60 * 1e3;
+        endTime = startTime + Math.max(durationMs, 1e3);
+      }
+      lines.push(`${cuePrefix}-${cueNumber}`);
+      lines.push(`${this.formatTime(startTime)} --> ${this.formatTime(endTime)}`);
+      lines.push(transcript.text);
+      lines.push("");
+      cueNumber++;
+      currentTime = endTime + 100;
+    }
+    return lines.join("\n");
+  }
+  /**
+   * Format milliseconds to WebVTT timestamp format (HH:MM:SS.mmm)
+   * @param ms - Time in milliseconds
+   * @returns Formatted timestamp
+   */
+  static formatTime(ms) {
+    const totalSeconds = Math.floor(ms / 1e3);
+    const hours = Math.floor(totalSeconds / 3600);
+    const minutes = Math.floor(totalSeconds % 3600 / 60);
+    const seconds = totalSeconds % 60;
+    const milliseconds = Math.floor(ms % 1e3);
+    return `${this.pad(hours, 2)}:${this.pad(minutes, 2)}:${this.pad(seconds, 2)}.${this.pad(milliseconds, 3)}`;
+  }
+  /**
+   * Pad number with leading zeros
+   */
+  static pad(num, length) {
+    return String(num).padStart(length, "0");
+  }
+};
+
+// src/utils/exporters/CSVExporter.ts
+var CSVExporter = class {
+  /**
+   * Export session transcripts to CSV format
+   * @param session - Session data to export
+   * @param options - Export options
+   * @returns CSV formatted string
+   */
+  static export(session, options = {}) {
+    const {
+      delimiter = ",",
+      includeHeaders = true,
+      columns = ["timestamp", "text", "isFinal", "confidence", "speaker"]
+    } = options;
+    const rows = [];
+    if (includeHeaders) {
+      rows.push(columns.map((col) => this.escapeField(col, delimiter)).join(delimiter));
+    }
+    for (const transcript of session.transcripts) {
+      const values = columns.map((col) => {
+        const value = this.getFieldValue(transcript, col);
+        return this.escapeField(String(value), delimiter);
+      });
+      rows.push(values.join(delimiter));
+    }
+    return rows.join("\n");
+  }
+  /**
+   * Export only final transcripts
+   * @param session - Session data to export
+   * @param options - Export options
+   * @returns CSV formatted string
+   */
+  static exportFinalOnly(session, options = {}) {
+    const filteredSession = {
+      transcripts: session.transcripts.filter((t) => t.isFinal)
+    };
+    return this.export(filteredSession, options);
+  }
+  /**
+   * Get field value from transcript
+   * @param transcript - Transcription result
+   * @param field - Field name
+   * @returns Field value
+   */
+  static getFieldValue(transcript, field) {
+    switch (field) {
+      case "timestamp":
+        return transcript.timestamp || "";
+      case "text":
+        return transcript.text || "";
+      case "isFinal":
+        return transcript.isFinal;
+      case "confidence":
+        return transcript.confidence !== void 0 ? transcript.confidence : "";
+      case "speaker":
+        return transcript.speaker || "";
+      case "language":
+        return transcript.language || "";
+      case "wordCount":
+        return transcript.text ? transcript.text.split(/\s+/).filter((w) => w).length : 0;
+      case "startTime":
+        return transcript.words?.[0]?.start || "";
+      case "endTime":
+        return transcript.words?.[transcript.words.length - 1]?.end || "";
+      default:
+        return "";
+    }
+  }
+  /**
+   * Escape field for CSV format
+   * @param field - Field value
+   * @param delimiter - CSV delimiter
+   * @returns Escaped field
+   */
+  static escapeField(field, delimiter) {
+    if (field.includes(delimiter) || field.includes('"') || field.includes("\n") || field.includes("\r")) {
+      const escaped = field.replace(/"/g, '""');
+      return `"${escaped}"`;
+    }
+    return field;
+  }
+};
+
+// src/core/TranscriptionSession.ts
+var TranscriptionSession = class {
+  /**
+   * Create a new TranscriptionSession
+   * @param provider - Transcription provider to use
+   * @param sessionConfig - Session configuration options
+   */
+  constructor(provider, sessionConfig = {}) {
+    /** Collected transcription results */
+    this.transcripts = [];
+    /** Current session state */
+    this.state = "idle" /* IDLE */;
+    this.provider = provider;
+    this.config = { ...DEFAULT_SESSION_CONFIG, ...sessionConfig };
+    this.id = this.generateSessionId();
+  }
+  /**
+   * Start the transcription session
+   */
+  async start() {
+    if (this.state !== "idle" /* IDLE */ && this.state !== "stopped" /* STOPPED */) {
+      throw new Error(`Cannot start session in state: ${this.state}`);
+    }
+    this.state = "initializing" /* INITIALIZING */;
+    this.startTime = Date.now();
+    try {
+      await this.provider.start();
+      this.state = "active" /* ACTIVE */;
+      this.setupTimers();
+    } catch (error) {
+      this.state = "error" /* ERROR */;
+      throw error;
+    }
+  }
+  /**
+   * Stop the transcription session
+   */
+  async stop() {
+    if (this.state === "stopped" /* STOPPED */ || this.state === "idle" /* IDLE */) {
+      return;
+    }
+    this.state = "stopping" /* STOPPING */;
+    this.clearTimers();
+    try {
+      await this.provider.stop();
+    } finally {
+      this.state = "stopped" /* STOPPED */;
+    }
+  }
+  /**
+   * Pause the transcription session
+   */
+  pause() {
+    if (this.state !== "active" /* ACTIVE */) {
+      return;
+    }
+    this.provider.pause();
+    this.state = "paused" /* PAUSED */;
+    this.clearTimers();
+  }
+  /**
+   * Resume the transcription session
+   */
+  resume() {
+    if (this.state !== "paused" /* PAUSED */) {
+      return;
+    }
+    this.provider.resume();
+    this.state = "active" /* ACTIVE */;
+    this.setupTimers();
+  }
+  /**
+   * Add a transcription result to the session
+   * @param result - Transcription result to add
+   */
+  addTranscript(result) {
+    this.transcripts.push(result);
+    this.resetSilenceTimer();
+  }
+  /**
+   * Get transcription results
+   * @param finalOnly - If true, return only final results
+   */
+  getTranscripts(finalOnly = false) {
+    if (finalOnly) {
+      return this.transcripts.filter((t) => t.isFinal);
+    }
+    return [...this.transcripts];
+  }
+  /**
+   * Get concatenated text from all final transcripts
+   */
+  getFullText() {
+    return this.transcripts.filter((t) => t.isFinal).map((t) => t.text).join(" ").trim();
+  }
+  /**
+   * Get the current session state
+   */
+  getState() {
+    return this.state;
+  }
+  /**
+   * Export session data in raw format
+   */
+  exportRaw() {
+    const metadata = {
+      id: this.id,
+      startTime: this.startTime || 0,
+      endTime: this.state === "stopped" /* STOPPED */ ? Date.now() : void 0,
+      duration: this.startTime ? Date.now() - this.startTime : 0,
+      wordCount: this.getWordCount(),
+      provider: this.provider.getState()
+    };
+    return {
+      metadata,
+      transcripts: this.getTranscripts(),
+      fullText: this.getFullText()
+    };
+  }
+  /**
+   * Export session data in specified format
+   * @param format - Export format (json, text, srt, vtt, csv)
+   */
+  export(format = "json") {
+    const transcripts = this.getTranscripts(true);
+    const sessionData = { transcripts };
+    const rawExport = this.exportRaw();
+    let data;
+    let mimeType;
+    let extension;
+    switch (format) {
+      case "json":
+        data = JSONExporter.export({ metadata: rawExport.metadata, transcripts });
+        mimeType = "application/json";
+        extension = "json";
+        break;
+      case "text":
+        data = TextExporter.export(sessionData, {});
+        mimeType = "text/plain";
+        extension = "txt";
+        break;
+      case "srt":
+        data = SRTExporter.export(sessionData);
+        mimeType = "text/plain";
+        extension = "srt";
+        break;
+      case "vtt":
+        data = VTTExporter.export(sessionData);
+        mimeType = "text/vtt";
+        extension = "vtt";
+        break;
+      case "csv":
+        data = CSVExporter.export(sessionData, {});
+        mimeType = "text/csv";
+        extension = "csv";
+        break;
+      default:
+        data = JSONExporter.export({ metadata: rawExport.metadata, transcripts });
+        mimeType = "application/json";
+        extension = "json";
+    }
+    return {
+      format,
+      data,
+      filename: `transcript-${this.id}.${extension}`,
+      mimeType
+    };
+  }
+  /**
+   * Get session statistics
+   */
+  getStatistics() {
+    const transcripts = this.getTranscripts(true);
+    const wordCount = this.getWordCount();
+    const durationMs = this.startTime ? Date.now() - this.startTime : 0;
+    let totalConfidence = 0;
+    let confCount = 0;
+    for (const t of transcripts) {
+      if (t.confidence !== void 0) {
+        totalConfidence += t.confidence;
+        confCount++;
+      }
+    }
+    const averageConfidence = confCount > 0 ? totalConfidence / confCount : 0;
+    const durationMinutes = durationMs / 6e4;
+    const speakingRate = durationMinutes > 0 ? wordCount / durationMinutes : 0;
+    return {
+      wordCount,
+      averageConfidence,
+      speakingRate,
+      silencePeriods: 0,
+      // Would require VAD tracking
+      durationMs,
+      transcriptCount: transcripts.length
+    };
+  }
+  /**
+   * Clear all transcripts
+   */
+  clear() {
+    this.transcripts = [];
+  }
+  /**
+   * Get the total word count from final transcripts
+   */
+  getWordCount() {
+    return this.transcripts.filter((t) => t.isFinal).reduce((count, t) => {
+      const words = t.text.trim().split(/\s+/).filter((w) => w.length > 0);
+      return count + words.length;
+    }, 0);
+  }
+  /**
+   * Set up session timers (max duration, silence timeout)
+   */
+  setupTimers() {
+    if (this.config.maxDuration > 0) {
+      this.maxDurationTimer = setTimeout(() => {
+        void this.stop();
+      }, this.config.maxDuration);
+    }
+    this.resetSilenceTimer();
+  }
+  /**
+   * Reset the silence timeout timer
+   */
+  resetSilenceTimer() {
+    if (this.silenceTimer) {
+      clearTimeout(this.silenceTimer);
+    }
+    if (this.config.silenceTimeout > 0 && this.state === "active" /* ACTIVE */) {
+      this.silenceTimer = setTimeout(() => {
+        void this.stop();
+      }, this.config.silenceTimeout);
+    }
+  }
+  /**
+   * Clear all timers
+   */
+  clearTimers() {
+    if (this.maxDurationTimer) {
+      clearTimeout(this.maxDurationTimer);
+      this.maxDurationTimer = void 0;
+    }
+    if (this.silenceTimer) {
+      clearTimeout(this.silenceTimer);
+      this.silenceTimer = void 0;
+    }
+  }
+  /**
+   * Generate a unique session ID
+   */
+  generateSessionId() {
+    return "session-" + "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+      const r = Math.random() * 16 | 0;
+      const v = c === "x" ? r : r & 3 | 8;
+      return v.toString(16);
+    });
+  }
+};
+
+// src/core/SessionManager.ts
+var SessionManager = class {
+  /**
+   * Create a new SessionManager
+   * @param options - Manager configuration
+   */
+  constructor(options = {}) {
+    /** Active sessions map */
+    this.sessions = /* @__PURE__ */ new Map();
+    /** Currently active session ID */
+    this.activeSessionId = null;
+    this.defaultConfig = options.defaultConfig || {};
+    this.maxSessions = options.maxSessions || 10;
+  }
+  /**
+   * Create a new transcription session
+   * @param provider - Transcription provider instance
+   * @param config - Session configuration (merged with defaults)
+   * @returns New TranscriptionSession instance
+   */
+  createSession(provider, config) {
+    if (this.sessions.size >= this.maxSessions) {
+      throw new Error(`Maximum number of sessions (${this.maxSessions}) reached`);
+    }
+    const mergedConfig = { ...this.defaultConfig, ...config };
+    const session = new TranscriptionSession(provider, mergedConfig);
+    this.sessions.set(session.id, session);
+    if (!this.activeSessionId) {
+      this.activeSessionId = session.id;
+    }
+    return session;
+  }
+  /**
+   * Get session by ID
+   * @param sessionId - Session ID
+   * @returns TranscriptionSession or null
+   */
+  getSession(sessionId) {
+    return this.sessions.get(sessionId) || null;
+  }
+  /**
+   * Get the currently active session
+   * @returns Active TranscriptionSession or null
+   */
+  getActiveSession() {
+    if (!this.activeSessionId) {
+      return null;
+    }
+    return this.sessions.get(this.activeSessionId) || null;
+  }
+  /**
+   * Set the active session
+   * @param sessionId - Session ID to make active
+   */
+  setActiveSession(sessionId) {
+    if (!this.sessions.has(sessionId)) {
+      throw new Error(`Session ${sessionId} not found`);
+    }
+    this.activeSessionId = sessionId;
+  }
+  /**
+   * Get all sessions
+   * @returns Array of all sessions
+   */
+  getAllSessions() {
+    return Array.from(this.sessions.values());
+  }
+  /**
+   * Delete a session
+   * @param sessionId - Session ID to delete
+   */
+  async deleteSession(sessionId) {
+    const session = this.sessions.get(sessionId);
+    if (!session) {
+      return;
+    }
+    if (session.getState() === "active" /* ACTIVE */ || session.getState() === "paused" /* PAUSED */) {
+      await session.stop();
+    }
+    this.sessions.delete(sessionId);
+    if (this.activeSessionId === sessionId) {
+      this.activeSessionId = null;
+      const remaining = this.sessions.keys().next();
+      if (!remaining.done) {
+        this.activeSessionId = remaining.value;
+      }
+    }
+  }
+  /**
+   * Clear all sessions
+   */
+  async clearAllSessions() {
+    const stopPromises = [];
+    for (const session of this.sessions.values()) {
+      const state = session.getState();
+      if (state === "active" /* ACTIVE */ || state === "paused" /* PAUSED */) {
+        stopPromises.push(session.stop());
+      }
+    }
+    await Promise.all(stopPromises);
+    this.sessions.clear();
+    this.activeSessionId = null;
+  }
+  /**
+   * Get statistics for all sessions
+   * @returns Session statistics
+   */
+  getSessionStats() {
+    let totalTranscripts = 0;
+    let totalDuration = 0;
+    let totalConfidence = 0;
+    let confidenceCount = 0;
+    let activeSessions = 0;
+    for (const session of this.sessions.values()) {
+      const state = session.getState();
+      if (state === "active" /* ACTIVE */) {
+        activeSessions++;
+      }
+      const stats = session.getStatistics();
+      totalTranscripts += stats.transcriptCount;
+      totalDuration += stats.durationMs;
+      if (stats.averageConfidence > 0) {
+        totalConfidence += stats.averageConfidence;
+        confidenceCount++;
+      }
+    }
+    return {
+      totalSessions: this.sessions.size,
+      activeSessions,
+      totalTranscripts,
+      totalDuration,
+      averageConfidence: confidenceCount > 0 ? totalConfidence / confidenceCount : 0
+    };
+  }
+  /**
+   * Export a session to specified format
+   * @param sessionId - Session ID
+   * @param format - Export format
+   * @returns Export result
+   */
+  exportSession(sessionId, format) {
+    const session = this.sessions.get(sessionId);
+    if (!session) {
+      throw new Error(`Session ${sessionId} not found`);
+    }
+    const exportData = session.exportRaw();
+    const sessionData = {
+      metadata: exportData.metadata,
+      transcripts: exportData.transcripts
+    };
+    let data;
+    let mimeType;
+    let extension;
+    switch (format) {
+      case "json":
+        data = JSONExporter.exportPretty(sessionData);
+        mimeType = "application/json";
+        extension = "json";
+        break;
+      case "text":
+        data = TextExporter.export(sessionData);
+        mimeType = "text/plain";
+        extension = "txt";
+        break;
+      case "srt":
+        data = SRTExporter.export(sessionData);
+        mimeType = "application/x-subrip";
+        extension = "srt";
+        break;
+      case "vtt":
+        data = VTTExporter.export(sessionData);
+        mimeType = "text/vtt";
+        extension = "vtt";
+        break;
+      case "csv":
+        data = CSVExporter.export(sessionData);
+        mimeType = "text/csv";
+        extension = "csv";
+        break;
+      default:
+        throw new Error(`Unsupported export format: ${format}`);
+    }
+    return {
+      format,
+      data,
+      filename: `transcript-${sessionId}.${extension}`,
+      mimeType
+    };
+  }
+  /**
+   * Import a session from data
+   * @param data - Session import data
+   * @param provider - Provider instance for the session
+   * @returns Imported session
+   */
+  importSession(data, provider) {
+    if (this.sessions.size >= this.maxSessions) {
+      throw new Error(`Maximum number of sessions (${this.maxSessions}) reached`);
+    }
+    const session = new TranscriptionSession(provider, data.config || {});
+    for (const transcript of data.transcripts) {
+      session.addTranscript(transcript);
+    }
+    this.sessions.set(session.id, session);
+    return session;
+  }
+  /**
+   * Check if a session exists
+   * @param sessionId - Session ID
+   * @returns True if session exists
+   */
+  hasSession(sessionId) {
+    return this.sessions.has(sessionId);
+  }
+  /**
+   * Get session count
+   * @returns Number of sessions
+   */
+  getSessionCount() {
+    return this.sessions.size;
+  }
+  /**
+   * Get sessions by state
+   * @param state - Session state to filter by
+   * @returns Array of sessions with matching state
+   */
+  getSessionsByState(state) {
+    return this.getAllSessions().filter((session) => session.getState() === state);
+  }
+};
+
+// src/providers/WebSpeechProvider.ts
+var _WebSpeechProvider = class _WebSpeechProvider extends BaseTranscriber {
+  /**
+   * Create a new WebSpeechProvider
+   * @param config - Transcription configuration
+   */
+  constructor(config) {
+    super({ ...config, provider: "web-speech" /* WebSpeechAPI */ });
+    /** Speech recognition instance */
+    this.recognition = null;
+    /** Media stream from microphone */
+    this.mediaStream = null;
+    /** Audio context for analysis */
+    this.audioContext = null;
+    /** Audio analyser for VAD */
+    this.analyser = null;
+    /** Script processor for audio level monitoring */
+    this.audioLevelInterval = null;
+    /** Whether recognition is being restarted automatically */
+    this.isRestarting = false;
+    /** Retry count for auto-restart */
+    this.retryCount = 0;
+    /** Maximum retry attempts */
+    this.maxRetries = 3;
+  }
+  /**
+   * Check if Web Speech API is supported in the current environment
+   */
+  isSupported() {
+    if (typeof window === "undefined") {
+      return false;
+    }
+    return !!(window.SpeechRecognition || window.webkitSpeechRecognition);
+  }
+  /**
+   * Initialize the Web Speech API provider
+   */
+  async initialize() {
+    if (!this.isSupported()) {
+      throw new TranscriptionError(
+        "Web Speech API is not supported in this browser",
+        "unsupported_browser" /* UNSUPPORTED_BROWSER */,
+        "web-speech" /* WebSpeechAPI */
+      );
+    }
+    this.setState("initializing" /* INITIALIZING */);
+    try {
+      await this.getMicrophoneAccess();
+      const SpeechRecognitionClass = window.SpeechRecognition || window.webkitSpeechRecognition;
+      this.recognition = new SpeechRecognitionClass();
+      this.recognition.continuous = true;
+      this.recognition.interimResults = this.config.interimResults ?? true;
+      this.recognition.lang = this.config.language || "en-US";
+      this.recognition.maxAlternatives = 1;
+      this.setupEventHandlers();
+      if (this.config.providerOptions?.enableVAD) {
+        this.setupAudioLevelMonitoring();
+      }
+    } catch (error) {
+      this.handleError(error);
+      throw error;
+    }
+  }
+  /**
+   * Start transcription
+   */
+  async start() {
+    if (!this.recognition) {
+      await this.initialize();
+    }
+    if (this.state === "active" /* ACTIVE */) {
+      return;
+    }
+    try {
+      this.recognition.start();
+      this.retryCount = 0;
+    } catch (error) {
+      if (error.message?.includes("already started")) {
+        return;
+      }
+      this.handleError(error);
+      throw error;
+    }
+  }
+  /**
+   * Stop transcription
+   */
+  async stop() {
+    if (this.state === "stopped" /* STOPPED */ || this.state === "idle" /* IDLE */) {
+      return;
+    }
+    this.setState("stopping" /* STOPPING */);
+    this.isRestarting = false;
+    try {
+      if (this.recognition) {
+        this.recognition.stop();
+      }
+      this.stopAudioLevelMonitoring();
+      this.stopMediaStream();
+      this.setState("stopped" /* STOPPED */);
+      this.emit("stop");
+    } catch (error) {
+      this.handleError(error);
+    }
+  }
+  /**
+   * Pause transcription
+   */
+  pause() {
+    if (this.state !== "active" /* ACTIVE */) {
+      return;
+    }
+    this.isRestarting = false;
+    try {
+      if (this.recognition) {
+        this.recognition.stop();
+      }
+      this.setState("paused" /* PAUSED */);
+      this.emit("pause");
+    } catch (error) {
+      this.handleError(error);
+    }
+  }
+  /**
+   * Resume transcription
+   */
+  resume() {
+    if (this.state !== "paused" /* PAUSED */) {
+      return;
+    }
+    try {
+      if (this.recognition) {
+        this.recognition.start();
+      }
+      this.setState("active" /* ACTIVE */);
+      this.emit("resume");
+    } catch (error) {
+      this.handleError(error);
+    }
+  }
+  /**
+   * Send audio data - not supported by Web Speech API
+   * @param _audioData - Audio data (unused)
+   */
+  sendAudio(_audioData) {
+    console.warn("WebSpeechProvider does not support external audio input. Audio data is captured directly from the microphone.");
+  }
+  /**
+   * Clean up all resources
+   */
+  async cleanup() {
+    this.isRestarting = false;
+    if (this.recognition) {
+      try {
+        this.recognition.stop();
+      } catch {
+      }
+      this.recognition.onstart = null;
+      this.recognition.onend = null;
+      this.recognition.onerror = null;
+      this.recognition.onresult = null;
+      this.recognition.onspeechstart = null;
+      this.recognition.onspeechend = null;
+      this.recognition = null;
+    }
+    this.stopAudioLevelMonitoring();
+    if (this.audioContext) {
+      try {
+        await this.audioContext.close();
+      } catch {
+      }
+      this.audioContext = null;
+      this.analyser = null;
+    }
+    this.stopMediaStream();
+    this.removeAllListeners();
+  }
+  /**
+   * Get provider capabilities
+   */
+  getCapabilities() {
+    return _WebSpeechProvider.capabilities;
+  }
+  // ==================== Private Methods ====================
+  /**
+   * Set up event handlers for speech recognition
+   */
+  setupEventHandlers() {
+    if (!this.recognition) return;
+    this.recognition.onstart = () => {
+      this.setState("active" /* ACTIVE */);
+      this.emit("start");
+    };
+    this.recognition.onend = () => {
+      this.handleRecognitionEnd();
+    };
+    this.recognition.onerror = (event) => {
+      this.handleRecognitionError(event);
+    };
+    this.recognition.onresult = (event) => {
+      this.processRecognitionResult(event);
+    };
+    this.recognition.onspeechstart = () => {
+      this.emit("speech");
+    };
+    this.recognition.onspeechend = () => {
+      this.emit("silence");
+    };
+  }
+  /**
+   * Process speech recognition results
+   */
+  processRecognitionResult(event) {
+    for (let i = event.resultIndex; i < event.results.length; i++) {
+      const result = event.results[i];
+      const alternative = result[0];
+      if (!alternative) continue;
+      const transcriptionResult = {
+        text: alternative.transcript,
+        isFinal: result.isFinal,
+        confidence: alternative.confidence,
+        timestamp: Date.now(),
+        language: this.config.language
+      };
+      this.handleTranscript(transcriptionResult);
+    }
+  }
+  /**
+   * Handle recognition end event
+   */
+  handleRecognitionEnd() {
+    if (this.state === "stopping" /* STOPPING */ || this.state === "stopped" /* STOPPED */ || this.state === "paused" /* PAUSED */ || this.state === "error" /* ERROR */) {
+      return;
+    }
+    if (this.state === "active" /* ACTIVE */ && !this.isRestarting) {
+      this.isRestarting = true;
+      if (this.retryCount < this.maxRetries) {
+        this.retryCount++;
+        setTimeout(() => {
+          if (this.recognition && this.state === "active" /* ACTIVE */) {
+            try {
+              this.recognition.start();
+            } catch (error) {
+              this.handleError(error);
+            }
+          }
+          this.isRestarting = false;
+        }, 100);
+      } else {
+        this.setState("stopped" /* STOPPED */);
+        this.emit("stop");
+      }
+    }
+  }
+  /**
+   * Handle recognition errors
+   */
+  handleRecognitionError(event) {
+    let errorCode;
+    let shouldStop = false;
+    switch (event.error) {
+      case "no-speech":
+        console.warn("No speech detected");
+        return;
+      case "audio-capture":
+      case "not-allowed":
+        errorCode = "microphone_access_denied" /* MICROPHONE_ACCESS_DENIED */;
+        shouldStop = true;
+        break;
+      case "network":
+        errorCode = "network_error" /* NETWORK_ERROR */;
+        break;
+      case "aborted":
+        return;
+      case "service-not-allowed":
+        errorCode = "unsupported_browser" /* UNSUPPORTED_BROWSER */;
+        shouldStop = true;
+        break;
+      default:
+        errorCode = "provider_error" /* PROVIDER_ERROR */;
+    }
+    const error = new TranscriptionError(
+      event.message || `Speech recognition error: ${event.error}`,
+      errorCode,
+      "web-speech" /* WebSpeechAPI */,
+      { originalError: event.error }
+    );
+    if (shouldStop) {
+      this.handleError(error);
+    } else {
+      this.emit("error", error);
+    }
+  }
+  /**
+   * Request microphone access
+   */
+  async getMicrophoneAccess() {
+    try {
+      const constraints = {
+        audio: {
+          echoCancellation: true,
+          noiseSuppression: true,
+          autoGainControl: true,
+          sampleRate: this.config.audioConfig?.sampleRate || 16e3
+        }
+      };
+      this.mediaStream = await navigator.mediaDevices.getUserMedia(constraints);
+    } catch (error) {
+      const err = error;
+      throw new TranscriptionError(
+        err.message || "Microphone access denied",
+        "microphone_access_denied" /* MICROPHONE_ACCESS_DENIED */,
+        "web-speech" /* WebSpeechAPI */,
+        error
+      );
+    }
+  }
+  /**
+   * Stop media stream tracks
+   */
+  stopMediaStream() {
+    if (this.mediaStream) {
+      this.mediaStream.getTracks().forEach((track) => track.stop());
+      this.mediaStream = null;
+    }
+  }
+  /**
+   * Set up audio level monitoring for VAD
+   */
+  setupAudioLevelMonitoring() {
+    if (!this.mediaStream) return;
+    try {
+      this.audioContext = new AudioContext();
+      const source = this.audioContext.createMediaStreamSource(this.mediaStream);
+      this.analyser = this.audioContext.createAnalyser();
+      this.analyser.fftSize = 256;
+      source.connect(this.analyser);
+      const dataArray = new Uint8Array(this.analyser.frequencyBinCount);
+      this.audioLevelInterval = setInterval(() => {
+        if (this.analyser && this.state === "active" /* ACTIVE */) {
+          this.analyser.getByteFrequencyData(dataArray);
+          const average = dataArray.reduce((a, b) => a + b, 0) / dataArray.length;
+          const normalizedLevel = average / 255;
+          this.emit("audioLevel", normalizedLevel);
+        }
+      }, 100);
+    } catch (error) {
+      console.warn("Failed to set up audio level monitoring:", error);
+    }
+  }
+  /**
+   * Stop audio level monitoring
+   */
+  stopAudioLevelMonitoring() {
+    if (this.audioLevelInterval) {
+      clearInterval(this.audioLevelInterval);
+      this.audioLevelInterval = null;
+    }
+  }
+};
+/** Provider capabilities */
+_WebSpeechProvider.capabilities = {
+  supportsInterim: true,
+  supportsWordTimestamps: false,
+  supportsSpeakerDiarization: false,
+  supportsPunctuation: false,
+  supportsLanguageDetection: false,
+  supportedLanguages: [
+    "en-US",
+    "en-GB",
+    "en-AU",
+    "en-CA",
+    "en-IN",
+    "es-ES",
+    "es-MX",
+    "fr-FR",
+    "de-DE",
+    "it-IT",
+    "pt-BR",
+    "pt-PT",
+    "ja-JP",
+    "ko-KR",
+    "zh-CN",
+    "zh-TW",
+    "ru-RU",
+    "ar-SA",
+    "hi-IN",
+    "nl-NL"
+  ]
+};
+var WebSpeechProvider = _WebSpeechProvider;
+
+// src/providers/DeepgramProvider.ts
+var DEEPGRAM_WS_URL = "wss://api.deepgram.com/v1/listen";
+var KEEP_ALIVE_INTERVAL = 5e3;
+var RECONNECT_DELAY = 1e3;
+var _DeepgramProvider = class _DeepgramProvider extends BaseTranscriber {
+  /**
+   * Create a new DeepgramProvider
+   * @param config - Transcription configuration with API key
+   */
+  constructor(config) {
+    super({ ...config, provider: "deepgram" /* Deepgram */ });
+    /** WebSocket connection */
+    this.socket = null;
+    /** Media stream from microphone */
+    this.mediaStream = null;
+    /** Audio context for processing */
+    this.audioContext = null;
+    /** Audio processor node */
+    this.processor = null;
+    /** Connection attempt counter */
+    this.connectionAttempts = 0;
+    /** Maximum reconnection attempts */
+    this.maxRetries = 3;
+    /** Reconnection timeout */
+    this.reconnectTimeout = null;
+    /** Keep-alive interval */
+    this.keepAliveInterval = null;
+    /** Flag indicating if connection is ready */
+    this.isConnectionReady = false;
+    /** Flag for intentional close */
+    this.isIntentionalClose = false;
+  }
+  /**
+   * Check if Deepgram provider is supported
+   */
+  isSupported() {
+    if (typeof window === "undefined") {
+      return typeof WebSocket !== "undefined";
+    }
+    return !!(typeof WebSocket !== "undefined" && navigator.mediaDevices && typeof navigator.mediaDevices.getUserMedia === "function" && (window.AudioContext || window.webkitAudioContext));
+  }
+  /**
+   * Initialize the Deepgram provider
+   */
+  async initialize() {
+    if (!this.config.apiKey) {
+      throw new TranscriptionError(
+        "Deepgram API key is required",
+        "invalid_config" /* INVALID_CONFIG */,
+        "deepgram" /* Deepgram */
+      );
+    }
+    if (!this.isSupported()) {
+      throw new TranscriptionError(
+        "Deepgram provider is not supported in this environment",
+        "unsupported_browser" /* UNSUPPORTED_BROWSER */,
+        "deepgram" /* Deepgram */
+      );
+    }
+    this.setState("initializing" /* INITIALIZING */);
+    this.isConnectionReady = false;
+    this.isIntentionalClose = false;
+    try {
+      await this.setupWebSocket();
+    } catch (error) {
+      this.handleError(error);
+      throw error;
+    }
+  }
+  /**
+   * Start transcription
+   */
+  async start() {
+    if (!this.socket || !this.isConnectionReady) {
+      await this.initialize();
+    }
+    if (this.state === "active" /* ACTIVE */) {
+      return;
+    }
+    try {
+      await this.getMicrophoneAccess();
+      this.setupAudioProcessing();
+      this.setState("active" /* ACTIVE */);
+      this.emit("start");
+    } catch (error) {
+      this.handleError(error);
+      throw error;
+    }
+  }
+  /**
+   * Stop transcription
+   */
+  async stop() {
+    if (this.state === "stopped" /* STOPPED */ || this.state === "idle" /* IDLE */) {
+      return;
+    }
+    this.setState("stopping" /* STOPPING */);
+    this.isIntentionalClose = true;
+    this.stopKeepAlive();
+    if (this.socket && this.socket.readyState === WebSocket.OPEN) {
+      try {
+        this.socket.send(JSON.stringify({ type: "CloseStream" }));
+        await new Promise((resolve) => setTimeout(resolve, 500));
+      } catch {
+      }
+    }
+    this.closeWebSocket();
+    this.stopAudioProcessing();
+    this.stopMediaStream();
+    this.setState("stopped" /* STOPPED */);
+    this.emit("stop");
+  }
+  /**
+   * Pause transcription
+   */
+  pause() {
+    if (this.state !== "active" /* ACTIVE */) {
+      return;
+    }
+    this.stopAudioProcessing();
+    this.setState("paused" /* PAUSED */);
+    this.emit("pause");
+  }
+  /**
+   * Resume transcription
+   */
+  resume() {
+    if (this.state !== "paused" /* PAUSED */) {
+      return;
+    }
+    if (this.mediaStream && this.audioContext) {
+      this.setupAudioProcessing();
+    }
+    this.setState("active" /* ACTIVE */);
+    this.emit("resume");
+  }
+  /**
+   * Send audio data through WebSocket
+   * @param audioData - Raw audio data as ArrayBuffer
+   */
+  sendAudio(audioData) {
+    if (this.socket && this.socket.readyState === WebSocket.OPEN && this.state === "active" /* ACTIVE */) {
+      this.socket.send(audioData);
+      this.recordAudioData(audioData);
+    }
+  }
+  /**
+   * Clean up all resources
+   */
+  async cleanup() {
+    this.isIntentionalClose = true;
+    this.stopKeepAlive();
+    if (this.reconnectTimeout) {
+      clearTimeout(this.reconnectTimeout);
+      this.reconnectTimeout = null;
+    }
+    this.closeWebSocket();
+    this.stopAudioProcessing();
+    if (this.audioContext) {
+      try {
+        await this.audioContext.close();
+      } catch {
+      }
+      this.audioContext = null;
+    }
+    this.stopMediaStream();
+    this.connectionAttempts = 0;
+    this.isConnectionReady = false;
+    this.removeAllListeners();
+  }
+  /**
+   * Get provider capabilities
+   */
+  getCapabilities() {
+    return _DeepgramProvider.capabilities;
+  }
+  // ==================== Private Methods ====================
+  /**
+   * Build WebSocket URL with query parameters
+   */
+  buildWebSocketUrl() {
+    const params = new URLSearchParams();
+    const options = this.config.providerOptions || {};
+    params.set("model", options.model || "nova-2");
+    if (options.version) params.set("version", options.version);
+    if (options.tier) params.set("tier", options.tier);
+    if (this.config.language) {
+      params.set("language", this.config.language);
+    }
+    params.set("punctuate", String(this.config.punctuation ?? options.punctuate ?? true));
+    params.set("interim_results", String(this.config.interimResults ?? true));
+    if (options.diarize) params.set("diarize", "true");
+    if (options.multichannel) params.set("multichannel", "true");
+    if (options.alternatives) params.set("alternatives", String(options.alternatives));
+    if (options.numerals) params.set("numerals", "true");
+    if (options.smartFormat) params.set("smart_format", "true");
+    if (options.endpointing !== void 0) params.set("endpointing", String(options.endpointing));
+    if (options.keywords?.length) {
+      options.keywords.forEach((k) => params.append("keywords", k));
+    }
+    if (options.search?.length) {
+      options.search.forEach((s) => params.append("search", s));
+    }
+    params.set("encoding", "linear16");
+    params.set("sample_rate", String(this.config.audioConfig?.sampleRate || 16e3));
+    params.set("channels", String(this.config.audioConfig?.channels || 1));
+    return `${DEEPGRAM_WS_URL}?${params.toString()}`;
+  }
+  /**
+   * Set up WebSocket connection
+   */
+  async setupWebSocket() {
+    return new Promise((resolve, reject) => {
+      const url = this.buildWebSocketUrl();
+      this.socket = new WebSocket(url, ["token", this.config.apiKey]);
+      this.socket.binaryType = "arraybuffer";
+      const connectionTimeout = setTimeout(() => {
+        reject(new TranscriptionError(
+          "WebSocket connection timeout",
+          "connection_failed" /* CONNECTION_FAILED */,
+          "deepgram" /* Deepgram */
+        ));
+      }, 1e4);
+      this.socket.onopen = () => {
+        clearTimeout(connectionTimeout);
+        this.handleWebSocketOpen();
+        resolve();
+      };
+      this.socket.onmessage = (event) => {
+        this.handleWebSocketMessage(event);
+      };
+      this.socket.onerror = (event) => {
+        clearTimeout(connectionTimeout);
+        this.handleWebSocketError(event);
+        reject(new TranscriptionError(
+          "WebSocket connection error",
+          "connection_failed" /* CONNECTION_FAILED */,
+          "deepgram" /* Deepgram */
+        ));
+      };
+      this.socket.onclose = (event) => {
+        clearTimeout(connectionTimeout);
+        this.handleWebSocketClose(event);
+      };
+    });
+  }
+  /**
+   * Handle WebSocket open event
+   */
+  handleWebSocketOpen() {
+    this.isConnectionReady = true;
+    this.connectionAttempts = 0;
+    this.startKeepAlive();
+  }
+  /**
+   * Handle incoming WebSocket messages
+   */
+  handleWebSocketMessage(event) {
+    try {
+      const message = JSON.parse(event.data);
+      switch (message.type) {
+        case "Results":
+          this.processTranscriptionResult(message);
+          break;
+        case "Metadata":
+          break;
+        case "SpeechStarted":
+          this.emit("speech");
+          break;
+        case "UtteranceEnd":
+          this.emit("silence");
+          break;
+        case "Error":
+          this.handleDeepgramError(message);
+          break;
+      }
+    } catch (error) {
+      console.error("Failed to parse Deepgram message:", error);
+    }
+  }
+  /**
+   * Process transcription result from Deepgram
+   */
+  processTranscriptionResult(message) {
+    if (!message.channel?.alternatives?.length) {
+      return;
+    }
+    const alternative = message.channel.alternatives[0];
+    const isFinal = message.is_final ?? message.speech_final ?? false;
+    if (!alternative.transcript && !isFinal) {
+      return;
+    }
+    const words = alternative.words?.map((w) => ({
+      text: w.word,
+      start: Math.round(w.start * 1e3),
+      // Convert to milliseconds
+      end: Math.round(w.end * 1e3),
+      confidence: w.confidence
+    }));
+    const result = {
+      text: alternative.transcript,
+      isFinal,
+      confidence: alternative.confidence,
+      timestamp: Date.now(),
+      words,
+      language: this.config.language
+    };
+    this.handleTranscript(result);
+  }
+  /**
+   * Handle Deepgram-specific errors
+   */
+  handleDeepgramError(message) {
+    let errorCode = "provider_error" /* PROVIDER_ERROR */;
+    const errorMessage = message.error?.message || "Unknown Deepgram error";
+    if (errorMessage.toLowerCase().includes("unauthorized") || errorMessage.toLowerCase().includes("invalid api key")) {
+      errorCode = "authentication_failed" /* AUTHENTICATION_FAILED */;
+    } else if (errorMessage.toLowerCase().includes("rate limit")) {
+      errorCode = "provider_error" /* PROVIDER_ERROR */;
+    }
+    const error = new TranscriptionError(
+      errorMessage,
+      errorCode,
+      "deepgram" /* Deepgram */,
+      message.error
+    );
+    this.emit("error", error);
+  }
+  /**
+   * Handle WebSocket error
+   */
+  handleWebSocketError(_event) {
+    if (!this.isIntentionalClose && this.connectionAttempts < this.maxRetries) {
+      this.reconnect();
+    } else {
+      const error = new TranscriptionError(
+        "WebSocket connection error",
+        "connection_failed" /* CONNECTION_FAILED */,
+        "deepgram" /* Deepgram */
+      );
+      this.handleError(error);
+    }
+  }
+  /**
+   * Handle WebSocket close
+   */
+  handleWebSocketClose(event) {
+    this.isConnectionReady = false;
+    if (!this.isIntentionalClose && this.state === "active" /* ACTIVE */) {
+      if (this.connectionAttempts < this.maxRetries) {
+        this.reconnect();
+      } else {
+        const error = new TranscriptionError(
+          `WebSocket closed unexpectedly: ${event.code} ${event.reason}`,
+          "connection_failed" /* CONNECTION_FAILED */,
+          "deepgram" /* Deepgram */
+        );
+        this.handleError(error);
+      }
+    }
+  }
+  /**
+   * Attempt to reconnect
+   */
+  reconnect() {
+    this.connectionAttempts++;
+    const delay = RECONNECT_DELAY * Math.pow(2, this.connectionAttempts - 1);
+    this.reconnectTimeout = setTimeout(async () => {
+      try {
+        await this.setupWebSocket();
+        if (this.mediaStream) {
+          this.setupAudioProcessing();
+        }
+      } catch (error) {
+        if (this.connectionAttempts < this.maxRetries) {
+          this.reconnect();
+        } else {
+          this.handleError(error);
+        }
+      }
+    }, delay);
+  }
+  /**
+   * Start keep-alive interval
+   */
+  startKeepAlive() {
+    this.keepAliveInterval = setInterval(() => {
+      if (this.socket && this.socket.readyState === WebSocket.OPEN) {
+        this.socket.send(JSON.stringify({ type: "KeepAlive" }));
+      }
+    }, KEEP_ALIVE_INTERVAL);
+  }
+  /**
+   * Stop keep-alive interval
+   */
+  stopKeepAlive() {
+    if (this.keepAliveInterval) {
+      clearInterval(this.keepAliveInterval);
+      this.keepAliveInterval = null;
+    }
+  }
+  /**
+   * Request microphone access
+   */
+  async getMicrophoneAccess() {
+    try {
+      const sampleRate = this.config.audioConfig?.sampleRate || 16e3;
+      this.mediaStream = await navigator.mediaDevices.getUserMedia({
+        audio: {
+          sampleRate,
+          channelCount: this.config.audioConfig?.channels || 1,
+          echoCancellation: true,
+          noiseSuppression: true,
+          autoGainControl: true
+        }
+      });
+    } catch (error) {
+      throw new TranscriptionError(
+        "Microphone access denied",
+        "microphone_access_denied" /* MICROPHONE_ACCESS_DENIED */,
+        "deepgram" /* Deepgram */,
+        error
+      );
+    }
+  }
+  /**
+   * Set up audio processing pipeline
+   */
+  setupAudioProcessing() {
+    if (!this.mediaStream) return;
+    const AudioContextClass = window.AudioContext || window.webkitAudioContext;
+    this.audioContext = new AudioContextClass({
+      sampleRate: this.config.audioConfig?.sampleRate || 16e3
+    });
+    const source = this.audioContext.createMediaStreamSource(this.mediaStream);
+    this.processor = this.audioContext.createScriptProcessor(4096, 1, 1);
+    this.processor.onaudioprocess = (event) => {
+      if (this.state !== "active" /* ACTIVE */) return;
+      const inputData = event.inputBuffer.getChannelData(0);
+      const int16Data = this.convertFloat32ToInt16(inputData);
+      this.sendAudio(int16Data.buffer);
+    };
+    source.connect(this.processor);
+    this.processor.connect(this.audioContext.destination);
+  }
+  /**
+   * Stop audio processing
+   */
+  stopAudioProcessing() {
+    if (this.processor) {
+      this.processor.disconnect();
+      this.processor.onaudioprocess = null;
+      this.processor = null;
+    }
+  }
+  /**
+   * Convert Float32 audio samples to Int16
+   */
+  convertFloat32ToInt16(buffer) {
+    const int16 = new Int16Array(buffer.length);
+    for (let i = 0; i < buffer.length; i++) {
+      const s = Math.max(-1, Math.min(1, buffer[i]));
+      int16[i] = s < 0 ? s * 32768 : s * 32767;
+    }
+    return int16;
+  }
+  /**
+   * Close WebSocket connection
+   */
+  closeWebSocket() {
+    if (this.socket) {
+      this.socket.onopen = null;
+      this.socket.onmessage = null;
+      this.socket.onerror = null;
+      this.socket.onclose = null;
+      if (this.socket.readyState === WebSocket.OPEN || this.socket.readyState === WebSocket.CONNECTING) {
+        this.socket.close();
+      }
+      this.socket = null;
+    }
+  }
+  /**
+   * Stop media stream tracks
+   */
+  stopMediaStream() {
+    if (this.mediaStream) {
+      this.mediaStream.getTracks().forEach((track) => track.stop());
+      this.mediaStream = null;
+    }
+  }
+};
+/** Provider capabilities */
+_DeepgramProvider.capabilities = {
+  supportsInterim: true,
+  supportsWordTimestamps: true,
+  supportsSpeakerDiarization: true,
+  supportsPunctuation: true,
+  supportsLanguageDetection: true,
+  supportedLanguages: [
+    "en",
+    "en-US",
+    "en-GB",
+    "en-AU",
+    "en-IN",
+    "es",
+    "es-ES",
+    "es-419",
+    "fr",
+    "fr-FR",
+    "fr-CA",
+    "de",
+    "de-DE",
+    "it",
+    "it-IT",
+    "pt",
+    "pt-BR",
+    "pt-PT",
+    "nl",
+    "nl-NL",
+    "ja",
+    "ja-JP",
+    "ko",
+    "ko-KR",
+    "zh",
+    "zh-CN",
+    "zh-TW",
+    "ru",
+    "ru-RU",
+    "uk",
+    "uk-UA",
+    "hi",
+    "hi-IN",
+    "tr",
+    "tr-TR",
+    "pl",
+    "pl-PL",
+    "sv",
+    "sv-SE",
+    "da",
+    "da-DK",
+    "no",
+    "no-NO",
+    "fi",
+    "fi-FI"
+  ]
+};
+var DeepgramProvider = _DeepgramProvider;
+
+// src/providers/AssemblyAIProvider.ts
+var ASSEMBLYAI_AUTH_URL = "https://api.assemblyai.com/v2/realtime/token";
+var ASSEMBLYAI_WS_URL = "wss://api.assemblyai.com/v2/realtime/ws";
+var SAMPLE_RATE = 16e3;
+var RECONNECT_DELAY2 = 1e3;
+var _AssemblyAIProvider = class _AssemblyAIProvider extends BaseTranscriber {
+  /**
+   * Create a new AssemblyAIProvider
+   * @param config - Transcription configuration with API key
+   */
+  constructor(config) {
+    super({ ...config, provider: "assemblyai" /* AssemblyAI */ });
+    /** WebSocket connection */
+    this.socket = null;
+    /** Media stream from microphone */
+    this.mediaStream = null;
+    /** Audio context for processing */
+    this.audioContext = null;
+    /** Audio processor node */
+    this.processor = null;
+    /** Session token for WebSocket authentication */
+    this.sessionToken = null;
+    /** Connection attempt counter */
+    this.connectionAttempts = 0;
+    /** Maximum reconnection attempts */
+    this.maxRetries = 3;
+    /** Reconnection timeout */
+    this.reconnectTimeout = null;
+    /** Flag indicating if connection is ready */
+    this.isConnectionReady = false;
+    /** Flag for intentional close */
+    this.isIntentionalClose = false;
+    /** Session ID from AssemblyAI */
+    this.sessionId = null;
+  }
+  /**
+   * Check if AssemblyAI provider is supported
+   */
+  isSupported() {
+    if (typeof window === "undefined") {
+      return typeof WebSocket !== "undefined" && typeof fetch !== "undefined";
+    }
+    return !!(typeof WebSocket !== "undefined" && typeof fetch !== "undefined" && navigator.mediaDevices && typeof navigator.mediaDevices.getUserMedia === "function" && (window.AudioContext || window.webkitAudioContext));
+  }
+  /**
+   * Initialize the AssemblyAI provider
+   */
+  async initialize() {
+    if (!this.config.apiKey) {
+      throw new TranscriptionError(
+        "AssemblyAI API key is required",
+        "invalid_config" /* INVALID_CONFIG */,
+        "assemblyai" /* AssemblyAI */
+      );
+    }
+    if (!this.isSupported()) {
+      throw new TranscriptionError(
+        "AssemblyAI provider is not supported in this environment",
+        "unsupported_browser" /* UNSUPPORTED_BROWSER */,
+        "assemblyai" /* AssemblyAI */
+      );
+    }
+    this.setState("initializing" /* INITIALIZING */);
+    this.isConnectionReady = false;
+    this.isIntentionalClose = false;
+    try {
+      this.sessionToken = await this.getSessionToken();
+      await this.setupWebSocket();
+    } catch (error) {
+      this.handleError(error);
+      throw error;
+    }
+  }
+  /**
+   * Start transcription
+   */
+  async start() {
+    if (!this.socket || !this.isConnectionReady) {
+      await this.initialize();
+    }
+    if (this.state === "active" /* ACTIVE */) {
+      return;
+    }
+    try {
+      await this.getMicrophoneAccess();
+      this.setupAudioProcessing();
+      this.setState("active" /* ACTIVE */);
+      this.emit("start");
+    } catch (error) {
+      this.handleError(error);
+      throw error;
+    }
+  }
+  /**
+   * Stop transcription
+   */
+  async stop() {
+    if (this.state === "stopped" /* STOPPED */ || this.state === "idle" /* IDLE */) {
+      return;
+    }
+    this.setState("stopping" /* STOPPING */);
+    this.isIntentionalClose = true;
+    this.sendTerminateMessage();
+    await new Promise((resolve) => setTimeout(resolve, 500));
+    this.closeWebSocket();
+    this.stopAudioProcessing();
+    this.stopMediaStream();
+    this.setState("stopped" /* STOPPED */);
+    this.emit("stop");
+  }
+  /**
+   * Pause transcription
+   */
+  pause() {
+    if (this.state !== "active" /* ACTIVE */) {
+      return;
+    }
+    this.stopAudioProcessing();
+    this.setState("paused" /* PAUSED */);
+    this.emit("pause");
+  }
+  /**
+   * Resume transcription
+   */
+  resume() {
+    if (this.state !== "paused" /* PAUSED */) {
+      return;
+    }
+    if (this.mediaStream && this.audioContext) {
+      this.setupAudioProcessing();
+    }
+    this.setState("active" /* ACTIVE */);
+    this.emit("resume");
+  }
+  /**
+   * Send audio data through WebSocket
+   * @param audioData - Raw audio data as ArrayBuffer
+   */
+  sendAudio(audioData) {
+    if (this.socket && this.socket.readyState === WebSocket.OPEN && this.state === "active" /* ACTIVE */) {
+      const base64Audio = this.encodeAudioToBase64(audioData);
+      this.sendAudioMessage(base64Audio);
+      this.recordAudioData(audioData);
+    }
+  }
+  /**
+   * Clean up all resources
+   */
+  async cleanup() {
+    this.isIntentionalClose = true;
+    if (this.reconnectTimeout) {
+      clearTimeout(this.reconnectTimeout);
+      this.reconnectTimeout = null;
+    }
+    this.closeWebSocket();
+    this.stopAudioProcessing();
+    if (this.audioContext) {
+      try {
+        await this.audioContext.close();
+      } catch {
+      }
+      this.audioContext = null;
+    }
+    this.stopMediaStream();
+    this.sessionToken = null;
+    this.sessionId = null;
+    this.connectionAttempts = 0;
+    this.isConnectionReady = false;
+    this.removeAllListeners();
+  }
+  /**
+   * Get provider capabilities
+   */
+  getCapabilities() {
+    return _AssemblyAIProvider.capabilities;
+  }
+  // ==================== Private Methods ====================
+  /**
+   * Get temporary session token from AssemblyAI
+   */
+  async getSessionToken() {
+    try {
+      const response = await fetch(ASSEMBLYAI_AUTH_URL, {
+        method: "POST",
+        headers: {
+          "authorization": this.config.apiKey,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({ expires_in: 3600 })
+      });
+      if (!response.ok) {
+        if (response.status === 401) {
+          throw new TranscriptionError(
+            "Invalid AssemblyAI API key",
+            "authentication_failed" /* AUTHENTICATION_FAILED */,
+            "assemblyai" /* AssemblyAI */
+          );
+        }
+        throw new TranscriptionError(
+          `Failed to get session token: ${response.statusText}`,
+          "provider_error" /* PROVIDER_ERROR */,
+          "assemblyai" /* AssemblyAI */
+        );
+      }
+      const data = await response.json();
+      return data.token;
+    } catch (error) {
+      if (error instanceof TranscriptionError) {
+        throw error;
+      }
+      throw new TranscriptionError(
+        "Failed to authenticate with AssemblyAI",
+        "network_error" /* NETWORK_ERROR */,
+        "assemblyai" /* AssemblyAI */,
+        error
+      );
+    }
+  }
+  /**
+   * Set up WebSocket connection
+   */
+  async setupWebSocket() {
+    return new Promise((resolve, reject) => {
+      const url = `${ASSEMBLYAI_WS_URL}?sample_rate=${SAMPLE_RATE}&token=${this.sessionToken}`;
+      this.socket = new WebSocket(url);
+      const connectionTimeout = setTimeout(() => {
+        reject(new TranscriptionError(
+          "WebSocket connection timeout",
+          "connection_failed" /* CONNECTION_FAILED */,
+          "assemblyai" /* AssemblyAI */
+        ));
+      }, 1e4);
+      this.socket.onopen = () => {
+        clearTimeout(connectionTimeout);
+        this.handleWebSocketOpen();
+        resolve();
+      };
+      this.socket.onmessage = (event) => {
+        this.handleWebSocketMessage(event);
+      };
+      this.socket.onerror = (event) => {
+        clearTimeout(connectionTimeout);
+        this.handleWebSocketError(event);
+        reject(new TranscriptionError(
+          "WebSocket connection error",
+          "connection_failed" /* CONNECTION_FAILED */,
+          "assemblyai" /* AssemblyAI */
+        ));
+      };
+      this.socket.onclose = (event) => {
+        clearTimeout(connectionTimeout);
+        this.handleWebSocketClose(event);
+      };
+    });
+  }
+  /**
+   * Handle WebSocket open event
+   */
+  handleWebSocketOpen() {
+    this.connectionAttempts = 0;
+  }
+  /**
+   * Handle incoming WebSocket messages
+   */
+  handleWebSocketMessage(event) {
+    try {
+      const message = JSON.parse(event.data);
+      switch (message.message_type) {
+        case "SessionBegins":
+          this.handleSessionBegins(message);
+          break;
+        case "PartialTranscript":
+          this.handlePartialTranscript(message);
+          break;
+        case "FinalTranscript":
+          this.handleFinalTranscript(message);
+          break;
+        case "SessionTerminated":
+          this.handleSessionTerminated();
+          break;
+        case "error":
+          this.handleAssemblyAIError(message);
+          break;
+      }
+    } catch (error) {
+      console.error("Failed to parse AssemblyAI message:", error);
+    }
+  }
+  /**
+   * Handle SessionBegins message
+   */
+  handleSessionBegins(message) {
+    this.sessionId = message.session_id || null;
+    this.isConnectionReady = true;
+  }
+  /**
+   * Handle partial (interim) transcript
+   */
+  handlePartialTranscript(message) {
+    if (!message.text) return;
+    const result = {
+      text: message.text,
+      isFinal: false,
+      confidence: message.confidence,
+      timestamp: Date.now(),
+      language: this.config.language
+    };
+    this.handleTranscript(result);
+  }
+  /**
+   * Handle final transcript
+   */
+  handleFinalTranscript(message) {
+    if (!message.text) return;
+    const words = message.words?.map((w) => ({
+      text: w.text,
+      start: w.start,
+      end: w.end,
+      confidence: w.confidence
+    }));
+    const result = {
+      text: message.text,
+      isFinal: true,
+      confidence: message.confidence,
+      timestamp: Date.now(),
+      words,
+      language: this.config.language
+    };
+    this.handleTranscript(result);
+  }
+  /**
+   * Handle session terminated message
+   */
+  handleSessionTerminated() {
+    this.isConnectionReady = false;
+    if (!this.isIntentionalClose) {
+      this.setState("stopped" /* STOPPED */);
+      this.emit("stop");
+    }
+  }
+  /**
+   * Handle AssemblyAI-specific errors
+   */
+  handleAssemblyAIError(message) {
+    let errorCode = "provider_error" /* PROVIDER_ERROR */;
+    const errorMessage = message.error || "Unknown AssemblyAI error";
+    if (errorMessage.toLowerCase().includes("unauthorized") || errorMessage.toLowerCase().includes("invalid token")) {
+      errorCode = "authentication_failed" /* AUTHENTICATION_FAILED */;
+    } else if (errorMessage.toLowerCase().includes("insufficient credits")) {
+      errorCode = "provider_error" /* PROVIDER_ERROR */;
+    } else if (errorMessage.toLowerCase().includes("session expired")) {
+      errorCode = "session_expired" /* SESSION_EXPIRED */;
+    }
+    const error = new TranscriptionError(
+      errorMessage,
+      errorCode,
+      "assemblyai" /* AssemblyAI */,
+      message
+    );
+    this.emit("error", error);
+  }
+  /**
+   * Handle WebSocket error
+   */
+  handleWebSocketError(_event) {
+    if (!this.isIntentionalClose && this.connectionAttempts < this.maxRetries) {
+      this.reconnect();
+    } else {
+      const error = new TranscriptionError(
+        "WebSocket connection error",
+        "connection_failed" /* CONNECTION_FAILED */,
+        "assemblyai" /* AssemblyAI */
+      );
+      this.handleError(error);
+    }
+  }
+  /**
+   * Handle WebSocket close
+   */
+  handleWebSocketClose(event) {
+    this.isConnectionReady = false;
+    if (!this.isIntentionalClose && this.state === "active" /* ACTIVE */) {
+      if (this.connectionAttempts < this.maxRetries) {
+        this.reconnect();
+      } else {
+        const error = new TranscriptionError(
+          `WebSocket closed unexpectedly: ${event.code} ${event.reason}`,
+          "connection_failed" /* CONNECTION_FAILED */,
+          "assemblyai" /* AssemblyAI */
+        );
+        this.handleError(error);
+      }
+    }
+  }
+  /**
+   * Attempt to reconnect
+   */
+  reconnect() {
+    this.connectionAttempts++;
+    const delay = RECONNECT_DELAY2 * Math.pow(2, this.connectionAttempts - 1);
+    this.reconnectTimeout = setTimeout(async () => {
+      try {
+        this.sessionToken = await this.getSessionToken();
+        await this.setupWebSocket();
+        if (this.mediaStream) {
+          this.setupAudioProcessing();
+        }
+      } catch (error) {
+        if (this.connectionAttempts < this.maxRetries) {
+          this.reconnect();
+        } else {
+          this.handleError(error);
+        }
+      }
+    }, delay);
+  }
+  /**
+   * Request microphone access
+   */
+  async getMicrophoneAccess() {
+    try {
+      this.mediaStream = await navigator.mediaDevices.getUserMedia({
+        audio: {
+          sampleRate: SAMPLE_RATE,
+          channelCount: 1,
+          echoCancellation: true,
+          noiseSuppression: true,
+          autoGainControl: true
+        }
+      });
+    } catch (error) {
+      throw new TranscriptionError(
+        "Microphone access denied",
+        "microphone_access_denied" /* MICROPHONE_ACCESS_DENIED */,
+        "assemblyai" /* AssemblyAI */,
+        error
+      );
+    }
+  }
+  /**
+   * Set up audio processing pipeline
+   */
+  setupAudioProcessing() {
+    if (!this.mediaStream) return;
+    const AudioContextClass = window.AudioContext || window.webkitAudioContext;
+    this.audioContext = new AudioContextClass({ sampleRate: SAMPLE_RATE });
+    const source = this.audioContext.createMediaStreamSource(this.mediaStream);
+    this.processor = this.audioContext.createScriptProcessor(4096, 1, 1);
+    this.processor.onaudioprocess = (event) => {
+      if (this.state !== "active" /* ACTIVE */) return;
+      const inputData = event.inputBuffer.getChannelData(0);
+      const pcmData = this.convertFloat32ToPCM16(inputData);
+      this.sendAudio(pcmData);
+    };
+    source.connect(this.processor);
+    this.processor.connect(this.audioContext.destination);
+  }
+  /**
+   * Stop audio processing
+   */
+  stopAudioProcessing() {
+    if (this.processor) {
+      this.processor.disconnect();
+      this.processor.onaudioprocess = null;
+      this.processor = null;
+    }
+  }
+  /**
+   * Convert Float32 audio samples to PCM16 (Int16)
+   */
+  convertFloat32ToPCM16(float32Array) {
+    const int16 = new Int16Array(float32Array.length);
+    for (let i = 0; i < float32Array.length; i++) {
+      const s = Math.max(-1, Math.min(1, float32Array[i]));
+      int16[i] = s < 0 ? s * 32768 : s * 32767;
+    }
+    return int16.buffer;
+  }
+  /**
+   * Encode ArrayBuffer to base64
+   */
+  encodeAudioToBase64(arrayBuffer) {
+    const bytes = new Uint8Array(arrayBuffer);
+    let binary = "";
+    for (let i = 0; i < bytes.byteLength; i++) {
+      binary += String.fromCharCode(bytes[i]);
+    }
+    return btoa(binary);
+  }
+  /**
+   * Send audio data message
+   */
+  sendAudioMessage(base64Audio) {
+    if (this.socket && this.socket.readyState === WebSocket.OPEN) {
+      this.socket.send(JSON.stringify({ audio_data: base64Audio }));
+    }
+  }
+  /**
+   * Send terminate session message
+   */
+  sendTerminateMessage() {
+    if (this.socket && this.socket.readyState === WebSocket.OPEN) {
+      this.socket.send(JSON.stringify({ terminate_session: true }));
+    }
+  }
+  /**
+   * Close WebSocket connection
+   */
+  closeWebSocket() {
+    if (this.socket) {
+      this.socket.onopen = null;
+      this.socket.onmessage = null;
+      this.socket.onerror = null;
+      this.socket.onclose = null;
+      if (this.socket.readyState === WebSocket.OPEN || this.socket.readyState === WebSocket.CONNECTING) {
+        this.socket.close();
+      }
+      this.socket = null;
+    }
+  }
+  /**
+   * Stop media stream tracks
+   */
+  stopMediaStream() {
+    if (this.mediaStream) {
+      this.mediaStream.getTracks().forEach((track) => track.stop());
+      this.mediaStream = null;
+    }
+  }
+};
+/** Provider capabilities */
+_AssemblyAIProvider.capabilities = {
+  supportsInterim: true,
+  supportsWordTimestamps: true,
+  supportsSpeakerDiarization: true,
+  supportsPunctuation: true,
+  supportsLanguageDetection: false,
+  supportedLanguages: ["en", "en-US", "en-GB", "en-AU"]
+};
+var AssemblyAIProvider = _AssemblyAIProvider;
+
+// src/utils/AudioProcessor.ts
+var AudioProcessor = class {
+  /**
+   * Convert Float32 audio samples to Int16
+   * @param buffer - Input Float32Array
+   * @returns Int16Array of converted samples
+   */
+  static convertFloat32ToInt16(buffer) {
+    const int16 = new Int16Array(buffer.length);
+    for (let i = 0; i < buffer.length; i++) {
+      const s = Math.max(-1, Math.min(1, buffer[i]));
+      int16[i] = s < 0 ? s * 32768 : s * 32767;
+    }
+    return int16;
+  }
+  /**
+   * Convert Int16 audio samples to Float32
+   * @param buffer - Input Int16Array
+   * @returns Float32Array of converted samples
+   */
+  static convertInt16ToFloat32(buffer) {
+    const float32 = new Float32Array(buffer.length);
+    for (let i = 0; i < buffer.length; i++) {
+      float32[i] = buffer[i] / 32768;
+    }
+    return float32;
+  }
+  /**
+   * Resample audio buffer to different sample rate
+   * Uses linear interpolation
+   * @param buffer - Input audio buffer
+   * @param fromRate - Source sample rate
+   * @param toRate - Target sample rate
+   * @returns Resampled Float32Array
+   */
+  static resampleBuffer(buffer, fromRate, toRate) {
+    if (fromRate === toRate) {
+      return buffer;
+    }
+    const ratio = toRate / fromRate;
+    const newLength = Math.round(buffer.length * ratio);
+    const output = new Float32Array(newLength);
+    for (let i = 0; i < newLength; i++) {
+      const srcPosition = i / ratio;
+      const srcIndex = Math.floor(srcPosition);
+      const fraction = srcPosition - srcIndex;
+      const sample1 = buffer[srcIndex] || 0;
+      const sample2 = buffer[srcIndex + 1] || sample1;
+      output[i] = sample1 + (sample2 - sample1) * fraction;
+    }
+    return output;
+  }
+  /**
+   * Downsample audio buffer (optimized for reducing sample rate)
+   * @param buffer - Input audio buffer
+   * @param fromRate - Source sample rate
+   * @param toRate - Target sample rate
+   * @returns Downsampled Float32Array
+   */
+  static downsampleBuffer(buffer, fromRate, toRate) {
+    if (fromRate <= toRate) {
+      return buffer;
+    }
+    const ratio = fromRate / toRate;
+    const newLength = Math.ceil(buffer.length / ratio);
+    const output = new Float32Array(newLength);
+    for (let i = 0; i < newLength; i++) {
+      const startIdx = Math.floor(i * ratio);
+      const endIdx = Math.min(Math.floor((i + 1) * ratio), buffer.length);
+      let sum = 0;
+      const count = endIdx - startIdx;
+      for (let j = startIdx; j < endIdx; j++) {
+        sum += buffer[j];
+      }
+      output[i] = count > 0 ? sum / count : 0;
+    }
+    return output;
+  }
+  /**
+   * Upsample audio buffer (optimized for increasing sample rate)
+   * @param buffer - Input audio buffer
+   * @param fromRate - Source sample rate
+   * @param toRate - Target sample rate
+   * @returns Upsampled Float32Array
+   */
+  static upsampleBuffer(buffer, fromRate, toRate) {
+    if (fromRate >= toRate) {
+      return buffer;
+    }
+    return this.resampleBuffer(buffer, fromRate, toRate);
+  }
+  /**
+   * Normalize audio buffer to peak amplitude of 1.0
+   * @param buffer - Input audio buffer
+   * @returns Normalized Float32Array
+   */
+  static normalizeBuffer(buffer) {
+    let peak = 0;
+    for (let i = 0; i < buffer.length; i++) {
+      const abs = Math.abs(buffer[i]);
+      if (abs > peak) peak = abs;
+    }
+    if (peak === 0) {
+      return buffer;
+    }
+    const output = new Float32Array(buffer.length);
+    for (let i = 0; i < buffer.length; i++) {
+      output[i] = buffer[i] / peak;
+    }
+    return output;
+  }
+  /**
+   * Apply gain to audio buffer
+   * @param buffer - Input audio buffer
+   * @param gain - Gain multiplier
+   * @returns Processed Float32Array
+   */
+  static applyGain(buffer, gain) {
+    const output = new Float32Array(buffer.length);
+    for (let i = 0; i < buffer.length; i++) {
+      output[i] = Math.max(-1, Math.min(1, buffer[i] * gain));
+    }
+    return output;
+  }
+  /**
+   * Mix two audio buffers together
+   * @param buffer1 - First audio buffer
+   * @param buffer2 - Second audio buffer
+   * @param ratio - Mix ratio (0-1, where 0.5 is equal mix)
+   * @returns Mixed Float32Array
+   */
+  static mixBuffers(buffer1, buffer2, ratio = 0.5) {
+    const length = Math.max(buffer1.length, buffer2.length);
+    const output = new Float32Array(length);
+    for (let i = 0; i < length; i++) {
+      const s1 = i < buffer1.length ? buffer1[i] : 0;
+      const s2 = i < buffer2.length ? buffer2[i] : 0;
+      output[i] = Math.max(-1, Math.min(1, s1 * (1 - ratio) + s2 * ratio));
+    }
+    return output;
+  }
+  /**
+   * Convert AudioBuffer to WAV format
+   * @param audioBuffer - Web Audio API AudioBuffer
+   * @param sampleRate - Output sample rate (defaults to buffer's sample rate)
+   * @returns WAV file as ArrayBuffer
+   */
+  static bufferToWav(audioBuffer, sampleRate) {
+    const outputRate = sampleRate || audioBuffer.sampleRate;
+    const channels = audioBuffer.numberOfChannels;
+    const bitDepth = 16;
+    const sourceData = audioBuffer.getChannelData(0);
+    const channelData = outputRate !== audioBuffer.sampleRate ? this.resampleBuffer(sourceData, audioBuffer.sampleRate, outputRate) : new Float32Array(sourceData);
+    const int16Data = this.convertFloat32ToInt16(channelData);
+    const dataLength = int16Data.length * (bitDepth / 8);
+    const header = this.createWavHeader(dataLength, outputRate, channels, bitDepth);
+    const wav = new ArrayBuffer(44 + dataLength);
+    const view = new DataView(wav);
+    const headerView = new DataView(header);
+    for (let i = 0; i < 44; i++) {
+      view.setUint8(i, headerView.getUint8(i));
+    }
+    for (let i = 0; i < int16Data.length; i++) {
+      view.setInt16(44 + i * 2, int16Data[i], true);
+    }
+    return wav;
+  }
+  /**
+   * Create WAV file header
+   * @param dataLength - Length of audio data in bytes
+   * @param sampleRate - Sample rate
+   * @param channels - Number of channels
+   * @param bitDepth - Bits per sample
+   * @returns WAV header as ArrayBuffer
+   */
+  static createWavHeader(dataLength, sampleRate, channels, bitDepth) {
+    const header = new ArrayBuffer(44);
+    const view = new DataView(header);
+    const byteRate = sampleRate * channels * (bitDepth / 8);
+    const blockAlign = channels * (bitDepth / 8);
+    this.writeString(view, 0, "RIFF");
+    view.setUint32(4, 36 + dataLength, true);
+    this.writeString(view, 8, "WAVE");
+    this.writeString(view, 12, "fmt ");
+    view.setUint32(16, 16, true);
+    view.setUint16(20, 1, true);
+    view.setUint16(22, channels, true);
+    view.setUint32(24, sampleRate, true);
+    view.setUint32(28, byteRate, true);
+    view.setUint16(32, blockAlign, true);
+    view.setUint16(34, bitDepth, true);
+    this.writeString(view, 36, "data");
+    view.setUint32(40, dataLength, true);
+    return header;
+  }
+  /**
+   * Write string to DataView
+   * @param view - DataView to write to
+   * @param offset - Byte offset
+   * @param string - String to write
+   */
+  static writeString(view, offset, string) {
+    for (let i = 0; i < string.length; i++) {
+      view.setUint8(offset + i, string.charCodeAt(i));
+    }
+  }
+  /**
+   * Convert raw PCM Float32 array to WAV ArrayBuffer
+   * @param samples - Float32Array of audio samples
+   * @param sampleRate - Sample rate
+   * @returns WAV file as ArrayBuffer
+   */
+  static float32ToWav(samples, sampleRate) {
+    const int16Data = this.convertFloat32ToInt16(samples);
+    const dataLength = int16Data.length * 2;
+    const header = this.createWavHeader(dataLength, sampleRate, 1, 16);
+    const wav = new ArrayBuffer(44 + dataLength);
+    const view = new DataView(wav);
+    const headerView = new DataView(header);
+    for (let i = 0; i < 44; i++) {
+      view.setUint8(i, headerView.getUint8(i));
+    }
+    for (let i = 0; i < int16Data.length; i++) {
+      view.setInt16(44 + i * 2, int16Data[i], true);
+    }
+    return wav;
+  }
+};
+
+// src/utils/VoiceActivityDetector.ts
+var VoiceActivityDetector = class {
+  /**
+   * Create a new VoiceActivityDetector
+   * @param options - VAD configuration options
+   */
+  constructor(options = {}) {
+    /** Energy history buffer */
+    this.energyHistory = [];
+    /** Current speaking state */
+    this.isSpeaking = false;
+    /** Speech start time */
+    this.speechStartTime = null;
+    /** Silence start time */
+    this.silenceStartTime = null;
+    /** Last processed timestamp */
+    this.lastProcessTime = 0;
+    this.threshold = options.threshold ?? 0.01;
+    this.minSpeechDuration = options.minSpeechDuration ?? 300;
+    this.minSilenceDuration = options.minSilenceDuration ?? 500;
+    this.historySize = options.historySize ?? 10;
+    this.onSpeechStart = options.onSpeechStart;
+    this.onSpeechEnd = options.onSpeechEnd;
+    this.onVolumeChange = options.onVolumeChange;
+  }
+  /**
+   * Process audio data and detect voice activity
+   * @param audioData - Audio samples as Float32Array
+   * @returns Current speaking state
+   */
+  processAudio(audioData) {
+    const currentTime = Date.now();
+    const energy = this.calculateRMSEnergy(audioData);
+    this.energyHistory.push(energy);
+    if (this.energyHistory.length > this.historySize) {
+      this.energyHistory.shift();
+    }
+    if (this.onVolumeChange) {
+      this.onVolumeChange(energy);
+    }
+    const isAboveThreshold = energy > this.threshold;
+    if (isAboveThreshold) {
+      this.silenceStartTime = null;
+      if (!this.isSpeaking) {
+        if (this.speechStartTime === null) {
+          this.speechStartTime = currentTime;
+        } else if (currentTime - this.speechStartTime >= this.minSpeechDuration) {
+          this.isSpeaking = true;
+          this.speechStartTime = null;
+          if (this.onSpeechStart) {
+            this.onSpeechStart();
+          }
+        }
+      }
+    } else {
+      this.speechStartTime = null;
+      if (this.isSpeaking) {
+        if (this.silenceStartTime === null) {
+          this.silenceStartTime = currentTime;
+        } else if (currentTime - this.silenceStartTime >= this.minSilenceDuration) {
+          this.isSpeaking = false;
+          this.silenceStartTime = null;
+          if (this.onSpeechEnd) {
+            this.onSpeechEnd();
+          }
+        }
+      }
+    }
+    this.lastProcessTime = currentTime;
+    return this.isSpeaking;
+  }
+  /**
+   * Calculate RMS (Root Mean Square) energy of audio buffer
+   * @param buffer - Audio samples
+   * @returns RMS energy value (0-1)
+   */
+  calculateRMSEnergy(buffer) {
+    let sum = 0;
+    for (let i = 0; i < buffer.length; i++) {
+      sum += buffer[i] * buffer[i];
+    }
+    return Math.sqrt(sum / buffer.length);
+  }
+  /**
+   * Calculate adaptive threshold based on energy history
+   * @returns Adaptive threshold value
+   */
+  calculateAdaptiveThreshold() {
+    if (this.energyHistory.length === 0) {
+      return this.threshold;
+    }
+    const average = this.energyHistory.reduce((a, b) => a + b, 0) / this.energyHistory.length;
+    return average * 1.5 + 5e-3;
+  }
+  /**
+   * Reset detector state
+   */
+  reset() {
+    this.energyHistory = [];
+    this.isSpeaking = false;
+    this.speechStartTime = null;
+    this.silenceStartTime = null;
+    this.lastProcessTime = 0;
+  }
+  /**
+   * Update threshold value
+   * @param threshold - New threshold (0-1)
+   */
+  setThreshold(threshold) {
+    this.threshold = Math.max(0, Math.min(1, threshold));
+  }
+  /**
+   * Get average energy from history
+   * @returns Average energy value
+   */
+  getAverageEnergy() {
+    if (this.energyHistory.length === 0) {
+      return 0;
+    }
+    return this.energyHistory.reduce((a, b) => a + b, 0) / this.energyHistory.length;
+  }
+  /**
+   * Check if speech is currently detected
+   * @returns Speaking state
+   */
+  isSpeechDetected() {
+    return this.isSpeaking;
+  }
+  /**
+   * Get current threshold
+   * @returns Threshold value
+   */
+  getThreshold() {
+    return this.threshold;
+  }
+  /**
+   * Update callbacks
+   * @param callbacks - New callback functions
+   */
+  setCallbacks(callbacks) {
+    if (callbacks.onSpeechStart !== void 0) {
+      this.onSpeechStart = callbacks.onSpeechStart;
+    }
+    if (callbacks.onSpeechEnd !== void 0) {
+      this.onSpeechEnd = callbacks.onSpeechEnd;
+    }
+    if (callbacks.onVolumeChange !== void 0) {
+      this.onVolumeChange = callbacks.onVolumeChange;
+    }
+  }
+};
+
+// src/utils/AudioLevelMonitor.ts
+var AudioLevelMonitor = class {
+  /**
+   * Create a new AudioLevelMonitor
+   * @param options - Monitor configuration
+   */
+  constructor(options = {}) {
+    /** Current smoothed level */
+    this.currentLevel = 0;
+    /** Peak level since last reset */
+    this.peakLevel = 0;
+    this.smoothingFactor = options.smoothingFactor ?? 0.8;
+    this.onLevelChange = options.onLevelChange;
+  }
+  /**
+   * Process audio data and update levels
+   * @param audioData - Audio samples as Float32Array
+   * @returns Current smoothed level
+   */
+  processAudio(audioData) {
+    const instantLevel = this.calculateLevel(audioData);
+    this.currentLevel = this.smoothingFactor * this.currentLevel + (1 - this.smoothingFactor) * instantLevel;
+    if (this.currentLevel > this.peakLevel) {
+      this.peakLevel = this.currentLevel;
+    }
+    if (this.onLevelChange) {
+      this.onLevelChange(this.currentLevel);
+    }
+    return this.currentLevel;
+  }
+  /**
+   * Calculate RMS level of audio buffer
+   * @param buffer - Audio samples
+   * @returns Level value (0-1)
+   */
+  calculateLevel(buffer) {
+    let sum = 0;
+    for (let i = 0; i < buffer.length; i++) {
+      sum += buffer[i] * buffer[i];
+    }
+    return Math.sqrt(sum / buffer.length);
+  }
+  /**
+   * Get current smoothed level
+   * @returns Current level (0-1)
+   */
+  getCurrentLevel() {
+    return this.currentLevel;
+  }
+  /**
+   * Get peak level since last reset
+   * @returns Peak level (0-1)
+   */
+  getPeakLevel() {
+    return this.peakLevel;
+  }
+  /**
+   * Reset current and peak levels
+   */
+  reset() {
+    this.currentLevel = 0;
+    this.peakLevel = 0;
+  }
+  /**
+   * Reset only the peak level
+   */
+  resetPeak() {
+    this.peakLevel = 0;
+  }
+  /**
+   * Convert current level to decibels
+   * @returns Level in dB (typically -60 to 0)
+   */
+  getDecibels() {
+    if (this.currentLevel <= 0) {
+      return -Infinity;
+    }
+    return 20 * Math.log10(this.currentLevel);
+  }
+  /**
+   * Convert specific level to decibels
+   * @param level - Level value (0-1)
+   * @returns Level in dB
+   */
+  static toDecibels(level) {
+    if (level <= 0) {
+      return -Infinity;
+    }
+    return 20 * Math.log10(level);
+  }
+  /**
+   * Convert decibels to linear level
+   * @param db - Level in decibels
+   * @returns Linear level (0-1)
+   */
+  static fromDecibels(db) {
+    return Math.pow(10, db / 20);
+  }
+  /**
+   * Set smoothing factor
+   * @param factor - Smoothing factor (0-1)
+   */
+  setSmoothingFactor(factor) {
+    this.smoothingFactor = Math.max(0, Math.min(1, factor));
+  }
+  /**
+   * Get current smoothing factor
+   * @returns Smoothing factor
+   */
+  getSmoothingFactor() {
+    return this.smoothingFactor;
+  }
+  /**
+   * Set level change callback
+   * @param callback - Callback function
+   */
+  setOnLevelChange(callback) {
+    this.onLevelChange = callback;
+  }
+  /**
+   * Get level as percentage (0-100)
+   * @returns Level percentage
+   */
+  getLevelPercentage() {
+    return Math.min(100, this.currentLevel * 100);
+  }
+};
+
+// src/utils/AudioBufferManager.ts
+var AudioBufferManager = class {
+  /**
+   * Create a new AudioBufferManager
+   * @param bufferSize - Maximum number of chunks to store
+   */
+  constructor(bufferSize = 100) {
+    /** Buffer storage */
+    this.buffer = [];
+    /** Write position */
+    this.writeIndex = 0;
+    /** Read position */
+    this.readIndex = 0;
+    /** Number of available chunks */
+    this.count = 0;
+    this.bufferSize = bufferSize;
+    this.buffer = new Array(bufferSize);
+  }
+  /**
+   * Write a chunk to the buffer
+   * @param chunk - Audio data chunk
+   */
+  write(chunk) {
+    this.buffer[this.writeIndex] = new Float32Array(chunk);
+    this.writeIndex = (this.writeIndex + 1) % this.bufferSize;
+    if (this.count < this.bufferSize) {
+      this.count++;
+    } else {
+      this.readIndex = (this.readIndex + 1) % this.bufferSize;
+    }
+  }
+  /**
+   * Read and remove chunks from the buffer
+   * @param numChunks - Number of chunks to read (default: all available)
+   * @returns Array of audio chunks
+   */
+  read(numChunks) {
+    const toRead = numChunks !== void 0 ? Math.min(numChunks, this.count) : this.count;
+    const chunks = [];
+    for (let i = 0; i < toRead; i++) {
+      const chunk = this.buffer[this.readIndex];
+      if (chunk) {
+        chunks.push(chunk);
+      }
+      this.readIndex = (this.readIndex + 1) % this.bufferSize;
+    }
+    this.count -= toRead;
+    return chunks;
+  }
+  /**
+   * Read chunks without removing them
+   * @param numChunks - Number of chunks to peek (default: all available)
+   * @returns Array of audio chunks
+   */
+  peek(numChunks) {
+    const toPeek = numChunks !== void 0 ? Math.min(numChunks, this.count) : this.count;
+    const chunks = [];
+    let idx = this.readIndex;
+    for (let i = 0; i < toPeek; i++) {
+      const chunk = this.buffer[idx];
+      if (chunk) {
+        chunks.push(chunk);
+      }
+      idx = (idx + 1) % this.bufferSize;
+    }
+    return chunks;
+  }
+  /**
+   * Clear all data from buffer
+   */
+  clear() {
+    this.buffer = new Array(this.bufferSize);
+    this.writeIndex = 0;
+    this.readIndex = 0;
+    this.count = 0;
+  }
+  /**
+   * Get number of available chunks
+   * @returns Number of chunks in buffer
+   */
+  getAvailableChunks() {
+    return this.count;
+  }
+  /**
+   * Check if buffer is full
+   * @returns True if buffer is full
+   */
+  isFull() {
+    return this.count >= this.bufferSize;
+  }
+  /**
+   * Check if buffer is empty
+   * @returns True if buffer is empty
+   */
+  isEmpty() {
+    return this.count === 0;
+  }
+  /**
+   * Concatenate multiple chunks into a single buffer
+   * @param chunks - Array of audio chunks
+   * @returns Single concatenated Float32Array
+   */
+  concatenateChunks(chunks) {
+    if (chunks.length === 0) {
+      return new Float32Array(0);
+    }
+    const totalLength = chunks.reduce((sum, chunk) => sum + chunk.length, 0);
+    const result = new Float32Array(totalLength);
+    let offset = 0;
+    for (const chunk of chunks) {
+      result.set(chunk, offset);
+      offset += chunk.length;
+    }
+    return result;
+  }
+  /**
+   * Get all data as a single concatenated buffer
+   * @returns Concatenated Float32Array
+   */
+  getAll() {
+    const chunks = this.peek();
+    return this.concatenateChunks(chunks);
+  }
+  /**
+   * Get total number of samples across all chunks
+   * @returns Total sample count
+   */
+  getTotalSamples() {
+    let total = 0;
+    let idx = this.readIndex;
+    for (let i = 0; i < this.count; i++) {
+      const chunk = this.buffer[idx];
+      if (chunk) {
+        total += chunk.length;
+      }
+      idx = (idx + 1) % this.bufferSize;
+    }
+    return total;
+  }
+  /**
+   * Get buffer capacity
+   * @returns Maximum number of chunks
+   */
+  getCapacity() {
+    return this.bufferSize;
+  }
+  /**
+   * Resize the buffer
+   * @param newSize - New buffer size
+   */
+  resize(newSize) {
+    if (newSize === this.bufferSize) return;
+    const chunks = this.read();
+    this.bufferSize = newSize;
+    this.buffer = new Array(newSize);
+    this.writeIndex = 0;
+    this.readIndex = 0;
+    this.count = 0;
+    for (const chunk of chunks.slice(-newSize)) {
+      this.write(chunk);
+    }
+  }
+};
+
+// src/utils/AudioRecorder.ts
+var AudioRecorder = class {
+  /**
+   * Create a new AudioRecorder
+   * @param sampleRate - Sample rate for recording
+   */
+  constructor(sampleRate = 16e3) {
+    /** Recorded audio chunks */
+    this.audioChunks = [];
+    /** Recording state */
+    this.isRecording = false;
+    /** Recording start time */
+    this.startTime = null;
+    this.sampleRate = sampleRate;
+  }
+  /**
+   * Start recording
+   */
+  start() {
+    this.audioChunks = [];
+    this.isRecording = true;
+    this.startTime = Date.now();
+  }
+  /**
+   * Record an audio chunk
+   * @param audioData - Audio data to record
+   */
+  recordChunk(audioData) {
+    if (this.isRecording) {
+      this.audioChunks.push(new Float32Array(audioData));
+    }
+  }
+  /**
+   * Stop recording and return all recorded audio
+   * @returns Complete audio as Float32Array
+   */
+  stop() {
+    this.isRecording = false;
+    return this.getCombinedAudio();
+  }
+  /**
+   * Clear all recorded audio
+   */
+  clear() {
+    this.audioChunks = [];
+    this.startTime = null;
+  }
+  /**
+   * Export recording to specified format
+   * @param format - Output format ('raw' or 'wav')
+   * @returns Audio data as ArrayBuffer
+   */
+  export(format = "wav") {
+    const audioData = this.getCombinedAudio();
+    if (format === "raw") {
+      return audioData.buffer;
+    }
+    return AudioProcessor.float32ToWav(audioData, this.sampleRate);
+  }
+  /**
+   * Get recording duration in seconds
+   * @returns Duration in seconds
+   */
+  getDuration() {
+    const totalSamples = this.audioChunks.reduce((sum, chunk) => sum + chunk.length, 0);
+    return totalSamples / this.sampleRate;
+  }
+  /**
+   * Get number of recorded chunks
+   * @returns Chunk count
+   */
+  getChunkCount() {
+    return this.audioChunks.length;
+  }
+  /**
+   * Check if currently recording
+   * @returns Recording state
+   */
+  getIsRecording() {
+    return this.isRecording;
+  }
+  /**
+   * Get sample rate
+   * @returns Sample rate
+   */
+  getSampleRate() {
+    return this.sampleRate;
+  }
+  /**
+   * Set sample rate (only effective before recording starts)
+   * @param sampleRate - New sample rate
+   */
+  setSampleRate(sampleRate) {
+    if (!this.isRecording) {
+      this.sampleRate = sampleRate;
+    }
+  }
+  /**
+   * Get total number of recorded samples
+   * @returns Sample count
+   */
+  getTotalSamples() {
+    return this.audioChunks.reduce((sum, chunk) => sum + chunk.length, 0);
+  }
+  /**
+   * Get recording start time
+   * @returns Start timestamp or null
+   */
+  getStartTime() {
+    return this.startTime;
+  }
+  /**
+   * Get elapsed recording time in milliseconds
+   * @returns Elapsed time in ms
+   */
+  getElapsedTime() {
+    if (!this.startTime) return 0;
+    return Date.now() - this.startTime;
+  }
+  /**
+   * Get combined audio data
+   * @returns Concatenated Float32Array
+   */
+  getCombinedAudio() {
+    if (this.audioChunks.length === 0) {
+      return new Float32Array(0);
+    }
+    const totalLength = this.audioChunks.reduce((sum, chunk) => sum + chunk.length, 0);
+    const combined = new Float32Array(totalLength);
+    let offset = 0;
+    for (const chunk of this.audioChunks) {
+      combined.set(chunk, offset);
+      offset += chunk.length;
+    }
+    return combined;
+  }
+  /**
+   * Create a Blob from the recording
+   * @param format - Output format
+   * @returns Blob with audio data
+   */
+  toBlob(format = "wav") {
+    const buffer = this.export(format);
+    const mimeType = format === "wav" ? "audio/wav" : "application/octet-stream";
+    return new Blob([buffer], { type: mimeType });
+  }
+  /**
+   * Create a data URL from the recording
+   * @param format - Output format
+   * @returns Data URL string
+   */
+  toDataURL(format = "wav") {
+    const blob = this.toBlob(format);
+    return URL.createObjectURL(blob);
+  }
+  /**
+   * Download the recording
+   * @param filename - Output filename
+   * @param format - Output format
+   */
+  download(filename = "recording", format = "wav") {
+    const url = this.toDataURL(format);
+    const extension = format === "wav" ? ".wav" : ".raw";
+    const link = document.createElement("a");
+    link.href = url;
+    link.download = filename + extension;
+    link.click();
+    URL.revokeObjectURL(url);
+  }
+};
+
+// src/utils/StorageAdapter.ts
+var LocalStorageAdapter = class {
+  /**
+   * Create a new LocalStorageAdapter
+   * @param prefix - Key prefix (default: 'live-transcribe')
+   */
+  constructor(prefix = "live-transcribe") {
+    this.prefix = prefix;
+  }
+  /**
+   * Get prefixed key
+   */
+  getKey(key) {
+    return `${this.prefix}:${key}`;
+  }
+  async save(key, data) {
+    if (typeof window === "undefined" || !window.localStorage) {
+      throw new Error("localStorage is not available");
+    }
+    const serialized = JSON.stringify(data);
+    localStorage.setItem(this.getKey(key), serialized);
+  }
+  async load(key) {
+    if (typeof window === "undefined" || !window.localStorage) {
+      throw new Error("localStorage is not available");
+    }
+    const data = localStorage.getItem(this.getKey(key));
+    if (data === null) {
+      return null;
+    }
+    return JSON.parse(data);
+  }
+  async delete(key) {
+    if (typeof window === "undefined" || !window.localStorage) {
+      throw new Error("localStorage is not available");
+    }
+    localStorage.removeItem(this.getKey(key));
+  }
+  async list() {
+    if (typeof window === "undefined" || !window.localStorage) {
+      throw new Error("localStorage is not available");
+    }
+    const keys = [];
+    const prefixWithColon = `${this.prefix}:`;
+    for (let i = 0; i < localStorage.length; i++) {
+      const key = localStorage.key(i);
+      if (key?.startsWith(prefixWithColon)) {
+        keys.push(key.substring(prefixWithColon.length));
+      }
+    }
+    return keys;
+  }
+  async exists(key) {
+    if (typeof window === "undefined" || !window.localStorage) {
+      throw new Error("localStorage is not available");
+    }
+    return localStorage.getItem(this.getKey(key)) !== null;
+  }
+};
+var MemoryStorageAdapter = class {
+  constructor() {
+    this.storage = /* @__PURE__ */ new Map();
+  }
+  async save(key, data) {
+    this.storage.set(key, JSON.parse(JSON.stringify(data)));
+  }
+  async load(key) {
+    const data = this.storage.get(key);
+    if (data === void 0) {
+      return null;
+    }
+    return JSON.parse(JSON.stringify(data));
+  }
+  async delete(key) {
+    this.storage.delete(key);
+  }
+  async list() {
+    return Array.from(this.storage.keys());
+  }
+  async exists(key) {
+    return this.storage.has(key);
+  }
+  /**
+   * Clear all data
+   */
+  clear() {
+    this.storage.clear();
+  }
+  /**
+   * Get storage size
+   */
+  size() {
+    return this.storage.size;
+  }
+};
+
+// src/utils/validators.ts
+function validateTranscriptionConfig(config) {
+  const errors = [];
+  const warnings = [];
+  if (!config.provider) {
+    errors.push({
+      field: "provider",
+      message: "Provider is required",
+      code: "REQUIRED_FIELD"
+    });
+  } else if (!Object.values(TranscriptionProvider).includes(config.provider)) {
+    errors.push({
+      field: "provider",
+      message: `Invalid provider: ${config.provider}`,
+      code: "INVALID_PROVIDER"
+    });
+  }
+  const cloudProviders = ["deepgram" /* Deepgram */, "assemblyai" /* AssemblyAI */];
+  if (config.provider && cloudProviders.includes(config.provider)) {
+    if (!config.apiKey) {
+      errors.push({
+        field: "apiKey",
+        message: `API key is required for ${config.provider} provider`,
+        code: "REQUIRED_API_KEY"
+      });
+    } else if (config.apiKey.length < 10) {
+      warnings.push({
+        field: "apiKey",
+        message: "API key seems too short"
+      });
+    }
+  }
+  if (config.language && !validateLanguageCode(config.language)) {
+    errors.push({
+      field: "language",
+      message: `Invalid language code: ${config.language}`,
+      code: "INVALID_LANGUAGE"
+    });
+  }
+  if (config.audioConfig) {
+    const audioValidation = validateAudioConfig(config.audioConfig);
+    errors.push(...audioValidation.errors);
+    if (audioValidation.warnings) {
+      warnings.push(...audioValidation.warnings);
+    }
+  }
+  return {
+    valid: errors.length === 0,
+    errors,
+    warnings: warnings.length > 0 ? warnings : void 0
+  };
+}
+function validateAudioConfig(config) {
+  const errors = [];
+  const warnings = [];
+  if (config.sampleRate !== void 0) {
+    if (config.sampleRate < 8e3 || config.sampleRate > 48e3) {
+      errors.push({
+        field: "audioConfig.sampleRate",
+        message: "Sample rate must be between 8000 and 48000",
+        code: "INVALID_SAMPLE_RATE"
+      });
+    } else if (config.sampleRate !== 16e3 && config.sampleRate !== 44100 && config.sampleRate !== 48e3) {
+      warnings.push({
+        field: "audioConfig.sampleRate",
+        message: "Non-standard sample rate may not be supported by all providers"
+      });
+    }
+  }
+  if (config.channels !== void 0 && (config.channels < 1 || config.channels > 2)) {
+    errors.push({
+      field: "audioConfig.channels",
+      message: "Channels must be 1 or 2",
+      code: "INVALID_CHANNELS"
+    });
+  }
+  if (config.bitDepth !== void 0 && ![8, 16, 24].includes(config.bitDepth)) {
+    errors.push({
+      field: "audioConfig.bitDepth",
+      message: "Bit depth must be 8, 16, or 24",
+      code: "INVALID_BIT_DEPTH"
+    });
+  }
+  if (config.encoding !== void 0 && !Object.values(AudioEncoding).includes(config.encoding)) {
+    errors.push({
+      field: "audioConfig.encoding",
+      message: `Invalid encoding: ${config.encoding}`,
+      code: "INVALID_ENCODING"
+    });
+  }
+  return {
+    valid: errors.length === 0,
+    errors,
+    warnings: warnings.length > 0 ? warnings : void 0
+  };
+}
+function validateSessionConfig(config) {
+  const errors = [];
+  const warnings = [];
+  if (config.maxDuration !== void 0 && config.maxDuration < 0) {
+    errors.push({
+      field: "maxDuration",
+      message: "Max duration must be positive",
+      code: "INVALID_MAX_DURATION"
+    });
+  }
+  if (config.silenceTimeout !== void 0 && config.silenceTimeout < 0) {
+    errors.push({
+      field: "silenceTimeout",
+      message: "Silence timeout must be positive",
+      code: "INVALID_SILENCE_TIMEOUT"
+    });
+  }
+  if (config.vadThreshold !== void 0 && (config.vadThreshold < 0 || config.vadThreshold > 1)) {
+    errors.push({
+      field: "vadThreshold",
+      message: "VAD threshold must be between 0 and 1",
+      code: "INVALID_VAD_THRESHOLD"
+    });
+  }
+  return {
+    valid: errors.length === 0,
+    errors,
+    warnings: warnings.length > 0 ? warnings : void 0
+  };
+}
+function validateLanguageCode(code) {
+  const pattern = /^[a-z]{2,3}(-[A-Z]{2})?(-[A-Za-z]{4})?(-[A-Z]{2}|-[0-9]{3})?$/i;
+  return pattern.test(code);
+}
+function validateApiKey(provider, key) {
+  const errors = [];
+  if (provider === "web-speech" /* WebSpeechAPI */) {
+    return { valid: true, errors: [] };
+  }
+  if (!key) {
+    errors.push({
+      field: "apiKey",
+      message: `API key is required for ${provider}`,
+      code: "MISSING_API_KEY"
+    });
+    return { valid: false, errors };
+  }
+  switch (provider) {
+    case "deepgram" /* Deepgram */:
+      if (key.length < 20) {
+        errors.push({
+          field: "apiKey",
+          message: "Deepgram API key appears to be too short",
+          code: "INVALID_API_KEY_FORMAT"
+        });
+      }
+      break;
+    case "assemblyai" /* AssemblyAI */:
+      if (key.length < 20) {
+        errors.push({
+          field: "apiKey",
+          message: "AssemblyAI API key appears to be too short",
+          code: "INVALID_API_KEY_FORMAT"
+        });
+      }
+      break;
+  }
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+}
+
+// src/utils/browserCheck.ts
+function getBrowserInfo() {
+  if (typeof window === "undefined" || typeof navigator === "undefined") {
+    return {
+      name: "Node.js",
+      version: typeof process !== "undefined" ? process.version : "unknown",
+      os: typeof process !== "undefined" ? process.platform : "unknown",
+      isMobile: false
+    };
+  }
+  const ua = navigator.userAgent;
+  let name = "Unknown";
+  let version = "unknown";
+  if (ua.includes("Firefox/")) {
+    name = "Firefox";
+    version = ua.match(/Firefox\/(\d+\.\d+)/)?.[1] || "unknown";
+  } else if (ua.includes("Edg/")) {
+    name = "Edge";
+    version = ua.match(/Edg\/(\d+\.\d+)/)?.[1] || "unknown";
+  } else if (ua.includes("Chrome/")) {
+    name = "Chrome";
+    version = ua.match(/Chrome\/(\d+\.\d+)/)?.[1] || "unknown";
+  } else if (ua.includes("Safari/") && !ua.includes("Chrome")) {
+    name = "Safari";
+    version = ua.match(/Version\/(\d+\.\d+)/)?.[1] || "unknown";
+  }
+  let os = "Unknown";
+  if (ua.includes("Windows")) os = "Windows";
+  else if (ua.includes("Mac OS")) os = "macOS";
+  else if (ua.includes("Linux")) os = "Linux";
+  else if (ua.includes("Android")) os = "Android";
+  else if (ua.includes("iOS") || ua.includes("iPhone") || ua.includes("iPad")) os = "iOS";
+  const isMobile = /Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(ua);
+  return { name, version, os, isMobile };
+}
+function checkWebSpeechAPISupport() {
+  if (typeof window === "undefined") {
+    return {
+      supported: false,
+      details: "Web Speech API is only available in browser environments",
+      fallback: "Use Deepgram or AssemblyAI provider in Node.js"
+    };
+  }
+  const hasSupport = !!(window.SpeechRecognition || window.webkitSpeechRecognition);
+  if (hasSupport) {
+    const isWebkit = !window.SpeechRecognition && !!window.webkitSpeechRecognition;
+    return {
+      supported: true,
+      details: isWebkit ? "Supported via webkit prefix" : "Fully supported"
+    };
+  }
+  return {
+    supported: false,
+    details: "Web Speech API is not supported in this browser",
+    fallback: "Use Deepgram or AssemblyAI provider instead"
+  };
+}
+function checkWebSocketSupport() {
+  const hasSupport = typeof WebSocket !== "undefined";
+  if (hasSupport) {
+    return {
+      supported: true,
+      details: "WebSocket is fully supported"
+    };
+  }
+  return {
+    supported: false,
+    details: "WebSocket is not supported",
+    fallback: "Upgrade to a modern browser"
+  };
+}
+function checkMediaDevicesSupport() {
+  if (typeof navigator === "undefined") {
+    return {
+      supported: false,
+      details: "Navigator API is not available",
+      fallback: "Run in a browser environment"
+    };
+  }
+  const hasGetUserMedia = !!(navigator.mediaDevices && navigator.mediaDevices.getUserMedia);
+  const hasEnumerateDevices = !!(navigator.mediaDevices && navigator.mediaDevices.enumerateDevices);
+  if (hasGetUserMedia && hasEnumerateDevices) {
+    return {
+      supported: true,
+      details: "Full media devices support"
+    };
+  }
+  if (hasGetUserMedia) {
+    return {
+      supported: true,
+      details: "getUserMedia supported, enumerateDevices not available"
+    };
+  }
+  return {
+    supported: false,
+    details: "Media devices API is not supported",
+    fallback: "Use HTTPS and a modern browser"
+  };
+}
+function checkAudioContextSupport() {
+  if (typeof window === "undefined") {
+    return {
+      supported: false,
+      details: "AudioContext is only available in browser environments"
+    };
+  }
+  const AudioContextClass = window.AudioContext || window.webkitAudioContext;
+  if (AudioContextClass) {
+    const hasWorklet = "audioWorklet" in AudioContext.prototype;
+    return {
+      supported: true,
+      details: hasWorklet ? "Full AudioContext support with AudioWorklet" : "AudioContext supported (no AudioWorklet)"
+    };
+  }
+  return {
+    supported: false,
+    details: "AudioContext is not supported",
+    fallback: "Use a modern browser"
+  };
+}
+function getFullCompatibilityReport() {
+  const browser = getBrowserInfo();
+  const webSpeechAPI = checkWebSpeechAPISupport();
+  const webSocket = checkWebSocketSupport();
+  const mediaDevices = checkMediaDevicesSupport();
+  const audioContext = checkAudioContextSupport();
+  const recommendations = [];
+  if (!webSpeechAPI.supported) {
+    recommendations.push("Consider using Chrome, Edge, or Safari for Web Speech API support");
+  }
+  if (!mediaDevices.supported) {
+    recommendations.push("Ensure HTTPS is enabled and grant microphone permissions");
+  }
+  if (!audioContext.supported) {
+    recommendations.push("Update to a modern browser for audio processing support");
+  }
+  const overallCompatible = (webSpeechAPI.supported || webSocket.supported) && mediaDevices.supported;
+  if (browser.isMobile) {
+    recommendations.push("Mobile support may vary; consider testing on desktop for best results");
+  }
+  return {
+    browser,
+    webSpeechAPI,
+    webSocket,
+    mediaDevices,
+    audioContext,
+    overallCompatible,
+    recommendations
+  };
+}
+
+// src/utils/timing.ts
+function debounce(func, wait) {
+  let timeoutId = null;
+  return function debounced(...args) {
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+    }
+    timeoutId = setTimeout(() => {
+      func.apply(null, args);
+      timeoutId = null;
+    }, wait);
+  };
+}
+function throttle(func, limit) {
+  let lastRun = 0;
+  let timeoutId = null;
+  return function throttled(...args) {
+    const now = Date.now();
+    if (now - lastRun >= limit) {
+      lastRun = now;
+      func.apply(null, args);
+    } else if (!timeoutId) {
+      const remaining = limit - (now - lastRun);
+      timeoutId = setTimeout(() => {
+        lastRun = Date.now();
+        func.apply(null, args);
+        timeoutId = null;
+      }, remaining);
+    }
+  };
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function timeout(promise, ms, message = "Operation timed out") {
+  return new Promise((resolve, reject) => {
+    const timeoutId = setTimeout(() => {
+      reject(new Error(message));
+    }, ms);
+    promise.then((result) => {
+      clearTimeout(timeoutId);
+      resolve(result);
+    }).catch((error) => {
+      clearTimeout(timeoutId);
+      reject(error);
+    });
+  });
+}
+async function retry(fn, options = {}) {
+  const {
+    maxAttempts = 3,
+    delay = 1e3,
+    backoff = "exponential",
+    maxDelay = 3e4,
+    shouldRetry = () => true
+  } = options;
+  let lastError;
+  let currentDelay = delay;
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error;
+      if (attempt === maxAttempts || !shouldRetry(error)) {
+        break;
+      }
+      await sleep(currentDelay);
+      if (backoff === "exponential") {
+        currentDelay = Math.min(currentDelay * 2, maxDelay);
+      } else {
+        currentDelay = Math.min(currentDelay + delay, maxDelay);
+      }
+    }
+  }
+  throw lastError;
+}
+function cancellableTimeout(ms) {
+  let timeoutId;
+  let rejectFn;
+  const promise = new Promise((resolve, reject) => {
+    rejectFn = reject;
+    timeoutId = setTimeout(resolve, ms);
+  });
+  const cancel = () => {
+    clearTimeout(timeoutId);
+    rejectFn(new Error("Timeout cancelled"));
+  };
+  return { promise, cancel };
+}
+function setIntervalAsync(fn, interval, immediate = false) {
+  let stopped = false;
+  let timeoutId;
+  const execute = async () => {
+    if (stopped) return;
+    try {
+      await fn();
+    } catch (error) {
+      console.error("Interval function error:", error);
+    }
+    if (!stopped) {
+      timeoutId = setTimeout(execute, interval);
+    }
+  };
+  if (immediate) {
+    void execute();
+  } else {
+    timeoutId = setTimeout(execute, interval);
+  }
+  return () => {
+    stopped = true;
+    clearTimeout(timeoutId);
+  };
+}
+
+// src/utils/formatters.ts
+function formatDuration(ms) {
+  if (ms < 0) return "0s";
+  const seconds = Math.floor(ms / 1e3);
+  const minutes = Math.floor(seconds / 60);
+  const hours = Math.floor(minutes / 60);
+  const remainingMinutes = minutes % 60;
+  const remainingSeconds = seconds % 60;
+  if (hours > 0) {
+    return `${hours}h ${remainingMinutes}m`;
+  }
+  if (minutes > 0) {
+    return `${minutes}m ${remainingSeconds}s`;
+  }
+  return `${seconds}s`;
+}
+function formatTimestamp(ms, format = "readable") {
+  if (ms < 0) ms = 0;
+  const totalSeconds = Math.floor(ms / 1e3);
+  const hours = Math.floor(totalSeconds / 3600);
+  const minutes = Math.floor(totalSeconds % 3600 / 60);
+  const seconds = totalSeconds % 60;
+  const milliseconds = Math.floor(ms % 1e3);
+  const pad = (n, length = 2) => String(n).padStart(length, "0");
+  switch (format) {
+    case "srt":
+      return `${pad(hours)}:${pad(minutes)}:${pad(seconds)},${pad(milliseconds, 3)}`;
+    case "vtt":
+      return `${pad(hours)}:${pad(minutes)}:${pad(seconds)}.${pad(milliseconds, 3)}`;
+    case "readable":
+      if (hours > 0) {
+        return `${hours}:${pad(minutes)}:${pad(seconds)}`;
+      }
+      return `${minutes}:${pad(seconds)}`;
+    case "iso":
+      return new Date(ms).toISOString();
+    case "ms":
+      return String(ms);
+    default:
+      return String(ms);
+  }
+}
+function formatConfidence(confidence) {
+  if (confidence < 0 || confidence > 1) {
+    return "N/A";
+  }
+  return `${Math.round(confidence * 100)}%`;
+}
+function formatFileSize(bytes) {
+  if (bytes < 0) return "0 B";
+  const units = ["B", "KB", "MB", "GB", "TB"];
+  let unitIndex = 0;
+  let size = bytes;
+  while (size >= 1024 && unitIndex < units.length - 1) {
+    size /= 1024;
+    unitIndex++;
+  }
+  return `${size.toFixed(unitIndex > 0 ? 1 : 0)} ${units[unitIndex]}`;
+}
+function formatTranscriptForDisplay(results, options = {}) {
+  const {
+    showTimestamps = false,
+    showConfidence = false,
+    highlightInterim = false,
+    maxLength
+  } = options;
+  const parts = [];
+  for (const result of results) {
+    let text = result.text;
+    const prefix = [];
+    if (showTimestamps && result.timestamp) {
+      const time = formatTimestamp(result.timestamp, "readable");
+      prefix.push(`[${time}]`);
+    }
+    if (result.speaker) {
+      prefix.push(`${result.speaker}:`);
+    }
+    if (showConfidence && result.confidence !== void 0) {
+      prefix.push(`(${formatConfidence(result.confidence)})`);
+    }
+    if (highlightInterim && !result.isFinal) {
+      text = `*${text}*`;
+    }
+    const line = prefix.length > 0 ? `${prefix.join(" ")} ${text}` : text;
+    parts.push(line);
+  }
+  let output = parts.join("\n");
+  if (maxLength && output.length > maxLength) {
+    output = output.substring(0, maxLength - 3) + "...";
+  }
+  return output;
+}
+function formatAsPlainText(results, finalOnly = true) {
+  const filtered = finalOnly ? results.filter((r) => r.isFinal) : results;
+  return filtered.map((r) => r.text).join(" ").trim();
+}
+function formatNumber(num) {
+  return num.toLocaleString();
+}
+function truncateText(text, maxLength) {
+  if (text.length <= maxLength) return text;
+  return text.substring(0, maxLength - 3) + "...";
+}
+
+// src/utils/languageUtils.ts
+var LANGUAGE_MAP = {
+  "en": { name: "English", nativeName: "English" },
+  "en-US": { name: "English (US)", nativeName: "English (US)" },
+  "en-GB": { name: "English (UK)", nativeName: "English (UK)" },
+  "en-AU": { name: "English (Australia)", nativeName: "English (Australia)" },
+  "en-CA": { name: "English (Canada)", nativeName: "English (Canada)" },
+  "en-IN": { name: "English (India)", nativeName: "English (India)" },
+  "es": { name: "Spanish", nativeName: "Espa\xF1ol" },
+  "es-ES": { name: "Spanish (Spain)", nativeName: "Espa\xF1ol (Espa\xF1a)" },
+  "es-MX": { name: "Spanish (Mexico)", nativeName: "Espa\xF1ol (M\xE9xico)" },
+  "es-419": { name: "Spanish (Latin America)", nativeName: "Espa\xF1ol (Latinoam\xE9rica)" },
+  "fr": { name: "French", nativeName: "Fran\xE7ais" },
+  "fr-FR": { name: "French (France)", nativeName: "Fran\xE7ais (France)" },
+  "fr-CA": { name: "French (Canada)", nativeName: "Fran\xE7ais (Canada)" },
+  "de": { name: "German", nativeName: "Deutsch" },
+  "de-DE": { name: "German (Germany)", nativeName: "Deutsch (Deutschland)" },
+  "it": { name: "Italian", nativeName: "Italiano" },
+  "it-IT": { name: "Italian (Italy)", nativeName: "Italiano (Italia)" },
+  "pt": { name: "Portuguese", nativeName: "Portugu\xEAs" },
+  "pt-BR": { name: "Portuguese (Brazil)", nativeName: "Portugu\xEAs (Brasil)" },
+  "pt-PT": { name: "Portuguese (Portugal)", nativeName: "Portugu\xEAs (Portugal)" },
+  "nl": { name: "Dutch", nativeName: "Nederlands" },
+  "nl-NL": { name: "Dutch (Netherlands)", nativeName: "Nederlands (Nederland)" },
+  "ja": { name: "Japanese", nativeName: "\u65E5\u672C\u8A9E" },
+  "ja-JP": { name: "Japanese (Japan)", nativeName: "\u65E5\u672C\u8A9E (\u65E5\u672C)" },
+  "ko": { name: "Korean", nativeName: "\uD55C\uAD6D\uC5B4" },
+  "ko-KR": { name: "Korean (Korea)", nativeName: "\uD55C\uAD6D\uC5B4 (\uB300\uD55C\uBBFC\uAD6D)" },
+  "zh": { name: "Chinese", nativeName: "\u4E2D\u6587" },
+  "zh-CN": { name: "Chinese (Simplified)", nativeName: "\u4E2D\u6587 (\u7B80\u4F53)" },
+  "zh-TW": { name: "Chinese (Traditional)", nativeName: "\u4E2D\u6587 (\u7E41\u9AD4)" },
+  "ru": { name: "Russian", nativeName: "\u0420\u0443\u0441\u0441\u043A\u0438\u0439" },
+  "ru-RU": { name: "Russian (Russia)", nativeName: "\u0420\u0443\u0441\u0441\u043A\u0438\u0439 (\u0420\u043E\u0441\u0441\u0438\u044F)" },
+  "ar": { name: "Arabic", nativeName: "\u0627\u0644\u0639\u0631\u0628\u064A\u0629" },
+  "ar-SA": { name: "Arabic (Saudi Arabia)", nativeName: "\u0627\u0644\u0639\u0631\u0628\u064A\u0629 (\u0627\u0644\u0633\u0639\u0648\u062F\u064A\u0629)" },
+  "hi": { name: "Hindi", nativeName: "\u0939\u093F\u0928\u094D\u0926\u0940" },
+  "hi-IN": { name: "Hindi (India)", nativeName: "\u0939\u093F\u0928\u094D\u0926\u0940 (\u092D\u093E\u0930\u0924)" },
+  "tr": { name: "Turkish", nativeName: "T\xFCrk\xE7e" },
+  "tr-TR": { name: "Turkish (Turkey)", nativeName: "T\xFCrk\xE7e (T\xFCrkiye)" },
+  "pl": { name: "Polish", nativeName: "Polski" },
+  "pl-PL": { name: "Polish (Poland)", nativeName: "Polski (Polska)" },
+  "uk": { name: "Ukrainian", nativeName: "\u0423\u043A\u0440\u0430\u0457\u043D\u0441\u044C\u043A\u0430" },
+  "uk-UA": { name: "Ukrainian (Ukraine)", nativeName: "\u0423\u043A\u0440\u0430\u0457\u043D\u0441\u044C\u043A\u0430 (\u0423\u043A\u0440\u0430\u0457\u043D\u0430)" },
+  "sv": { name: "Swedish", nativeName: "Svenska" },
+  "sv-SE": { name: "Swedish (Sweden)", nativeName: "Svenska (Sverige)" },
+  "da": { name: "Danish", nativeName: "Dansk" },
+  "da-DK": { name: "Danish (Denmark)", nativeName: "Dansk (Danmark)" },
+  "no": { name: "Norwegian", nativeName: "Norsk" },
+  "no-NO": { name: "Norwegian (Norway)", nativeName: "Norsk (Norge)" },
+  "fi": { name: "Finnish", nativeName: "Suomi" },
+  "fi-FI": { name: "Finnish (Finland)", nativeName: "Suomi (Suomi)" }
+};
+var PROVIDER_LANGUAGES = {
+  ["web-speech" /* WebSpeechAPI */]: [
+    "en-US",
+    "en-GB",
+    "en-AU",
+    "en-CA",
+    "en-IN",
+    "es-ES",
+    "es-MX",
+    "fr-FR",
+    "de-DE",
+    "it-IT",
+    "pt-BR",
+    "pt-PT",
+    "ja-JP",
+    "ko-KR",
+    "zh-CN",
+    "zh-TW",
+    "ru-RU",
+    "ar-SA",
+    "hi-IN",
+    "nl-NL"
+  ],
+  ["deepgram" /* Deepgram */]: [
+    "en",
+    "en-US",
+    "en-GB",
+    "en-AU",
+    "en-IN",
+    "es",
+    "es-ES",
+    "es-419",
+    "fr",
+    "fr-FR",
+    "fr-CA",
+    "de",
+    "de-DE",
+    "it",
+    "it-IT",
+    "pt",
+    "pt-BR",
+    "pt-PT",
+    "nl",
+    "nl-NL",
+    "ja",
+    "ja-JP",
+    "ko",
+    "ko-KR",
+    "zh",
+    "zh-CN",
+    "zh-TW",
+    "ru",
+    "ru-RU",
+    "uk",
+    "uk-UA",
+    "hi",
+    "hi-IN",
+    "tr",
+    "tr-TR",
+    "pl",
+    "pl-PL",
+    "sv",
+    "sv-SE",
+    "da",
+    "da-DK",
+    "no",
+    "no-NO",
+    "fi",
+    "fi-FI"
+  ],
+  ["assemblyai" /* AssemblyAI */]: [
+    "en",
+    "en-US",
+    "en-GB",
+    "en-AU"
+  ],
+  ["custom" /* Custom */]: []
+};
+function getSupportedLanguages(provider) {
+  const codes = PROVIDER_LANGUAGES[provider] || [];
+  return codes.map((code) => {
+    const info = LANGUAGE_MAP[code] || { name: code, nativeName: code };
+    return {
+      code,
+      name: info.name,
+      nativeName: info.nativeName,
+      provider
+    };
+  });
+}
+function normalizeLanguageCode(code) {
+  if (!code) return "en-US";
+  const normalized = code.trim();
+  const parts = normalized.split(/[-_]/);
+  if (parts.length === 1) {
+    return parts[0].toLowerCase();
+  }
+  const language = parts[0].toLowerCase();
+  const region = parts[1].toUpperCase();
+  return `${language}-${region}`;
+}
+function getLanguageName(code) {
+  const normalized = normalizeLanguageCode(code);
+  const info = LANGUAGE_MAP[normalized];
+  return info?.name || code;
+}
+function getNativeLanguageName(code) {
+  const normalized = normalizeLanguageCode(code);
+  const info = LANGUAGE_MAP[normalized];
+  return info?.nativeName || code;
+}
+function detectBrowserLanguage() {
+  if (typeof navigator === "undefined") {
+    return "en-US";
+  }
+  const browserLang = navigator.language || navigator.userLanguage;
+  return normalizeLanguageCode(browserLang || "en-US");
+}
+function isLanguageSupported(code, provider) {
+  const normalized = normalizeLanguageCode(code);
+  const supported = PROVIDER_LANGUAGES[provider] || [];
+  if (supported.includes(normalized)) {
+    return true;
+  }
+  const baseLang = normalized.split("-")[0];
+  return supported.includes(baseLang);
+}
+function getBestMatchingLanguage(code, provider) {
+  const normalized = normalizeLanguageCode(code);
+  const supported = PROVIDER_LANGUAGES[provider] || [];
+  if (supported.includes(normalized)) {
+    return normalized;
+  }
+  const baseLang = normalized.split("-")[0];
+  if (supported.includes(baseLang)) {
+    return baseLang;
+  }
+  const match = supported.find((s) => s.startsWith(baseLang + "-"));
+  if (match) {
+    return match;
+  }
+  return supported.includes("en-US") ? "en-US" : supported[0] || "en-US";
+}
+
+// src/utils/helpers.ts
+function generateId(prefix) {
+  const timestamp = Date.now().toString(36);
+  const random = Math.random().toString(36).substring(2, 9);
+  const id = `${timestamp}-${random}`;
+  return prefix ? `${prefix}-${id}` : id;
+}
+function deepClone(obj) {
+  if (obj === null || typeof obj !== "object") {
+    return obj;
+  }
+  if (Array.isArray(obj)) {
+    return obj.map((item) => deepClone(item));
+  }
+  if (obj instanceof Date) {
+    return new Date(obj.getTime());
+  }
+  if (obj instanceof ArrayBuffer) {
+    return obj.slice(0);
+  }
+  const cloned = {};
+  for (const key in obj) {
+    if (Object.prototype.hasOwnProperty.call(obj, key)) {
+      cloned[key] = deepClone(obj[key]);
+    }
+  }
+  return cloned;
+}
+function mergeDeep(...objects) {
+  const result = {};
+  for (const obj of objects) {
+    if (!obj) continue;
+    for (const key in obj) {
+      if (!Object.prototype.hasOwnProperty.call(obj, key)) continue;
+      const value = obj[key];
+      const existing = result[key];
+      if (isObject(value) && isObject(existing)) {
+        result[key] = mergeDeep(
+          existing,
+          value
+        );
+      } else {
+        result[key] = value;
+      }
+    }
+  }
+  return result;
+}
+function isFunction(value) {
+  return typeof value === "function";
+}
+function isObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function isEmpty(value) {
+  if (value === null || value === void 0) return true;
+  if (typeof value === "string") return value.length === 0;
+  if (Array.isArray(value)) return value.length === 0;
+  if (isObject(value)) return Object.keys(value).length === 0;
+  return false;
+}
+function pick(obj, keys) {
+  const result = {};
+  for (const key of keys) {
+    if (Object.prototype.hasOwnProperty.call(obj, key)) {
+      result[key] = obj[key];
+    }
+  }
+  return result;
+}
+function omit(obj, keys) {
+  const result = { ...obj };
+  for (const key of keys) {
+    delete result[key];
+  }
+  return result;
+}
+function waitFor(condition, interval = 100, timeout2 = 5e3) {
+  return new Promise((resolve, reject) => {
+    const startTime = Date.now();
+    const check = () => {
+      if (condition()) {
+        resolve();
+        return;
+      }
+      if (Date.now() - startTime > timeout2) {
+        reject(new Error("Timeout waiting for condition"));
+        return;
+      }
+      setTimeout(check, interval);
+    };
+    check();
+  });
+}
+function groupBy(array, keyFn) {
+  return array.reduce((result, item) => {
+    const key = keyFn(item);
+    if (!result[key]) {
+      result[key] = [];
+    }
+    result[key].push(item);
+    return result;
+  }, {});
+}
+function clamp(value, min, max) {
+  return Math.min(Math.max(value, min), max);
+}
+function round(value, decimals = 0) {
+  const factor = Math.pow(10, decimals);
+  return Math.round(value * factor) / factor;
+}
+
+// src/utils/audioUtils.ts
+function calculateBitrate(sampleRate, bitDepth, channels) {
+  return sampleRate * bitDepth * channels;
+}
+function estimateAudioSize(durationMs, config) {
+  const sampleRate = config.sampleRate || 16e3;
+  const bitDepth = config.bitDepth || 16;
+  const channels = config.channels || 1;
+  const durationSec = durationMs / 1e3;
+  const bytesPerSecond = sampleRate * bitDepth * channels / 8;
+  return Math.ceil(durationSec * bytesPerSecond);
+}
+function getOptimalBufferSize(sampleRate) {
+  const targetSamples = sampleRate * 0.02;
+  let bufferSize = 256;
+  while (bufferSize < targetSamples && bufferSize < 16384) {
+    bufferSize *= 2;
+  }
+  return Math.max(256, bufferSize);
+}
+function validateAudioFormat(data) {
+  const view = new DataView(data);
+  if (data.byteLength >= 44) {
+    const riff = String.fromCharCode(view.getUint8(0), view.getUint8(1), view.getUint8(2), view.getUint8(3));
+    const wave = String.fromCharCode(view.getUint8(8), view.getUint8(9), view.getUint8(10), view.getUint8(11));
+    if (riff === "RIFF" && wave === "WAVE") {
+      return parseWavHeader(view);
+    }
+  }
+  return {
+    format: "raw"
+  };
+}
+function parseWavHeader(view) {
+  try {
+    const channels = view.getUint16(22, true);
+    const sampleRate = view.getUint32(24, true);
+    const bitDepth = view.getUint16(34, true);
+    const dataSize = view.getUint32(40, true);
+    const duration = dataSize / (sampleRate * channels * (bitDepth / 8));
+    return {
+      format: "wav",
+      sampleRate,
+      channels,
+      bitDepth,
+      duration
+    };
+  } catch {
+    return { format: "wav" };
+  }
+}
+function calculateRMS(buffer) {
+  let sum = 0;
+  for (let i = 0; i < buffer.length; i++) {
+    sum += buffer[i] * buffer[i];
+  }
+  return Math.sqrt(sum / buffer.length);
+}
+function calculatePeak(buffer) {
+  let peak = 0;
+  for (let i = 0; i < buffer.length; i++) {
+    const abs = Math.abs(buffer[i]);
+    if (abs > peak) peak = abs;
+  }
+  return peak;
+}
+function dbToLinear(db) {
+  return Math.pow(10, db / 20);
+}
+function linearToDb(linear) {
+  if (linear <= 0) return -Infinity;
+  return 20 * Math.log10(linear);
+}
+function isSilence(buffer, threshold = 1e-3) {
+  const rms = calculateRMS(buffer);
+  return rms < threshold;
+}
+function getAudioConstraints(config = {}) {
+  return {
+    sampleRate: config.sampleRate || 16e3,
+    channelCount: config.channels || 1,
+    echoCancellation: true,
+    noiseSuppression: true,
+    autoGainControl: true
+  };
+}
+function samplesToDuration(samples, sampleRate) {
+  return samples / sampleRate * 1e3;
+}
+function durationToSamples(durationMs, sampleRate) {
+  return Math.round(durationMs / 1e3 * sampleRate);
+}
+
+// src/index.ts
+var VERSION = "0.1.0";
+var LIBRARY_NAME = "live-transcribe";
+function createTranscriber(config) {
+  switch (config.provider) {
+    case "web-speech" /* WebSpeechAPI */:
+      return new WebSpeechProvider(config);
+    case "deepgram" /* Deepgram */:
+      if (!config.apiKey) {
+        throw new TranscriptionError(
+          "API key is required for Deepgram provider",
+          "invalid_config" /* INVALID_CONFIG */,
+          "deepgram" /* Deepgram */
+        );
+      }
+      return new DeepgramProvider(config);
+    case "assemblyai" /* AssemblyAI */:
+      if (!config.apiKey) {
+        throw new TranscriptionError(
+          "API key is required for AssemblyAI provider",
+          "invalid_config" /* INVALID_CONFIG */,
+          "assemblyai" /* AssemblyAI */
+        );
+      }
+      return new AssemblyAIProvider(config);
+    case "custom" /* Custom */:
+      throw new TranscriptionError(
+        "Custom provider requires manual implementation",
+        "invalid_config" /* INVALID_CONFIG */
+      );
+    default:
+      throw new TranscriptionError(
+        `Unsupported provider: ${config.provider}`,
+        "invalid_config" /* INVALID_CONFIG */
+      );
+  }
+}
+function createSession(config, sessionConfig) {
+  const provider = createTranscriber(config);
+  return new TranscriptionSession(provider, sessionConfig);
+}
+async function quickStart(options = {}) {
+  const {
+    provider: requestedProvider,
+    apiKey,
+    language = "en-US",
+    onTranscript,
+    onError,
+    onStart,
+    onStop,
+    interimResults = true,
+    recordAudio = false
+  } = options;
+  let provider = requestedProvider;
+  if (!provider) {
+    if (apiKey) {
+      provider = "deepgram" /* Deepgram */;
+    } else if (typeof window !== "undefined") {
+      const hasWebSpeech = !!(window.SpeechRecognition || window.webkitSpeechRecognition);
+      if (hasWebSpeech) {
+        provider = "web-speech" /* WebSpeechAPI */;
+      } else {
+        throw new TranscriptionError(
+          "No speech recognition available. Provide an API key for Deepgram or AssemblyAI.",
+          "unsupported_browser" /* UNSUPPORTED_BROWSER */
+        );
+      }
+    } else {
+      throw new TranscriptionError(
+        "Provider must be specified in Node.js environment",
+        "invalid_config" /* INVALID_CONFIG */
+      );
+    }
+  }
+  const transcriptionConfig = {
+    provider,
+    apiKey,
+    language,
+    interimResults
+  };
+  const sessionConfig = {
+    recordAudio
+  };
+  const transcriber = createTranscriber(transcriptionConfig);
+  const session = new TranscriptionSession(transcriber, sessionConfig);
+  if (onTranscript) {
+    transcriber.on("transcript", onTranscript);
+  }
+  if (onError) {
+    transcriber.on("error", onError);
+  }
+  if (onStart) {
+    transcriber.on("start", onStart);
+  }
+  if (onStop) {
+    transcriber.on("stop", onStop);
+  }
+  try {
+    await transcriber.initialize();
+    await session.start();
+  } catch (error) {
+    if (onError && error instanceof TranscriptionError) {
+      onError(error);
+    }
+    throw error;
+  }
+  return session;
+}
+function isProviderSupported(provider) {
+  switch (provider) {
+    case "web-speech" /* WebSpeechAPI */:
+      return new WebSpeechProvider({ provider }).isSupported();
+    case "deepgram" /* Deepgram */:
+      return new DeepgramProvider({ provider, apiKey: "test" }).isSupported();
+    case "assemblyai" /* AssemblyAI */:
+      return new AssemblyAIProvider({ provider, apiKey: "test" }).isSupported();
+    default:
+      return false;
+  }
+}
+function getSupportedProviders() {
+  const providers = [];
+  if (isProviderSupported("web-speech" /* WebSpeechAPI */)) {
+    providers.push("web-speech" /* WebSpeechAPI */);
+  }
+  if (isProviderSupported("deepgram" /* Deepgram */)) {
+    providers.push("deepgram" /* Deepgram */);
+  }
+  if (isProviderSupported("assemblyai" /* AssemblyAI */)) {
+    providers.push("assemblyai" /* AssemblyAI */);
+  }
+  return providers;
+}
+var index_default = {
+  VERSION,
+  LIBRARY_NAME,
+  createTranscriber,
+  createSession,
+  quickStart,
+  isProviderSupported,
+  getSupportedProviders,
+  TranscriptionProvider,
+  WebSpeechProvider,
+  DeepgramProvider,
+  AssemblyAIProvider,
+  TranscriptionSession,
+  SessionManager
+};
+
+exports.AssemblyAIProvider = AssemblyAIProvider;
+exports.AudioBufferManager = AudioBufferManager;
+exports.AudioEncoding = AudioEncoding;
+exports.AudioLevelMonitor = AudioLevelMonitor;
+exports.AudioProcessor = AudioProcessor;
+exports.AudioRecorder = AudioRecorder;
+exports.BaseTranscriber = BaseTranscriber;
+exports.CSVExporter = CSVExporter;
+exports.DEFAULT_AUDIO_CONFIG = DEFAULT_AUDIO_CONFIG;
+exports.DEFAULT_SESSION_CONFIG = DEFAULT_SESSION_CONFIG;
+exports.DEFAULT_TRANSCRIPTION_CONFIG = DEFAULT_TRANSCRIPTION_CONFIG;
+exports.DeepgramProvider = DeepgramProvider;
+exports.ErrorCode = ErrorCode;
+exports.EventEmitter = EventEmitter;
+exports.JSONExporter = JSONExporter;
+exports.LIBRARY_NAME = LIBRARY_NAME;
+exports.LocalStorageAdapter = LocalStorageAdapter;
+exports.MemoryStorageAdapter = MemoryStorageAdapter;
+exports.SRTExporter = SRTExporter;
+exports.SessionManager = SessionManager;
+exports.SessionState = SessionState;
+exports.TextExporter = TextExporter;
+exports.TranscriptionError = TranscriptionError;
+exports.TranscriptionProvider = TranscriptionProvider;
+exports.TranscriptionSession = TranscriptionSession;
+exports.VERSION = VERSION;
+exports.VTTExporter = VTTExporter;
+exports.VoiceActivityDetector = VoiceActivityDetector;
+exports.WebSpeechProvider = WebSpeechProvider;
+exports.calculateBitrate = calculateBitrate;
+exports.calculatePeak = calculatePeak;
+exports.calculateRMS = calculateRMS;
+exports.cancellableTimeout = cancellableTimeout;
+exports.checkAudioContextSupport = checkAudioContextSupport;
+exports.checkMediaDevicesSupport = checkMediaDevicesSupport;
+exports.checkWebSocketSupport = checkWebSocketSupport;
+exports.checkWebSpeechAPISupport = checkWebSpeechAPISupport;
+exports.clamp = clamp;
+exports.createSession = createSession;
+exports.createTranscriber = createTranscriber;
+exports.dbToLinear = dbToLinear;
+exports.debounce = debounce;
+exports.deepClone = deepClone;
+exports.default = index_default;
+exports.detectBrowserLanguage = detectBrowserLanguage;
+exports.durationToSamples = durationToSamples;
+exports.estimateAudioSize = estimateAudioSize;
+exports.formatAsPlainText = formatAsPlainText;
+exports.formatConfidence = formatConfidence;
+exports.formatDuration = formatDuration;
+exports.formatFileSize = formatFileSize;
+exports.formatNumber = formatNumber;
+exports.formatTimestamp = formatTimestamp;
+exports.formatTranscriptForDisplay = formatTranscriptForDisplay;
+exports.generateId = generateId;
+exports.getAudioConstraints = getAudioConstraints;
+exports.getBestMatchingLanguage = getBestMatchingLanguage;
+exports.getBrowserInfo = getBrowserInfo;
+exports.getFullCompatibilityReport = getFullCompatibilityReport;
+exports.getLanguageName = getLanguageName;
+exports.getNativeLanguageName = getNativeLanguageName;
+exports.getOptimalBufferSize = getOptimalBufferSize;
+exports.getSupportedLanguages = getSupportedLanguages;
+exports.getSupportedProviders = getSupportedProviders;
+exports.groupBy = groupBy;
+exports.isEmpty = isEmpty;
+exports.isFunction = isFunction;
+exports.isLanguageSupported = isLanguageSupported;
+exports.isObject = isObject;
+exports.isProviderSupported = isProviderSupported;
+exports.isSilence = isSilence;
+exports.linearToDb = linearToDb;
+exports.mergeDeep = mergeDeep;
+exports.normalizeLanguageCode = normalizeLanguageCode;
+exports.omit = omit;
+exports.pick = pick;
+exports.quickStart = quickStart;
+exports.retry = retry;
+exports.round = round;
+exports.samplesToDuration = samplesToDuration;
+exports.setIntervalAsync = setIntervalAsync;
+exports.sleep = sleep;
+exports.throttle = throttle;
+exports.timeout = timeout;
+exports.truncateText = truncateText;
+exports.validateApiKey = validateApiKey;
+exports.validateAudioConfig = validateAudioConfig;
+exports.validateAudioFormat = validateAudioFormat;
+exports.validateLanguageCode = validateLanguageCode;
+exports.validateSessionConfig = validateSessionConfig;
+exports.validateTranscriptionConfig = validateTranscriptionConfig;
+exports.waitFor = waitFor;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map