sera-ai 1.0.11 → 1.0.13

package/dist/index.js

@@ -2670,7 +2670,6 @@ var createAudioProcessorWorker = () => {
         this._recordingStartTime = Date.now();
         this._initialSilenceThreshold = 44100 * 10;
         this._isInitialPhase = true;
-        this._audioActivityBuffer = []; // Track recent audio activity
         this._bufferSize = 0; // Track total samples in buffer
 
         this.port.onmessage = (event) => {
@@ -2765,12 +2764,6 @@ var createAudioProcessorWorker = () => {
             this._isInitialPhase = false;
             this._silentSampleCount = 0;
             this._lastAudioTime = Date.now();
-            
-            // Track audio activity for chunk validation
-            this._audioActivityBuffer.push(audioLevel);
-            if (this._audioActivityBuffer.length > 1000) {
-              this._audioActivityBuffer.shift(); // Keep only recent activity
-            }
           } else {
             this._silentSampleCount += samples.length;
             
@@ -2795,43 +2788,36 @@ var createAudioProcessorWorker = () => {
 
           if (this._uploadChunk && !this._uploadingChunk) {
             this._uploadingChunk = true;
-            
-            // Check if buffer has meaningful audio content before uploading
-            const recentActivity = this._audioActivityBuffer.slice(-100); // Last 100 activity measurements
-            const hasRecentAudio = recentActivity.some(level => level > this._audioThreshold * 2);
-            
+
             // Properly flatten the buffer by concatenating Float32Arrays
             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;
             }
-            
-            // Only upload if we have recent audio activity or if this is a significant buffer
-            if (hasRecentAudio || this._bufferSize > 44100 * 30) { // 30 seconds minimum
+
+            // Always send chunks to server - let server handle silence filtering
+            if (this._bufferSize > 0) {
               this.port.postMessage(
                 {
                   command: "chunk",
                   audioBuffer: flat.buffer,
-                  hasActivity: hasRecentAudio,
                   bufferDuration: this._bufferSize / 44100
                 },
                 [flat.buffer]
               );
-              // Clear buffer after successful upload
+              console.log('[UPLOAD] Sending chunk: ' + (this._bufferSize / 44100).toFixed(1) + 's');
+              // Clear buffer after upload
               this._buffer = [];
               this._bufferSize = 0;
-            } else {
-              console.log('[SKIP] Skipping silent chunk upload (' + (this._bufferSize / 44100).toFixed(1) + 's, no recent activity)');
-              // Don't clear buffer for skipped chunks, keep accumulating
             }
-            
+
             this._uploadChunk = false;
             this._uploadingChunk = false;
           }
@@ -3098,11 +3084,14 @@ var useAudioRecorder = ({
       processorRef.current?.port.postMessage({ command: "resetUploadChunk" });
       if (audioData && localSessionIdRef.current && !retry) {
         try {
+          console.log(`[DB] Saving chunk ${sequence} to IndexedDB session ${localSessionIdRef.current}`);
           await appendAudioToSession(localSessionIdRef.current, audioData, sequence);
-          console.log(`[SUCCESS] Successfully saved audio chunk ${sequence} to local session`);
+          console.log(`[DB] \u2713 Successfully saved audio chunk ${sequence} to IndexedDB (${audioData.length} samples)`);
         } catch (error2) {
-          console.error(`[ERROR] Failed to save audio to local session:`, error2);
+          console.error(`[DB] \u2717 Failed to save audio chunk ${sequence} to IndexedDB:`, error2);
         }
+      } else {
+        console.log(`[DB] Skipping IndexedDB save: audioData=${!!audioData}, sessionId=${localSessionIdRef.current}, retry=${retry}`);
       }
       try {
         const data = await pRetry__default.default(
@@ -3119,37 +3108,19 @@ var useAudioRecorder = ({
             console.log(
               `[PROCESSING] Processing audio chunk: ${audioData.length} samples (${(audioData.length / 44100).toFixed(2)}s)`
             );
-            let hasAudio = false;
             let maxAmplitude = 0;
             let nonZeroSamples = 0;
             for (let i = 0; i < audioData.length; i++) {
               const amplitude = Math.abs(audioData[i]);
               if (amplitude > maxAmplitude) maxAmplitude = amplitude;
               if (amplitude > 1e-3) {
-                hasAudio = true;
                 nonZeroSamples++;
               }
             }
             const audioPercentage = nonZeroSamples / audioData.length;
             console.log(
-              `[AUDIO] Audio validation: hasAudio=${hasAudio}, maxAmplitude=${maxAmplitude.toFixed(4)}, audioContent=${(audioPercentage * 100).toFixed(2)}%`
+              `[AUDIO] Audio stats: maxAmplitude=${maxAmplitude.toFixed(4)}, audioContent=${(audioPercentage * 100).toFixed(2)}%, sequence=${sequence}, isFinal=${isFinalChunk}`
             );
-            if (!hasAudio || maxAmplitude < 1e-3 || audioPercentage < 0.01) {
-              console.log(
-                `[SKIP] Skipping silent chunk (${audioPercentage < 0.01 ? "too little audio content" : "completely silent"})`
-              );
-              if (!isFinalChunk) {
-                console.log(`[OUT] Non-final silent chunk skipped entirely`);
-                return;
-              } else {
-                console.log(`[OUT] Final silent chunk - will send minimal audio to close session`);
-                const minimalAudio = new Float32Array(1e3);
-                for (let i = 0; i < minimalAudio.length; i += 100) {
-                  minimalAudio[i] = 1e-3;
-                }
-                audioData = minimalAudio;
-              }
-            }
             const sampleRate = audioContextRef.current?.sampleRate || 16e3;
             const timestamp = Date.now();
             const fileName = `audio-chunk-${timestamp}.wav`;
@@ -3186,11 +3157,8 @@ var useAudioRecorder = ({
               `[OUT] Final file for transcription: ${wavFile.size} bytes, ${wavFile.name}`
             );
             if (wavFile.size < 500) {
-              console.error(
-                `[ERROR] File too small (${wavFile.size} bytes) - likely contains no audio data`
-              );
-              throw new Error(
-                `Audio file too small (${wavFile.size} bytes) - no meaningful audio content`
+              console.warn(
+                `[WARN] Small audio file (${wavFile.size} bytes) - may contain minimal audio data, sending to server anyway`
               );
             }
             const requestData = {
@@ -3516,16 +3484,19 @@ var useAudioRecorder = ({
           totalRecordingTime,
           lastAudioTime
         } = event.data;
-        const sequence = sequenceCounterRef.current++;
         if (command === "finalChunk" && audioBuffer) {
+          const sequence = sequenceCounterRef.current++;
           const audioArray = new Float32Array(audioBuffer);
-          console.log(`Received final chunk: ${audioArray.length} samples`);
+          console.log(`[RECEIVE] Final chunk: ${audioArray.length} samples, sequence: ${sequence}`);
           enqueueChunk(audioArray, true, sequence);
-        } else if (command === "uploadChunk" && audioBuffer) {
+        } else if (command === "chunk" && audioBuffer) {
+          const sequence = sequenceCounterRef.current++;
           const audioArray = new Float32Array(audioBuffer);
+          console.log(`[RECEIVE] Chunk: ${audioArray.length} samples, sequence: ${sequence}`);
           enqueueChunk(audioArray, false, sequence);
         } else if (command === "pauseChunk" && audioBuffer) {
-          console.log("Received pauseChunk with audioBuffer", audioBuffer);
+          const sequence = sequenceCounterRef.current++;
+          console.log(`[RECEIVE] Pause chunk with audioBuffer, sequence: ${sequence}`);
           enqueueChunk(new Float32Array(audioBuffer), false, sequence, true);
         } else if (command === "audioLevel") {
           setAudioLevel(level);
@@ -3679,16 +3650,18 @@ var useAudioRecorder = ({
   const processNextChunkInQueue = React3__namespace.default.useCallback(() => {
     if (isProcessingQueueRef.current || chunkQueueRef.current.length === 0) return;
     const { chunk, isFinal, sequence, isPaused: isPaused2 = false } = chunkQueueRef.current.shift();
+    console.log(`[QUEUE] Processing chunk ${sequence} from queue, remaining: ${chunkQueueRef.current.length}`);
     isProcessingQueueRef.current = true;
     uploadChunkToServer(chunk, isFinal, sequence, false, isPaused2).finally(() => {
+      console.log(`[QUEUE] Finished processing chunk ${sequence}`);
       isProcessingQueueRef.current = false;
       processNextChunkInQueue();
     });
   }, [uploadChunkToServer, isLoaded]);
   const enqueueChunk = React3__namespace.default.useCallback(
     (audioData, isFinalChunk, sequence, isPausedChunk = false) => {
+      console.log(`[QUEUE] Enqueuing ${isFinalChunk ? "FINAL" : isPausedChunk ? "PAUSED" : "regular"} chunk ${sequence}, samples: ${audioData?.length || 0}, queue size: ${chunkQueueRef.current.length}`);
       if (isFinalChunk) {
-        console.log("Enqueuing final chunk:", sequence);
         setIsProcessing(true);
       }
       chunkQueueRef.current.push({