sera-ai 1.0.7 → 1.0.9

package/dist/index.mjs

@@ -1,7 +1,7 @@
 import * as React3 from 'react';
 import React3__default, { useState, useRef, useCallback, useEffect } from 'react';
 import pRetry, { AbortError } from 'p-retry';
-import { AlertTriangle, Loader2, Square, Pause, Play, Mic, X, AlertCircle, Check } from 'lucide-react';
+import { AlertTriangle, Loader2, Square, Pause, Play, Mic, Download, X, AlertCircle, Check } from 'lucide-react';
 import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
 
 // src/AudioRecorder.tsx
@@ -2828,6 +2828,7 @@ var useAudioRecorder = ({
   speciality,
   patientId,
   patientName,
+  patientHistory,
   selectedFormat = "json",
   skipDiarization = true,
   silenceRemoval = true,
@@ -3209,6 +3210,7 @@ var useAudioRecorder = ({
                 formData.append("model", selectedModelRef.current);
                 formData.append("doctorName", doctorName);
                 formData.append("patientName", patientName || "");
+                if (patientHistory) formData.append("patientHistory", patientHistory);
                 if (patientId) formData.append("patientId", patientId.toString());
                 formData.append("removeSilence", removeSilenceRef.current.toString());
                 formData.append("skipDiarization", skipDiarizationRef.current.toString());
@@ -3390,6 +3392,7 @@ var useAudioRecorder = ({
       skipDiarization,
       selectedFormat,
       patientName,
+      patientHistory,
       onTranscriptionComplete,
       speciality,
       removeSilence,
@@ -3448,6 +3451,7 @@ var useAudioRecorder = ({
         await createSession(localSessionId, {
           patientId,
           patientName: patientName || void 0,
+          patientHistory: patientHistory || void 0,
           speciality
         });
       }
@@ -3546,6 +3550,7 @@ var useAudioRecorder = ({
     createSession,
     patientId,
     patientName,
+    patientHistory,
     speciality,
     currentDeviceId
   ]);
@@ -4336,6 +4341,7 @@ var AudioRecorder = ({
   speciality,
   patientId,
   patientName,
+  patientHistory,
   onTranscriptionUpdate,
   onTranscriptionComplete,
   onSuccess,
@@ -4370,6 +4376,7 @@ var AudioRecorder = ({
     speciality,
     patientName,
     patientId,
+    patientHistory,
     onTranscriptionUpdate: (text, sessionId) => {
       console.log("onTranscriptionUpdate called with text:", text, "sessionId:", sessionId);
       if (text.length > 0) {
@@ -5071,7 +5078,885 @@ var AudioDictation = ({
   ) });
 };
 var AudioDictation_default = AudioDictation;
+var createAudioCaptureWorker = () => {
+  const workerCode = `
+    class AudioCaptureProcessor extends AudioWorkletProcessor {
+      constructor() {
+        super();
+        this._buffer = [];
+        this._isStopped = false;
+        this._isPaused = false;
+        this._chunkReady = false;
+        this._processingChunk = false;
+        
+        this._audioLevelCheckInterval = 0;
+        this._audioLevelCheckFrequency = 128;
+        this._silentSampleCount = 0;
+        this._maxSilentSamples = 44100 * 30;
+        this._audioThreshold = 0.002;
+        this._hasDetectedAudio = false;
+        this._lastAudioTime = 0;
+        this._recordingStartTime = Date.now();
+        this._initialSilenceThreshold = 44100 * 10;
+        this._isInitialPhase = true;
+        this._bufferSize = 0;
+
+        this.port.onmessage = (event) => {
+          if (event.data.command === "stop") {
+            this._isStopped = true;
+            this._sendFinalChunk();
+          }
+
+          if (event.data.command === "getChunk") {
+            this._chunkReady = true;
+          }
+
+          if (event.data.command === "resetChunk") {
+            this._chunkReady = false;
+            this._processingChunk = false;
+            this._buffer = [];
+            this._bufferSize = 0;
+          }
+
+          if (event.data.command === "pause") {
+            this._isPaused = true;
+          }
+
+          if (event.data.command === "resume") {
+            this._isPaused = false;
+          }
+        };
+      }
+
+      _sendFinalChunk() {
+        if (this._buffer.length > 0) {
+          const flat = this._flattenBuffer();
+          this.port.postMessage({
+            command: "finalChunk",
+            audioBuffer: flat.buffer,
+            duration: this._bufferSize / 44100
+          }, [flat.buffer]);
+        } else {
+          // Send empty final chunk
+          const emptyBuffer = new Float32Array(1000);
+          this.port.postMessage({
+            command: "finalChunk", 
+            audioBuffer: emptyBuffer.buffer,
+            duration: 0
+          }, [emptyBuffer.buffer]);
+        }
+        this._buffer = [];
+        this._bufferSize = 0;
+      }
+
+      _flattenBuffer() {
+        let totalLength = 0;
+        for (let i = 0; i < this._buffer.length; i++) {
+          totalLength += this._buffer[i].length;
+        }
+        
+        const flat = new Float32Array(totalLength);
+        let offset = 0;
+        for (let i = 0; i < this._buffer.length; i++) {
+          flat.set(this._buffer[i], offset);
+          offset += this._buffer[i].length;
+        }
+        return flat;
+      }
+
+      process(inputs, outputs) {
+        if (this._isStopped || this._isPaused) {
+          return true;
+        }
+
+        const input = inputs[0];
+        if (input && input.length > 0) {
+          const samples = input[0];
+          
+          // Calculate audio level
+          let audioLevel = 0;
+          for (let i = 0; i < samples.length; i++) {
+            audioLevel += Math.abs(samples[i]);
+          }
+          audioLevel /= samples.length;
+
+          // Send audio level updates
+          this._audioLevelCheckInterval++;
+          if (this._audioLevelCheckInterval >= this._audioLevelCheckFrequency) {
+            this.port.postMessage({
+              command: "audioLevel",
+              level: audioLevel,
+            });
+            this._audioLevelCheckInterval = 0;
+          }
+
+          // Check for audio activity
+          if (audioLevel > this._audioThreshold) {
+            this._hasDetectedAudio = true;
+            this._isInitialPhase = false;
+            this._silentSampleCount = 0;
+            this._lastAudioTime = Date.now();
+          } else {
+            this._silentSampleCount += samples.length;
+            
+            if (this._isInitialPhase && this._silentSampleCount > this._initialSilenceThreshold) {
+              this.port.postMessage({
+                command: "noAudioDetected",
+                message: "No audio input detected after 10 seconds. Please check your microphone."
+              });
+              return true;
+            }
+          }
+
+          // Buffer the audio
+          this._buffer.push(new Float32Array(samples));
+          this._bufferSize += samples.length;
+
+          // Send chunk if ready
+          if (this._chunkReady && !this._processingChunk) {
+            this._processingChunk = true;
+            
+            const flat = this._flattenBuffer();
+            this.port.postMessage({
+              command: "chunk",
+              audioBuffer: flat.buffer,
+              duration: this._bufferSize / 44100,
+              hasActivity: audioLevel > this._audioThreshold
+            }, [flat.buffer]);
+            
+            this._buffer = [];
+            this._bufferSize = 0;
+            this._chunkReady = false;
+            this._processingChunk = false;
+          }
+        }
+
+        return true;
+      }
+    }
+
+    registerProcessor("audio-capture-processor", AudioCaptureProcessor);
+  `;
+  const blob = new Blob([workerCode], { type: "application/javascript" });
+  return URL.createObjectURL(blob);
+};
+var useAudioCapture = ({
+  onAudioChunk,
+  onAudioComplete,
+  onAudioFile,
+  silenceRemoval = false,
+  chunkDuration = 30,
+  // Default 30 seconds per chunk
+  format = "raw"
+}) => {
+  const [isRecording, setIsRecording] = useState(false);
+  const [isPaused, setIsPaused] = useState(false);
+  const [isProcessing, setIsProcessing] = useState(false);
+  const [error, setError] = useState(null);
+  const [currentDeviceId, setCurrentDeviceId] = useState(null);
+  const [availableDevices, setAvailableDevices] = useState([]);
+  const [audioLevel, setAudioLevel] = useState(0);
+  const [noAudioDetected, setNoAudioDetected] = useState(false);
+  const [recordingDuration, setRecordingDuration] = useState(0);
+  const [totalChunks, setTotalChunks] = useState(0);
+  const mediaStreamRef = useRef(null);
+  const processorRef = useRef(null);
+  const audioContextRef = useRef(null);
+  const chunkIntervalRef = useRef(null);
+  const recordingStartTimeRef = useRef(0);
+  const durationIntervalRef = useRef(null);
+  const sequenceCounterRef = useRef(0);
+  const allAudioChunksRef = useRef([]);
+  const {
+    removeSilence,
+    isLoaded,
+    isConverting,
+    progress,
+    statusMessage,
+    convertToWav
+  } = useFFmpegConverter_default();
+  const validateMicrophoneAccess = useCallback(async () => {
+    try {
+      const devices = await navigator.mediaDevices.enumerateDevices();
+      const audioInputDevices = devices.filter((device) => device.kind === "audioinput");
+      setAvailableDevices(audioInputDevices);
+      if (audioInputDevices.length === 0) {
+        throw new Error("No microphone devices detected. Please connect a microphone.");
+      }
+      const testStream = await navigator.mediaDevices.getUserMedia({
+        audio: {
+          deviceId: currentDeviceId ? { exact: currentDeviceId } : void 0
+        }
+      });
+      const audioTracks = testStream.getAudioTracks();
+      if (audioTracks.length > 0) {
+        const track = audioTracks[0];
+        const settings = track.getSettings();
+        setCurrentDeviceId(settings.deviceId || null);
+      }
+      testStream.getTracks().forEach((track) => track.stop());
+      return true;
+    } catch (error2) {
+      console.error("Microphone validation failed:", error2);
+      if (error2 instanceof Error) {
+        let errorMessage = "";
+        if (error2.name === "NotFoundError" || error2.name === "DevicesNotFoundError") {
+          errorMessage = "No microphone devices found. Please connect a microphone.";
+        } else if (error2.name === "NotAllowedError" || error2.name === "PermissionDeniedError") {
+          errorMessage = "Microphone permission denied. Please allow access and try again.";
+        } else if (error2.name === "NotReadableError" || error2.name === "TrackStartError") {
+          errorMessage = "Microphone is busy or unavailable. Please close other applications using the microphone.";
+        } else if (error2.name === "OverconstrainedError") {
+          errorMessage = "Selected microphone device is not available. Please select a different device.";
+        } else {
+          errorMessage = `Microphone error: ${error2.message}`;
+        }
+        setError(errorMessage);
+      } else {
+        setError("Microphone access error occurred.");
+      }
+      return false;
+    }
+  }, [currentDeviceId]);
+  const processAudioChunk = useCallback(async (audioData, sequence, isFinal) => {
+    try {
+      setIsProcessing(true);
+      let processedAudio = audioData;
+      if (silenceRemoval && isLoaded && typeof removeSilence === "function") {
+        console.log("Applying silence removal to audio chunk...");
+        const tempFile = float32ToWavFile(audioData);
+        const processedFile = await removeSilence(tempFile);
+        if (processedFile) {
+          const arrayBuffer = await processedFile.arrayBuffer();
+          const dataView = new DataView(arrayBuffer);
+          const samples = new Float32Array((arrayBuffer.byteLength - 44) / 2);
+          for (let i = 0; i < samples.length; i++) {
+            const int16 = dataView.getInt16(44 + i * 2, true);
+            samples[i] = int16 / (int16 < 0 ? 32768 : 32767);
+          }
+          processedAudio = samples;
+        }
+      }
+      if (!isFinal) {
+        allAudioChunksRef.current.push(processedAudio);
+      }
+      if (onAudioChunk) {
+        onAudioChunk(processedAudio, sequence, isFinal);
+      }
+      if (isFinal) {
+        const totalLength = allAudioChunksRef.current.reduce((sum, chunk) => sum + chunk.length, 0);
+        const finalAudio = new Float32Array(totalLength);
+        let offset = 0;
+        for (const chunk of allAudioChunksRef.current) {
+          finalAudio.set(chunk, offset);
+          offset += chunk.length;
+        }
+        if (onAudioComplete) {
+          onAudioComplete(finalAudio);
+        }
+        if (onAudioFile && format === "wav") {
+          const wavFile = await createWavFile(finalAudio);
+          onAudioFile(wavFile);
+        } else if (onAudioFile && format === "raw") {
+          const rawFile = createRawFile(finalAudio);
+          onAudioFile(rawFile);
+        }
+        allAudioChunksRef.current = [];
+      }
+    } catch (error2) {
+      console.error("Error processing audio chunk:", error2);
+      setError(`Audio processing failed: ${error2 instanceof Error ? error2.message : "Unknown error"}`);
+    } finally {
+      setIsProcessing(false);
+    }
+  }, [silenceRemoval, isLoaded, removeSilence, onAudioChunk, onAudioComplete, onAudioFile, format]);
+  const createWavFile = useCallback(async (samples) => {
+    if (isLoaded && typeof convertToWav === "function") {
+      const result = await convertToWav(samples);
+      return result || float32ToWavFile(samples);
+    } else {
+      return float32ToWavFile(samples);
+    }
+  }, [isLoaded, convertToWav]);
+  const createRawFile = useCallback((samples) => {
+    const timestamp = Date.now();
+    const filename = `audio-recording-${timestamp}.raw`;
+    const buffer = new ArrayBuffer(samples.byteLength);
+    const uint8Array = new Uint8Array(buffer);
+    const sourceArray = new Uint8Array(samples.buffer, samples.byteOffset, samples.byteLength);
+    uint8Array.set(sourceArray);
+    return new File([buffer], filename, {
+      type: "application/octet-stream",
+      lastModified: timestamp
+    });
+  }, []);
+  const float32ToWavFile = (samples) => {
+    const sampleRate = audioContextRef.current?.sampleRate || 44100;
+    const buffer = new ArrayBuffer(44 + samples.length * 2);
+    const view = new DataView(buffer);
+    const writeString = (offset2, str) => {
+      for (let i = 0; i < str.length; i++) {
+        view.setUint8(offset2 + i, str.charCodeAt(i));
+      }
+    };
+    writeString(0, "RIFF");
+    view.setUint32(4, 36 + samples.length * 2, true);
+    writeString(8, "WAVE");
+    writeString(12, "fmt ");
+    view.setUint32(16, 16, true);
+    view.setUint16(20, 1, true);
+    view.setUint16(22, 1, true);
+    view.setUint32(24, sampleRate, true);
+    view.setUint32(28, sampleRate * 2, true);
+    view.setUint16(32, 2, true);
+    view.setUint16(34, 16, true);
+    writeString(36, "data");
+    view.setUint32(40, samples.length * 2, true);
+    let offset = 44;
+    for (let i = 0; i < samples.length; i++) {
+      const sample = Math.max(-1, Math.min(1, samples[i]));
+      view.setInt16(offset, sample < 0 ? sample * 32768 : sample * 32767, true);
+      offset += 2;
+    }
+    const timestamp = Date.now();
+    const filename = `audio-recording-${timestamp}.wav`;
+    return new File([view], filename, {
+      type: "audio/wav",
+      lastModified: timestamp
+    });
+  };
+  const startRecording = useCallback(async () => {
+    try {
+      setError(null);
+      setNoAudioDetected(false);
+      const micValid = await validateMicrophoneAccess();
+      if (!micValid) return;
+      sequenceCounterRef.current = 0;
+      allAudioChunksRef.current = [];
+      setTotalChunks(0);
+      setRecordingDuration(0);
+      recordingStartTimeRef.current = Date.now();
+      const stream = await navigator.mediaDevices.getUserMedia({
+        audio: {
+          deviceId: currentDeviceId ? { exact: currentDeviceId } : void 0,
+          echoCancellation: true,
+          noiseSuppression: true,
+          autoGainControl: true
+        }
+      });
+      mediaStreamRef.current = stream;
+      const audioContext = new (window.AudioContext || window.webkitAudioContext)();
+      const processorUrl = createAudioCaptureWorker();
+      await audioContext.audioWorklet.addModule(processorUrl);
+      URL.revokeObjectURL(processorUrl);
+      const processor = new AudioWorkletNode(audioContext, "audio-capture-processor");
+      processor.port.onmessage = (event) => {
+        if (event.data.command === "chunk") {
+          const audioData = new Float32Array(event.data.audioBuffer);
+          const sequence = sequenceCounterRef.current++;
+          setTotalChunks(sequence + 1);
+          processAudioChunk(audioData, sequence, false);
+        } else if (event.data.command === "finalChunk") {
+          const audioData = new Float32Array(event.data.audioBuffer);
+          const sequence = sequenceCounterRef.current++;
+          processAudioChunk(audioData, sequence, true);
+        } else if (event.data.command === "audioLevel") {
+          setAudioLevel(event.data.level);
+        } else if (event.data.command === "noAudioDetected") {
+          setNoAudioDetected(true);
+          setError(event.data.message);
+        }
+      };
+      const source = audioContext.createMediaStreamSource(stream);
+      source.connect(processor);
+      audioContextRef.current = audioContext;
+      processorRef.current = processor;
+      setIsRecording(true);
+      const chunkIntervalId = window.setInterval(() => {
+        processor.port.postMessage({ command: "getChunk" });
+      }, chunkDuration * 1e3);
+      chunkIntervalRef.current = chunkIntervalId;
+      const durationIntervalId = window.setInterval(() => {
+        const elapsed = (Date.now() - recordingStartTimeRef.current) / 1e3;
+        setRecordingDuration(elapsed);
+      }, 100);
+      durationIntervalRef.current = durationIntervalId;
+    } catch (err) {
+      console.error("Recording start failed:", err);
+      setError(err instanceof Error ? err.message : "Failed to start recording");
+    }
+  }, [validateMicrophoneAccess, currentDeviceId, chunkDuration, processAudioChunk]);
+  const stopRecording = useCallback(() => {
+    console.log("Stopping recording...");
+    if (chunkIntervalRef.current) {
+      clearInterval(chunkIntervalRef.current);
+      chunkIntervalRef.current = null;
+    }
+    if (durationIntervalRef.current) {
+      clearInterval(durationIntervalRef.current);
+      durationIntervalRef.current = null;
+    }
+    if (processorRef.current) {
+      processorRef.current.port.postMessage({ command: "stop" });
+    }
+    if (mediaStreamRef.current) {
+      mediaStreamRef.current.getTracks().forEach((track) => track.stop());
+      mediaStreamRef.current = null;
+    }
+    if (audioContextRef.current) {
+      audioContextRef.current.close();
+      audioContextRef.current = null;
+    }
+    processorRef.current = null;
+    setIsRecording(false);
+  }, []);
+  const pauseRecording = useCallback(() => {
+    if (!isRecording || isPaused) return;
+    if (chunkIntervalRef.current) {
+      clearInterval(chunkIntervalRef.current);
+      chunkIntervalRef.current = null;
+    }
+    if (durationIntervalRef.current) {
+      clearInterval(durationIntervalRef.current);
+      durationIntervalRef.current = null;
+    }
+    setIsPaused(true);
+    if (processorRef.current) {
+      processorRef.current.port.postMessage({ command: "pause" });
+    }
+    setIsRecording(false);
+  }, [isRecording, isPaused]);
+  const resumeRecording = useCallback(() => {
+    if (!isPaused) return;
+    setIsPaused(false);
+    setIsRecording(true);
+    setNoAudioDetected(false);
+    if (processorRef.current) {
+      processorRef.current.port.postMessage({ command: "resume" });
+    }
+    const chunkIntervalId = window.setInterval(() => {
+      processorRef.current?.port.postMessage({ command: "getChunk" });
+    }, chunkDuration * 1e3);
+    chunkIntervalRef.current = chunkIntervalId;
+    const durationIntervalId = window.setInterval(() => {
+      const elapsed = (Date.now() - recordingStartTimeRef.current) / 1e3;
+      setRecordingDuration(elapsed);
+    }, 100);
+    durationIntervalRef.current = durationIntervalId;
+  }, [isPaused, chunkDuration]);
+  const selectMicrophone = useCallback(async (deviceId) => {
+    try {
+      setCurrentDeviceId(deviceId);
+      if (isRecording) {
+        await stopRecording();
+        await startRecording();
+      }
+    } catch (error2) {
+      console.error("Device selection failed:", error2);
+      setError("Failed to switch to selected microphone.");
+    }
+  }, [isRecording, stopRecording, startRecording]);
+  return {
+    mediaStreamRef,
+    startRecording,
+    stopRecording,
+    pauseRecording,
+    resumeRecording,
+    isRecording,
+    isPaused,
+    isProcessing,
+    error,
+    availableDevices,
+    currentDeviceId,
+    selectMicrophone,
+    validateMicrophoneAccess,
+    audioLevel,
+    noAudioDetected,
+    isConverting,
+    progress,
+    statusMessage,
+    recordingDuration,
+    totalChunks
+  };
+};
+var useAudioCapture_default = useAudioCapture;
+var tailwindStyles2 = `
+  .space-y-4 > :not([hidden]) ~ :not([hidden]) { margin-top: 1rem; }
+  .bg-orange-50 { background-color: rgb(255 247 237); }
+  .bg-blue-900 { background-color: rgb(30 58 138); }
+  .text-yellow-200 { color: rgb(254 240 138); }
+  .hover\\:bg-blue-700:hover { background-color: rgb(29 78 216); }
+  .dark .dark\\:bg-orange-900\\/20 { background-color: rgb(194 65 12 / 0.2); }
+  .border { border-width: 1px; }
+  .border-orange-200 { border-color: rgb(254 215 170); }
+  .dark .dark\\:border-orange-800 { border-color: rgb(154 52 18); }
+  .rounded-lg { border-radius: 0.5rem; }
+  .p-4 { padding: 1rem; }
+  .flex { display: flex; }
+  .items-start { align-items: flex-start; }
+  .items-center { align-items: center; }
+  .justify-center { justify-content: center; }
+  .justify-between { justify-content: space-between; }
+  .flex-shrink-0 { flex-shrink: 0; }
+  .h-5 { height: 1.25rem; }
+  .w-5 { width: 1.25rem; }
+  .text-orange-400 { color: rgb(251 146 60); }
+  .ml-3 { margin-left: 0.75rem; }
+  .mr-2 { margin-right: 0.5rem; }
+  .flex-1 { flex: 1 1 0%; }
+  .text-sm { font-size: 0.875rem; line-height: 1.25rem; }
+  .font-medium { font-weight: 500; }
+  .text-orange-800 { color: rgb(154 52 18); }
+  .dark .dark\\:text-orange-200 { color: rgb(254 215 170); }
+  .mt-2 { margin-top: 0.5rem; }
+  .text-orange-700 { color: rgb(194 65 12); }
+  .dark .dark\\:text-orange-300 { color: rgb(253 186 116); }
+  .list-disc { list-style-type: disc; }
+  .list-inside { list-style-position: inside; }
+  .bg-red-50 { background-color: rgb(254 242 242); }
+  .dark .dark\\:bg-red-900\\/20 { background-color: rgb(127 29 29 / 0.2); }
+  .border-red-200 { border-color: rgb(254 202 202); }
+  .dark .dark\\:border-red-800 { border-color: rgb(153 27 27); }
+  .text-red-400 { color: rgb(248 113 113); }
+  .text-red-800 { color: rgb(153 27 27); }
+  .dark .dark\\:text-red-200 { color: rgb(254 202 202); }
+  .text-red-700 { color: rgb(185 28 28); }
+  .dark .dark\\:text-red-300 { color: rgb(252 165 165); }
+  .mt-4 { margin-top: 1rem; }
+  .bg-red-600 { background-color: rgb(220 38 38); }
+  .hover\\:bg-red-700:hover { background-color: rgb(185 28 28); }
+  .text-white { color: rgb(255 255 255); }
+  .px-3 { padding-left: 0.75rem; padding-right: 0.75rem; }
+  .py-1 { padding-top: 0.25rem; padding-bottom: 0.25rem; }
+  .py-2 { padding-top: 0.5rem; padding-bottom: 0.5rem; }
+  .px-4 { padding-left: 1rem; padding-right: 1rem; }
+  .rounded { border-radius: 0.25rem; }
+  .rounded-full { border-radius: 9999px; }
+  .transition-colors { transition-property: color, background-color, border-color, text-decoration-color, fill, stroke; transition-timing-function: cubic-bezier(0.4, 0, 0.2, 1); transition-duration: 150ms; }
+  .bg-yellow-50 { background-color: rgb(254 252 232); }
+  .dark .dark\\:bg-yellow-900\\/20 { background-color: rgb(133 77 14 / 0.2); }
+  .border-yellow-200 { border-color: rgb(254 240 138); }
+  .dark .dark\\:border-yellow-800 { border-color: rgb(133 77 14); }
+  .text-yellow-400 { color: rgb(250 204 21); }
+  .text-yellow-800 { color: rgb(133 77 14); }
+  .dark .dark\\:text-yellow-200 { color: rgb(254 240 138); }
+  .text-yellow-700 { color: rgb(161 98 7); }
+  .dark .dark\\:text-yellow-300 { color: rgb(253 224 71); }
+  .space-x-3 > :not([hidden]) ~ :not([hidden]) { margin-left: 0.75rem; }
+  .space-x-1 > :not([hidden]) ~ :not([hidden]) { margin-left: 0.25rem; }
+  .space-x-2 > :not([hidden]) ~ :not([hidden]) { margin-left: 0.5rem; }
+  .bg-yellow-600 { background-color: rgb(202 138 4); }
+  .hover\\:bg-yellow-700:hover { background-color: rgb(161 98 7); }
+  .disabled\\:opacity-50:disabled { opacity: 0.5; }
+  .h-3 { height: 0.75rem; }
+  .w-3 { width: 0.75rem; }
+  .animate-spin { animation: spin 1s linear infinite; }
+  @keyframes spin { from { transform: rotate(0deg); } to { transform: rotate(360deg); } }
+  .bg-gray-600 { background-color: rgb(75 85 99); }
+  .hover\\:bg-gray-700:hover { background-color: rgb(55 65 81); }
+  .bg-blue-50 { background-color: rgb(239 246 255); }
+  .dark .dark\\:bg-blue-900\\/20 { background-color: rgb(30 58 138 / 0.2); }
+  .border-blue-200 { border-color: rgb(191 219 254); }
+  .dark .dark\\:border-blue-800 { border-color: rgb(30 64 175); }
+  .text-blue-600 { color: rgb(37 99 235); }
+  .block { display: block; }
+  .text-blue-700 { color: rgb(29 78 216); }
+  .dark .dark\\:text-blue-300 { color: rgb(147 197 253); }
+  .text-xs { font-size: 0.75rem; line-height: 1rem; }
+  .dark .dark\\:text-blue-400 { color: rgb(96 165 250); }
+  .mt-1 { margin-top: 0.25rem; }
+  .bg-teal-600 { background-color: rgb(13 148 136); }
+  .hover\\:bg-teal-700:hover { background-color: rgb(15 118 110); }
+  .bg-green-600 { background-color: rgb(22 163 74); }
+  .hover\\:bg-green-700:hover { background-color: rgb(21 128 61); }
+  .bg-yellow-500 { background-color: rgb(234 179 8); }
+  .hover\\:bg-yellow-600:hover { background-color: rgb(202 138 4); }
+  .bg-gradient-to-r { background-image: linear-gradient(to right, var(--tw-gradient-stops)); }
+  .from-purple-400 { --tw-gradient-from: #c084fc; --tw-gradient-to: rgb(192 132 252 / 0); --tw-gradient-stops: var(--tw-gradient-from), var(--tw-gradient-to); }
+  .to-blue-500 { --tw-gradient-to: #3b82f6; }
+  .hover\\:from-purple-500:hover { --tw-gradient-from: #a855f7; --tw-gradient-to: rgb(168 85 247 / 0); --tw-gradient-stops: var(--tw-gradient-from), var(--tw-gradient-to); }
+  .hover\\:to-blue-600:hover { --tw-gradient-to: #2563eb; }
+  .opacity-50 { opacity: 0.5; }
+  .cursor-not-allowed { cursor: not-allowed; }
+  .text-gray-600 { color: rgb(75 85 99); }
+  .dark .dark\\:text-gray-300 { color: rgb(209 213 219); }
+  .bg-gray-100 { background-color: rgb(243 244 246); }
+  .dark .dark\\:bg-gray-800 { background-color: rgb(31 41 55); }
+  .border-gray-200 { border-color: rgb(229 231 235); }
+  .dark .dark\\:border-gray-700 { border-color: rgb(55 65 81); }
+  .cursor-pointer { cursor: pointer; }
+  .hover\\:bg-gray-200:hover { background-color: rgb(229 231 235); }
+  .dark .dark\\:hover\\:bg-gray-700:hover { background-color: rgb(55 65 81); }
+`;
+var stylesInjected2 = false;
+var injectTailwindStyles2 = () => {
+  if (!stylesInjected2 && typeof document !== "undefined") {
+    const styleElement = document.createElement("style");
+    styleElement.textContent = tailwindStyles2;
+    document.head.appendChild(styleElement);
+    stylesInjected2 = true;
+  }
+};
+var AudioCapture = ({
+  onAudioChunk,
+  onAudioComplete,
+  onAudioFile,
+  silenceRemoval = false,
+  chunkDuration = 30,
+  format = "raw",
+  showDownload = false,
+  className = "",
+  style
+}) => {
+  React3.useEffect(() => {
+    injectTailwindStyles2();
+  }, []);
+  const {
+    mediaStreamRef,
+    startRecording,
+    stopRecording,
+    pauseRecording,
+    resumeRecording,
+    isRecording,
+    isPaused,
+    isProcessing,
+    error,
+    availableDevices,
+    currentDeviceId,
+    selectMicrophone,
+    validateMicrophoneAccess,
+    noAudioDetected,
+    isConverting,
+    progress,
+    statusMessage,
+    recordingDuration,
+    totalChunks
+  } = useAudioCapture_default({
+    onAudioChunk,
+    onAudioComplete,
+    onAudioFile,
+    silenceRemoval,
+    chunkDuration,
+    format
+  });
+  const [isDisabled, setIsDisabled] = React3.useState(false);
+  const [lastAudioFile, setLastAudioFile] = React3.useState(null);
+  const [toast, setToast] = React3.useState({
+    show: false,
+    message: "",
+    type: "success"
+  });
+  React3.useEffect(() => {
+    if (onAudioFile) {
+      const originalCallback = onAudioFile;
+      onAudioFile = (file) => {
+        setLastAudioFile(file);
+        originalCallback(file);
+      };
+    }
+  }, [onAudioFile]);
+  const handleStopClick = () => {
+    setIsDisabled(true);
+    stopRecording();
+  };
+  const handleStartRecording = () => {
+    setIsDisabled(false);
+    setLastAudioFile(null);
+    startRecording();
+  };
+  const handleDownload = () => {
+    if (lastAudioFile) {
+      const url = URL.createObjectURL(lastAudioFile);
+      const a = document.createElement("a");
+      a.href = url;
+      a.download = lastAudioFile.name;
+      document.body.appendChild(a);
+      a.click();
+      document.body.removeChild(a);
+      URL.revokeObjectURL(url);
+      setToast({
+        show: true,
+        message: `Downloaded ${lastAudioFile.name}`,
+        type: "success"
+      });
+    }
+  };
+  React3.useEffect(() => {
+    if (error) {
+      setToast({ show: true, message: error, type: "error" });
+    }
+  }, [error]);
+  const closeToast = () => {
+    setToast({ ...toast, show: false });
+  };
+  const formatDuration = (seconds) => {
+    const minutes = Math.floor(seconds / 60);
+    const secs = Math.floor(seconds % 60);
+    return `${minutes}:${secs.toString().padStart(2, "0")}`;
+  };
+  const isMicrophoneError = error && (error.toLowerCase().includes("microphone") || error.toLowerCase().includes("not found") || error.toLowerCase().includes("no audio") || error.toLowerCase().includes("devices not found") || error.toLowerCase().includes("access denied") || error.toLowerCase().includes("permission") || error.toLowerCase().includes("not allowed") || error.toLowerCase().includes("busy") || error.toLowerCase().includes("media devices not supported") || availableDevices.length === 0 || noAudioDetected);
+  if (noAudioDetected || error && error.includes("No audio input detected")) {
+    return /* @__PURE__ */ jsx("div", { className: "bg-orange-50 dark:bg-orange-900/20 border border-orange-200 dark:border-orange-800 rounded-lg p-4", children: /* @__PURE__ */ jsxs("div", { className: "flex items-start", children: [
+      /* @__PURE__ */ jsx("div", { className: "flex-shrink-0", children: /* @__PURE__ */ jsx(AlertTriangle, { className: "h-5 w-5 text-orange-400" }) }),
+      /* @__PURE__ */ jsxs("div", { className: "ml-3 flex-1", children: [
+        /* @__PURE__ */ jsx("h3", { className: "text-sm font-medium text-orange-800 dark:text-orange-200", children: "No Audio Input Detected" }),
+        /* @__PURE__ */ jsxs("div", { className: "mt-2 text-sm text-orange-700 dark:text-orange-300", children: [
+          /* @__PURE__ */ jsx("p", { children: error }),
+          /* @__PURE__ */ jsxs("ul", { className: "mt-2 list-disc list-inside", children: [
+            /* @__PURE__ */ jsx("li", { children: "Check if your microphone is properly connected" }),
+            /* @__PURE__ */ jsx("li", { children: "Ensure you're speaking close enough to the microphone" }),
+            /* @__PURE__ */ jsx("li", { children: "Try adjusting your microphone volume settings" }),
+            /* @__PURE__ */ jsx("li", { children: "Test your microphone in other applications" }),
+            /* @__PURE__ */ jsx("li", { children: "Make sure your browser has microphone permissions" }),
+            /* @__PURE__ */ jsx("li", { children: "Please reload the page and try again" })
+          ] })
+        ] })
+      ] })
+    ] }) });
+  }
+  if (isMicrophoneError) {
+    return /* @__PURE__ */ jsx("div", { className: "bg-red-50 dark:bg-red-900/20 border border-red-200 dark:border-red-800 rounded-lg p-4", children: /* @__PURE__ */ jsxs("div", { className: "flex items-start", children: [
+      /* @__PURE__ */ jsx("div", { className: "flex-shrink-0", children: /* @__PURE__ */ jsx(AlertTriangle, { className: "h-5 w-5 text-red-400" }) }),
+      /* @__PURE__ */ jsxs("div", { className: "ml-3 flex-1", children: [
+        /* @__PURE__ */ jsx("h3", { className: "text-sm font-medium text-red-800 dark:text-red-200", children: "Audio Input Issue" }),
+        /* @__PURE__ */ jsx("div", { className: "mt-2 text-sm text-red-700 dark:text-red-300", children: /* @__PURE__ */ jsx("p", { children: error }) }),
+        /* @__PURE__ */ jsx("div", { className: "mt-4", children: /* @__PURE__ */ jsx(
+          "button",
+          {
+            onClick: () => {
+              validateMicrophoneAccess();
+            },
+            className: "bg-red-600 hover:bg-red-700 text-white px-3 py-1 rounded text-sm transition-colors",
+            children: "Check Again"
+          }
+        ) })
+      ] })
+    ] }) });
+  }
+  return /* @__PURE__ */ jsxs("div", { className: "space-y-4", children: [
+    toast.show && /* @__PURE__ */ jsx(Toast, { message: toast.message, type: toast.type, onClose: closeToast, duration: 3 }),
+    (isRecording || isPaused || recordingDuration > 0) && /* @__PURE__ */ jsx("div", { className: "bg-gray-100 dark:bg-gray-800 border border-gray-200 dark:border-gray-700 rounded-lg p-4", children: /* @__PURE__ */ jsxs("div", { className: "flex justify-between items-center", children: [
+      /* @__PURE__ */ jsx("div", { className: "text-sm text-gray-600 dark:text-gray-300", children: /* @__PURE__ */ jsxs("div", { className: "flex space-x-4", children: [
+        /* @__PURE__ */ jsxs("span", { children: [
+          "Duration: ",
+          formatDuration(recordingDuration)
+        ] }),
+        /* @__PURE__ */ jsxs("span", { children: [
+          "Chunks: ",
+          totalChunks
+        ] }),
+        /* @__PURE__ */ jsxs("span", { children: [
+          "Format: ",
+          format.toUpperCase()
+        ] }),
+        silenceRemoval && /* @__PURE__ */ jsx("span", { children: "Silence Removal: ON" })
+      ] }) }),
+      showDownload && lastAudioFile && /* @__PURE__ */ jsxs(
+        "button",
+        {
+          onClick: handleDownload,
+          className: "flex items-center space-x-1 bg-blue-600 hover:bg-blue-700 text-white px-3 py-1 rounded text-sm transition-colors",
+          children: [
+            /* @__PURE__ */ jsx(Download, { className: "h-3 w-3" }),
+            /* @__PURE__ */ jsx("span", { children: "Download" })
+          ]
+        }
+      )
+    ] }) }),
+    (isProcessing || isConverting) && /* @__PURE__ */ jsxs("div", { className: "flex items-center justify-center space-x-2 bg-blue-50 dark:bg-blue-900/20 border border-blue-200 dark:border-blue-800 rounded-lg p-4", children: [
+      /* @__PURE__ */ jsx(Loader2, { className: "animate-spin h-5 w-5 text-blue-600" }),
+      /* @__PURE__ */ jsxs("div", { className: "text-center", children: [
+        /* @__PURE__ */ jsx("span", { className: "block text-sm font-medium text-blue-700 dark:text-blue-300", children: isConverting ? `Processing Audio... ${Math.round(progress)}%` : "Processing audio chunk..." }),
+        statusMessage && /* @__PURE__ */ jsx("span", { className: "block text-xs text-blue-600 dark:text-blue-400 mt-1", children: statusMessage })
+      ] })
+    ] }),
+    isRecording && !isPaused && mediaStreamRef.current && /* @__PURE__ */ jsxs(
+      "div",
+      {
+        className: `audio-recorder-container ${isRecording && !isPaused ? "glow-active" : ""}`,
+        children: [
+          /* @__PURE__ */ jsxs("div", { className: "edge-container", children: [
+            /* @__PURE__ */ jsx("div", { className: "edge edge-top" }),
+            /* @__PURE__ */ jsx("div", { className: "edge edge-right" }),
+            /* @__PURE__ */ jsx("div", { className: "edge edge-bottom" }),
+            /* @__PURE__ */ jsx("div", { className: "edge edge-left" })
+          ] }),
+          /* @__PURE__ */ jsx("div", { className: "flex justify-center items-center", children: /* @__PURE__ */ jsx(
+            AudioVisualizerImproved,
+            {
+              mediaStream: mediaStreamRef.current,
+              isRecording: isRecording && !isPaused,
+              forceLight: false
+            }
+          ) })
+        ]
+      }
+    ),
+    /* @__PURE__ */ jsx("div", { className: "flex justify-center", children: isProcessing ? /* @__PURE__ */ jsxs("div", { className: "flex items-center justify-center space-x-2 bg-teal-600 hover:bg-teal-700 text-white py-2 px-4 rounded-full", children: [
+      /* @__PURE__ */ jsx(Loader2, { className: "animate-spin h-5 w-5" }),
+      /* @__PURE__ */ jsx("span", { children: "Processing..." })
+    ] }) : isRecording || isPaused ? /* @__PURE__ */ jsxs("div", { className: "flex space-x-2", children: [
+      /* @__PURE__ */ jsxs(
+        "button",
+        {
+          className: `flex items-center justify-center space-x-2 bg-red-600 hover:bg-red-700 text-white py-2 px-4 rounded-full transition-colors ${isDisabled ? "opacity-50 cursor-not-allowed" : ""}`,
+          onClick: handleStopClick,
+          disabled: isDisabled,
+          children: [
+            /* @__PURE__ */ jsx(Square, { className: "h-5 w-5" }),
+            /* @__PURE__ */ jsx("span", { children: "Stop" })
+          ]
+        }
+      ),
+      !isPaused ? /* @__PURE__ */ jsxs(
+        "button",
+        {
+          className: "flex items-center justify-center space-x-2 bg-yellow-500 hover:bg-yellow-600 text-white py-2 px-4 rounded-full transition-colors",
+          onClick: pauseRecording,
+          children: [
+            /* @__PURE__ */ jsx(Pause, { className: "h-5 w-5" }),
+            /* @__PURE__ */ jsx("span", { children: "Pause" })
+          ]
+        }
+      ) : /* @__PURE__ */ jsxs(
+        "button",
+        {
+          className: "flex items-center justify-center space-x-2 bg-green-600 hover:bg-green-700 text-white py-2 px-4 rounded-full transition-colors",
+          onClick: resumeRecording,
+          children: [
+            /* @__PURE__ */ jsx(Play, { className: "h-5 w-5" }),
+            /* @__PURE__ */ jsx("span", { children: "Resume" })
+          ]
+        }
+      )
+    ] }) : /* @__PURE__ */ jsxs(
+      "button",
+      {
+        className: className ? `flex items-center justify-center space-x-2 py-2 px-4 rounded-full transition-colors ${className}` : "flex items-center justify-center space-x-2 bg-gradient-to-r from-purple-400 to-blue-500 hover:bg-gradient-to-r hover:from-purple-500 hover:to-blue-600 text-white py-2 px-4 rounded-full transition-colors",
+        onClick: handleStartRecording,
+        children: [
+          /* @__PURE__ */ jsx(Mic, { className: "h-5 w-5" }),
+          /* @__PURE__ */ jsx("span", { children: "Start Recording" })
+        ]
+      }
+    ) }),
+    availableDevices.length > 1 && /* @__PURE__ */ jsxs("div", { className: "mt-4", children: [
+      /* @__PURE__ */ jsx("label", { className: "block text-sm font-medium text-gray-700 dark:text-gray-300 mb-2", children: "Select Microphone:" }),
+      /* @__PURE__ */ jsx(
+        "select",
+        {
+          value: currentDeviceId || "",
+          onChange: (e) => selectMicrophone(e.target.value),
+          className: "w-full p-2 border border-gray-200 dark:border-gray-700 rounded bg-white dark:bg-gray-800 text-gray-900 dark:text-gray-100",
+          disabled: isRecording,
+          children: availableDevices.map((device) => /* @__PURE__ */ jsx("option", { value: device.deviceId, children: device.label || `Microphone ${device.deviceId.slice(0, 8)}` }, device.deviceId))
+        }
+      )
+    ] })
+  ] });
+};
+var AudioCapture_default = AudioCapture;
 
-export { AudioDictation_default as AudioDictation, AudioRecorder_default as AudioRecorder };
+export { AudioCapture_default as AudioCapture, AudioDictation_default as AudioDictation, AudioRecorder_default as AudioRecorder };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map