@360labs/live-transcribe 0.1.0

package/dist/index.mjs

@@ -0,0 +1,4682 @@
+/* @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
+};
+
+export { AssemblyAIProvider, AudioBufferManager, AudioEncoding, AudioLevelMonitor, AudioProcessor, AudioRecorder, BaseTranscriber, CSVExporter, DEFAULT_AUDIO_CONFIG, DEFAULT_SESSION_CONFIG, DEFAULT_TRANSCRIPTION_CONFIG, DeepgramProvider, ErrorCode, EventEmitter, JSONExporter, LIBRARY_NAME, LocalStorageAdapter, MemoryStorageAdapter, SRTExporter, SessionManager, SessionState, TextExporter, TranscriptionError, TranscriptionProvider, TranscriptionSession, VERSION, VTTExporter, VoiceActivityDetector, WebSpeechProvider, calculateBitrate, calculatePeak, calculateRMS, cancellableTimeout, checkAudioContextSupport, checkMediaDevicesSupport, checkWebSocketSupport, checkWebSpeechAPISupport, clamp, createSession, createTranscriber, dbToLinear, debounce, deepClone, index_default as default, detectBrowserLanguage, durationToSamples, estimateAudioSize, formatAsPlainText, formatConfidence, formatDuration, formatFileSize, formatNumber, formatTimestamp, formatTranscriptForDisplay, generateId, getAudioConstraints, getBestMatchingLanguage, getBrowserInfo, getFullCompatibilityReport, getLanguageName, getNativeLanguageName, getOptimalBufferSize, getSupportedLanguages, getSupportedProviders, groupBy, isEmpty, isFunction, isLanguageSupported, isObject, isProviderSupported, isSilence, linearToDb, mergeDeep, normalizeLanguageCode, omit, pick, quickStart, retry, round, samplesToDuration, setIntervalAsync, sleep, throttle, timeout, truncateText, validateApiKey, validateAudioConfig, validateAudioFormat, validateLanguageCode, validateSessionConfig, validateTranscriptionConfig, waitFor };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map