sera-ai 1.0.28 → 1.0.30

package/dist/index.js

@@ -151,12 +151,12 @@ var useFFmpegConverter = () => {
   const [statusMessage, setStatusMessage] = React3.useState("");
   const loadFFmpeg = React3.useCallback(async () => {
     if (ffmpegInstance) {
-      console.log("[FFmpeg] Already loaded, skipping");
+      console.log("[SERA] FFmpeg already loaded, skipping");
       setFfmpegLoaded(true);
       return true;
     }
     if (ffmpegLoadingPromise) {
-      console.log("[FFmpeg] Already loading, waiting for existing promise");
+      console.log("[SERA] FFmpeg already loading, waiting for existing promise");
       const result = await ffmpegLoadingPromise;
       if (result) {
         setFfmpegLoaded(true);
@@ -166,7 +166,7 @@ var useFFmpegConverter = () => {
     ffmpegLoadingPromise = (async () => {
       try {
         const cdnCorePath = "https://unpkg.com/@ffmpeg/core@0.11.0/dist/ffmpeg-core.js";
-        console.log("[FFmpeg] Loading from CDN:", cdnCorePath);
+        console.log(`[SERA] FFmpeg loading from CDN | corePath=${cdnCorePath}`);
         setStatusMessage("Loading FFmpeg...");
         const ffmpeg$1 = ffmpeg.createFFmpeg({
           log: false,
@@ -180,10 +180,10 @@ var useFFmpegConverter = () => {
         setFfmpegLoaded(true);
         setIsLoaded(true);
         setStatusMessage("");
-        console.log("[FFmpeg] WASM loaded successfully from CDN");
+        console.log("[SERA] FFmpeg WASM loaded successfully from CDN");
         return true;
       } catch (err) {
-        console.error("Failed to load FFmpeg:", err);
+        console.error("[SERA] FFmpeg loading failed:", err);
         setError("Failed to load FFmpeg");
         setStatusMessage("");
         ffmpegLoadingPromise = null;
@@ -253,13 +253,13 @@ var useFFmpegConverter = () => {
       if (!ffmpegInstance || !ffmpegLoaded) {
         const loaded = await loadFFmpeg();
         if (!loaded) {
-          console.error("Failed to load FFmpeg for FLAC conversion");
+          console.error("[SERA] FFmpeg loading failed for FLAC conversion");
           return wavFile;
         }
       }
       const ffmpeg$1 = ffmpegInstance;
       if (!ffmpeg$1) {
-        console.error("FFmpeg not available");
+        console.error("[SERA] FFmpeg not available for FLAC conversion");
         return wavFile;
       }
       try {
@@ -293,7 +293,7 @@ var useFFmpegConverter = () => {
         const flacFile = new File([flacBlob], flacFileName, { type: "audio/flac" });
         setProgress(100);
         setStatusMessage("FLAC conversion complete");
-        console.log(`[FLAC] Converted ${wavFile.size} bytes WAV to ${flacFile.size} bytes FLAC (${Math.round((1 - flacFile.size / wavFile.size) * 100)}% reduction)`);
+        console.log(`[SERA] FLAC conversion complete | inputSize=${wavFile.size}, outputSize=${flacFile.size}, reduction=${Math.round((1 - flacFile.size / wavFile.size) * 100)}%`);
         setTimeout(() => {
           setIsConverting(false);
           setProgress(0);
@@ -301,7 +301,7 @@ var useFFmpegConverter = () => {
         }, 500);
         return flacFile;
       } catch (err) {
-        console.error("FLAC conversion failed:", err);
+        console.error("[SERA] FLAC conversion failed:", err);
         setError("FLAC conversion failed");
         setIsConverting(false);
         setProgress(0);
@@ -318,7 +318,7 @@ var useFFmpegConverter = () => {
     }
     const maxFileSize = 50 * 1024 * 1024;
     if (file.size > maxFileSize) {
-      console.warn(`[SILENCE] File too large (${file.size} bytes), skipping silence removal`);
+      console.warn(`[SERA] Silence removal skipped, file too large | size=${file.size}`);
       return file;
     }
     try {
@@ -326,12 +326,12 @@ var useFFmpegConverter = () => {
       setError(null);
       setProgress(0);
       setStatusMessage("Removing silence...");
-      console.log(`[SILENCE] Processing file: ${file.size} bytes, name: ${file.name}`);
+      console.log(`[SERA] Silence removal started | size=${file.size}, name=${file.name}`);
       if (!ffmpegInstance) {
         setStatusMessage("Loading FFmpeg for silence removal...");
         const loaded = await loadFFmpeg();
         if (!loaded || !ffmpegInstance) {
-          console.error("[SILENCE] Failed to load FFmpeg");
+          console.error("[SERA] FFmpeg loading failed for silence removal");
           setIsConverting(false);
           setProgress(0);
           setStatusMessage("");
@@ -345,7 +345,7 @@ var useFFmpegConverter = () => {
       const wavData = await ffmpeg.fetchFile(file);
       ffmpegInstance.FS("writeFile", inputFileName, wavData);
       const originalSize = file.size;
-      console.log(`[SILENCE] Input file written: ${originalSize} bytes`);
+      console.log(`[SERA] Silence removal input written | size=${originalSize}`);
       setProgress(30);
       setStatusMessage("Analyzing and removing silence...");
       await ffmpegInstance.run(
@@ -364,11 +364,11 @@ var useFFmpegConverter = () => {
         ffmpegInstance.FS("unlink", inputFileName);
         ffmpegInstance.FS("unlink", outputFileName);
       } catch (cleanupErr) {
-        console.warn("[SILENCE] Cleanup warning:", cleanupErr);
+        console.warn("[SERA] Silence removal cleanup warning:", cleanupErr);
       }
       const processedSize = outputData.length;
       const reductionPercent = Math.round((1 - processedSize / originalSize) * 100);
-      console.log(`[SILENCE] Complete: ${originalSize} bytes -> ${processedSize} bytes (${reductionPercent}% reduction)`);
+      console.log(`[SERA] Silence removal complete | inputSize=${originalSize}, outputSize=${processedSize}, reduction=${reductionPercent}%`);
       const processedFile = new File(
         [new Uint8Array(outputData)],
         file.name,
@@ -383,7 +383,7 @@ var useFFmpegConverter = () => {
       }, 500);
       return processedFile;
     } catch (err) {
-      console.error("[SILENCE] FFmpeg silence removal failed:", err);
+      console.error("[SERA] Silence removal failed:", err);
       setError("Silence removal failed");
       setIsConverting(false);
       setProgress(0);
@@ -422,7 +422,7 @@ var useAudioRecovery = (reprocessSession) => {
   const DB_VERSION = 1;
   const createAudioEncodingWorker = () => {
     const workerCode = `
-      console.log("Audio encoding worker loaded");
+      console.log("[SERA] Audio encoding worker loaded");
 
       self.onmessage = function (e) {
         const { command, data, id } = e.data;
@@ -441,11 +441,7 @@ var useAudioRecovery = (reprocessSession) => {
               const float32Array =
                 audioData instanceof Float32Array ? audioData : new Float32Array(audioData);
 
-              console.log("Worker encoding audio:", {
-                length: float32Array.length,
-                firstSamples: Array.from(float32Array.slice(0, 10)),
-                hasValidData: Array.from(float32Array).some((sample) => sample !== 0),
-              });
+              console.log("[SERA] Worker encoding audio | samples=" + float32Array.length);
 
               const buffer = new ArrayBuffer(float32Array.length * 4);
               const view = new Float32Array(buffer);
@@ -499,11 +495,7 @@ var useAudioRecovery = (reprocessSession) => {
 
                 const float32Result = new Float32Array(bytes.buffer);
 
-                console.log("Worker decoded audio:", {
-                  length: float32Result.length,
-                  firstSamples: Array.from(float32Result.slice(0, 10)),
-                  hasValidData: Array.from(float32Result).some((sample) => sample !== 0),
-                });
+                console.log("[SERA] Worker decoded audio | samples=" + float32Result.length);
 
                 self.postMessage({
                   type: "complete",
@@ -528,7 +520,7 @@ var useAudioRecovery = (reprocessSession) => {
               });
           }
         } catch (error) {
-          console.error("Worker error:", error);
+          console.error("[SERA] Audio encoding worker error:", error);
           self.postMessage({
             type: "error",
             id,
@@ -539,7 +531,7 @@ var useAudioRecovery = (reprocessSession) => {
       };
 
       self.onerror = function (error) {
-        console.error("Worker script error:", error);
+        console.error("[SERA] Audio encoding worker script error:", error);
         self.postMessage({
           type: "error",
           error: error.message || "Unknown worker error",
@@ -559,7 +551,7 @@ var useAudioRecovery = (reprocessSession) => {
           const { type, id, result, error, progress, message } = e.data;
           const operation = pendingOperations.current.get(id);
           if (!operation) {
-            console.warn(`No pending operation found for id: ${id}`);
+            console.warn(`[SERA] No pending worker operation found | id=${id}`);
             return;
           }
           switch (type) {
@@ -576,16 +568,16 @@ var useAudioRecovery = (reprocessSession) => {
           }
         };
         workerRef.current.onerror = (error) => {
-          console.error("Audio encoding worker error:", error);
+          console.error("[SERA] Audio encoding worker error:", error);
           for (const [id, operation] of pendingOperations.current) {
             operation.reject(new Error("Worker crashed"));
           }
           pendingOperations.current.clear();
           workerRef.current = null;
         };
-        console.log("\u{1F3B5} Audio encoding worker initialized");
+        console.log("[SERA] Audio encoding worker initialized");
       } catch (error) {
-        console.error("Failed to initialize audio encoding worker:", error);
+        console.error("[SERA] Audio encoding worker initialization failed:", error);
         workerRef.current = null;
       }
     }
@@ -595,7 +587,7 @@ var useAudioRecovery = (reprocessSession) => {
     async (audioData) => {
       const worker = initWorker();
       if (!worker) {
-        console.warn("Worker not available, falling back to main thread encoding");
+        console.warn("[SERA] Worker not available, falling back to main thread encoding");
         return float32ArrayToBase64(audioData);
       }
       const operationId = `encode_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
@@ -635,7 +627,7 @@ var useAudioRecovery = (reprocessSession) => {
     async (base64Data) => {
       const worker = initWorker();
       if (!worker) {
-        console.warn("Worker not available, falling back to main thread decoding");
+        console.warn("[SERA] Worker not available, falling back to main thread decoding");
         return base64ToFloat32Array(base64Data);
       }
       const operationId = `decode_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
@@ -677,7 +669,7 @@ var useAudioRecovery = (reprocessSession) => {
     return new Promise((resolve, reject) => {
       const request = indexedDB.open(DB_NAME, DB_VERSION);
       request.onerror = () => {
-        console.error("Failed to open IndexedDB:", request.error);
+        console.error("[SERA] Failed to open IndexedDB:", request.error);
         reject(request.error);
       };
       request.onsuccess = () => {
@@ -735,16 +727,16 @@ var useAudioRecovery = (reprocessSession) => {
         await new Promise((resolve, reject) => {
           const request = store.add(session);
           request.onsuccess = () => {
-            console.log(`Created audio session ${sessionId}`);
+            console.log(`[SERA] Audio session created | sessionId=${sessionId}`);
             resolve();
           };
           request.onerror = () => {
-            console.error("Failed to create session:", request.error);
+            console.error("[SERA] Failed to create audio session:", request.error);
             reject(request.error);
           };
         });
       } catch (error) {
-        console.error("Error creating session:", error);
+        console.error("[SERA] Error creating audio session:", error);
         throw error;
       }
     },
@@ -785,7 +777,7 @@ var useAudioRecovery = (reprocessSession) => {
           getRequest.onerror = () => reject(getRequest.error);
         });
       } catch (error) {
-        console.error(`Failed to append chunk ${sequence}:`, error);
+        console.error(`[SERA] Failed to append audio chunk | sequence=${sequence}:`, error);
       }
     },
     [initDB, encodeInWorker]
@@ -804,26 +796,24 @@ var useAudioRecovery = (reprocessSession) => {
         if (!session) return false;
         const audioChunks = [];
         const chunkIndices = Object.keys(session.audioChunks).map(Number).sort((a, b) => a - b);
-        console.log(
-          `Found ${chunkIndices.length} chunks with indices: ${chunkIndices.slice(0, 10)}...`
-        );
+        console.log(`[SERA] Retrying session | sessionId=${sessionId}, chunks=${chunkIndices.length}`);
         for (const index of chunkIndices) {
           try {
             const base64Data = session.audioChunks[index];
             const float32Array = await decodeInWorker(base64Data);
             audioChunks.push(float32Array);
           } catch (error) {
-            console.error(`Failed to decode chunk ${index}:`, error);
+            console.error(`[SERA] Failed to decode audio chunk | index=${index}:`, error);
           }
         }
         if (audioChunks.length === 0) {
-          console.error("No valid chunks found");
+          console.error("[SERA] No valid audio chunks found for retry");
           return false;
         }
         await reprocessSession(audioChunks, session.metadata);
         return true;
       } catch (error) {
-        console.error("Retry failed:", error);
+        console.error("[SERA] Session retry failed:", error);
         return false;
       }
     },
@@ -838,16 +828,16 @@ var useAudioRecovery = (reprocessSession) => {
         await new Promise((resolve, reject) => {
           const request = store.delete(sessionId);
           request.onsuccess = () => {
-            console.log(`Deleted completed session ${sessionId}`);
+            console.log(`[SERA] Deleted completed session | sessionId=${sessionId}`);
             resolve();
           };
           request.onerror = () => {
-            console.error("Failed to delete session:", request.error);
+            console.error("[SERA] Failed to delete session:", request.error);
             reject(request.error);
           };
         });
       } catch (error) {
-        console.error("Error marking session complete:", error);
+        console.error("[SERA] Error marking session complete:", error);
         throw error;
       }
     },
@@ -871,7 +861,7 @@ var useAudioRecovery = (reprocessSession) => {
             session.lastError = error;
             const updateRequest = store.put(session);
             updateRequest.onsuccess = () => {
-              console.log(`Marked session ${sessionId} as failed`);
+              console.log(`[SERA] Session marked as failed | sessionId=${sessionId}`);
               resolve();
             };
             updateRequest.onerror = () => reject(updateRequest.error);
@@ -879,7 +869,7 @@ var useAudioRecovery = (reprocessSession) => {
           getRequest.onerror = () => reject(getRequest.error);
         });
       } catch (error2) {
-        console.error("Error marking session failed:", error2);
+        console.error("[SERA] Error marking session failed:", error2);
         throw error2;
       }
     },
@@ -894,16 +884,16 @@ var useAudioRecovery = (reprocessSession) => {
         await new Promise((resolve, reject) => {
           const request = store.delete(sessionId);
           request.onsuccess = () => {
-            console.log(`Deleted session ${sessionId}`);
+            console.log(`[SERA] Deleted session | sessionId=${sessionId}`);
             resolve();
           };
           request.onerror = () => {
-            console.error("Failed to delete session:", request.error);
+            console.error("[SERA] Failed to delete session:", request.error);
             reject(request.error);
           };
         });
       } catch (error) {
-        console.error("Error deleting session:", error);
+        console.error("[SERA] Error deleting session:", error);
         throw error;
       }
     },
@@ -921,12 +911,12 @@ var useAudioRecovery = (reprocessSession) => {
           resolve(request.result[0]);
         };
         request.onerror = () => {
-          console.error("Failed to get failed sessions:", request.error);
+          console.error("[SERA] Failed to get failed sessions:", request.error);
           reject(request.error);
         };
       });
     } catch (error) {
-      console.error("Error getting failed sessions:", error);
+      console.error("[SERA] Error getting failed sessions:", error);
       return null;
     }
   }, [initDB]);
@@ -942,22 +932,22 @@ var useAudioRecovery = (reprocessSession) => {
       await new Promise((resolve, reject) => {
         const request = store.clear();
         request.onsuccess = () => {
-          console.log("Cleared all audio sessions");
+          console.log("[SERA] Cleared all audio sessions");
           resolve();
         };
         request.onerror = () => {
-          console.error("Failed to clear sessions:", request.error);
+          console.error("[SERA] Failed to clear sessions:", request.error);
           reject(request.error);
         };
       });
     } catch (error) {
-      console.error("Error clearing sessions:", error);
+      console.error("[SERA] Error clearing sessions:", error);
       throw error;
     }
   }, [initDB]);
   const cleanup = React3.useCallback(() => {
     if (workerRef.current) {
-      console.log("\u{1F9F9} Cleaning up audio encoding worker");
+      console.log("[SERA] Cleaning up audio encoding worker");
       workerRef.current.terminate();
       workerRef.current = null;
     }
@@ -1089,7 +1079,7 @@ var useHL7FHIRConverter = () => {
         let sessionId = "";
         let metadata = {};
         let speciality = "";
-        console.log("Parsing HL7 transcription segments:", segments);
+        console.log(`[SERA] Parsing HL7 transcription | segments=${segments.length}`);
         for (const segment of segments) {
           switch (segment.type) {
             case "MSH":
@@ -1131,7 +1121,7 @@ var useHL7FHIRConverter = () => {
                     const parsedClassification = JSON.parse(classificationJson);
                     Object.assign(classifiedInfo, parsedClassification);
                   } catch (e) {
-                    console.error("Failed to parse classification JSON:", e);
+                    console.error("[SERA] Failed to parse HL7 classification JSON:", e);
                   }
                 }
               }
@@ -1182,7 +1172,7 @@ var useHL7FHIRConverter = () => {
           }
         };
       } catch (error) {
-        console.error("HL7 transcription conversion error:", error);
+        console.error("[SERA] HL7 transcription conversion error:", error);
         throw new Error(
           `Failed to convert HL7 transcription data: ${error instanceof Error ? error.message : "Unknown error"}`
         );
@@ -1195,7 +1185,7 @@ var useHL7FHIRConverter = () => {
       try {
         const segments = parseHL7(hl7Data);
         const specialities = [];
-        console.log("Parsing HL7 specialities segments:", segments);
+        console.log(`[SERA] Parsing HL7 specialities | segments=${segments.length}`);
         let currentSpeciality = null;
         for (const segment of segments) {
           switch (segment.type) {
@@ -1237,7 +1227,7 @@ var useHL7FHIRConverter = () => {
                       specialities.push(specialityData);
                     }
                   } catch (e) {
-                    console.error("Failed to parse legacy specialities JSON data:", e);
+                    console.error("[SERA] Failed to parse legacy specialities JSON data:", e);
                   }
                 }
               }
@@ -1250,10 +1240,10 @@ var useHL7FHIRConverter = () => {
           }
           specialities.push(currentSpeciality);
         }
-        console.log("Parsed specialities:", specialities);
+        console.log(`[SERA] Parsed specialities | count=${specialities.length}`);
         return { specialities };
       } catch (error) {
-        console.error("HL7 specialities conversion error:", error);
+        console.error("[SERA] HL7 specialities conversion error:", error);
         throw new Error(
           `Failed to convert HL7 specialities data: ${error instanceof Error ? error.message : "Unknown error"}`
         );
@@ -1300,8 +1290,7 @@ var useHL7FHIRConverter = () => {
                   classification = conclusionData.classifiedInfo;
                 }
               } catch (parseError) {
-                console.error("\u274C Failed to parse DiagnosticReport conclusion:", parseError);
-                console.log("Raw conclusion:", resource.conclusion);
+                console.error("[SERA] Failed to parse DiagnosticReport conclusion:", parseError);
                 if (!classification["Clinical Summary"]) {
                   classification["Clinical Summary"] = [];
                 }
@@ -1320,16 +1309,13 @@ var useHL7FHIRConverter = () => {
             break;
           case "Composition":
             if (resource.section && Array.isArray(resource.section) && resource.section.length > 0) {
-              console.log(`\u{1F4C4} Processing ${resource.section.length} sections...`);
+              console.log(`[SERA] Processing FHIR Composition | sections=${resource.section.length}`);
               for (const section of resource.section) {
                 if (section.title === "Transcription" && section.text?.div) {
                   const textContent = section.text.div.replace(/<[^>]*>/g, "");
                   transcription += (transcription ? "\n" : "") + textContent;
-                  console.log(`\u2705 Extracted transcription text (${textContent.length} chars)`);
+                  console.log(`[SERA] Extracted transcription text | chars=${textContent.length}`);
                 } else if (section.title === "Medical Classification") {
-                  console.log(
-                    "\u2139\uFE0F Skipping Medical Classification section (handled by DiagnosticReport)"
-                  );
                 }
               }
             } else if (resource.text?.div) {
@@ -1338,10 +1324,8 @@ var useHL7FHIRConverter = () => {
             }
             if (resource.identifier) {
               const identifiers = Array.isArray(resource.identifier) ? resource.identifier : [resource.identifier];
-              console.log(`\u{1F4CB} Found ${identifiers.length} identifier(s)`);
               for (let j = 0; j < identifiers.length; j++) {
                 const identifier = identifiers[j];
-                console.log(`  [${j}] system: ${identifier.system}, value: ${identifier.value}`);
                 if (identifier.system === "http://nuxera.ai/session-identifier" && identifier.value) {
                   sessionId = identifier.value;
                   break;
@@ -1350,10 +1334,7 @@ var useHL7FHIRConverter = () => {
             }
             if (!sessionId && resource.id) {
               sessionId = resource.id;
-              console.log(
-                "\u26A0\uFE0F [Priority 2] Using Composition.id as fallback session ID:",
-                sessionId
-              );
+              console.log(`[SERA] Using Composition.id as fallback sessionId | sessionId=${sessionId}`);
             }
             break;
           case "Task":
@@ -1361,10 +1342,7 @@ var useHL7FHIRConverter = () => {
               for (const identifier of resource.identifier) {
                 if (identifier.system === "http://nuxera.ai/session-id" && identifier.value) {
                   sessionId = identifier.value;
-                  console.log(
-                    "\u2705 [Priority 3] Extracted session ID from Task.identifier:",
-                    sessionId
-                  );
+                  console.log(`[SERA] Extracted sessionId from Task.identifier | sessionId=${sessionId}`);
                   break;
                 }
               }
@@ -1374,15 +1352,15 @@ var useHL7FHIRConverter = () => {
       }
       if (!sessionId && fhirData.resourceType === "Bundle" && fhirData.identifier?.value) {
         sessionId = fhirData.identifier.value;
-        console.log("\u26A0\uFE0F [Priority 4] Using Bundle.identifier as last resort:", sessionId);
+        console.log(`[SERA] Using Bundle.identifier as fallback sessionId | sessionId=${sessionId}`);
       }
       if (!sessionId && fhirData.resourceType === "Bundle" && fhirData.id) {
         sessionId = fhirData.id;
-        console.log("\u26A0\uFE0F [Priority 5] Using Bundle.id as absolute last resort:", sessionId);
+        console.log(`[SERA] Using Bundle.id as fallback sessionId | sessionId=${sessionId}`);
       }
       if (!sessionId) {
         sessionId = `session_${Date.now()}`;
-        console.warn("\u26A0\uFE0F\u26A0\uFE0F No session ID found in FHIR response, generated:", sessionId);
+        console.warn(`[SERA] No sessionId found in FHIR response, generated | sessionId=${sessionId}`);
       }
       return {
         transcription: transcription || "No transcription found in FHIR data",
@@ -1395,7 +1373,7 @@ var useHL7FHIRConverter = () => {
         }
       };
     } catch (error) {
-      console.error("\u274C FHIR transcription conversion error:", error);
+      console.error("[SERA] FHIR transcription conversion error:", error);
       throw new Error(
         `Failed to convert FHIR transcription data: ${error instanceof Error ? error.message : "Unknown error"}`
       );
@@ -1441,7 +1419,7 @@ var useHL7FHIRConverter = () => {
       } catch (error) {
         const errorMessage = error instanceof Error ? error.message : "Unknown conversion error";
         setConversionError(errorMessage);
-        console.error("Transcription conversion failed:", error);
+        console.error("[SERA] Transcription conversion failed:", error);
         return {
           transcription: "Conversion failed - see raw response",
           classification: { "Conversion Error": [errorMessage] },
@@ -1537,7 +1515,7 @@ var useHL7FHIRConverter = () => {
         )}|||||F|||${timestamp}`
       );
       const hl7Message = hl7Lines.join("\r\n") + "\r\n";
-      console.log("Constructed HL7 Transcription Request:\n", hl7Message);
+      console.log(`[SERA] HL7 transcription request constructed | size=${hl7Message.length}`);
       const formData = new FormData();
       const hl7Blob = new Blob([hl7Message], { type: "text/plain" });
       formData.append("hl7_request", hl7Blob, "transcription_request.hl7");
@@ -1792,10 +1770,7 @@ var useHL7FHIRConverter = () => {
           });
         }
       }
-      console.log(
-        "Constructed FHIR Transcription Request Bundle:",
-        JSON.stringify(fhirBundle, null, 2)
-      );
+      console.log(`[SERA] FHIR transcription request constructed | entries=${fhirBundle.entry.length}`);
       const formData = new FormData();
       const fhirBlob = new Blob([JSON.stringify(fhirBundle, null, 2)], {
         type: "application/fhir+json"
@@ -1807,10 +1782,7 @@ var useHL7FHIRConverter = () => {
       }
       formData.append("sequence", requestData.sequence.toString());
       formData.append("isFinalChunk", requestData.isFinalChunk.toString());
-      console.log(
-        "Created FHIR FormData with session ID:",
-        requestData.sessionId || "none (first call)"
-      );
+      console.log(`[SERA] FHIR FormData created | sessionId=${requestData.sessionId || "none"}`);
       return formData;
     },
     [formatFHIRDate, mapFHIRGender]
@@ -1882,16 +1854,7 @@ var useHL7FHIRConverter = () => {
         `OBX|${obxSequence++}|TX|REQUEST_TYPE^Request Type||DICTATION|||||F|||${timestamp}`
       );
       const hl7Message = hl7Lines.join("\r\n") + "\r\n";
-      console.log("=== HL7 Dictation Request Debug ===");
-      console.log("Request Data:", requestData);
-      console.log("Audio File:", {
-        name: audioFile.name,
-        size: audioFile.size,
-        type: audioFile.type
-      });
-      console.log("HL7 Message:");
-      console.log(hl7Message);
-      console.log("=== End Debug ===");
+      console.log(`[SERA] HL7 dictation request constructed | size=${hl7Message.length}, audioFile=${audioFile.name}, audioSize=${audioFile.size}`);
       const formData = new FormData();
       formData.append("audio", audioFile);
       const hl7Blob = new Blob([hl7Message], { type: "text/plain; charset=utf-8" });
@@ -2046,15 +2009,7 @@ var useHL7FHIRConverter = () => {
           }
         ]
       };
-      console.log("=== FHIR Dictation Request Debug ===");
-      console.log("Request Data:", requestData);
-      console.log("Audio File:", {
-        name: audioFile.name,
-        size: audioFile.size,
-        type: audioFile.type
-      });
-      console.log("FHIR Bundle:", JSON.stringify(fhirBundle, null, 2));
-      console.log("=== End Debug ===");
+      console.log(`[SERA] FHIR dictation request constructed | entries=${fhirBundle.entry.length}, audioFile=${audioFile.name}, audioSize=${audioFile.size}`);
       const formData = new FormData();
       formData.append("audio", audioFile);
       const fhirBlob = new Blob([JSON.stringify(fhirBundle, null, 2)], {
@@ -2070,7 +2025,7 @@ var useHL7FHIRConverter = () => {
       try {
         const segments = parseHL7(hl7Data);
         let dictationResponse = {};
-        console.log("Parsing HL7 dictation segments:", segments);
+        console.log(`[SERA] Parsing HL7 dictation | segments=${segments.length}`);
         for (const segment of segments) {
           switch (segment.type) {
             case "MSH":
@@ -2165,7 +2120,7 @@ var useHL7FHIRConverter = () => {
               );
             }
           } catch (e) {
-            console.warn("Could not calculate processing time:", e);
+            console.warn("[SERA] Could not calculate processing time:", e);
           }
         }
         const finalResponse = {
@@ -2175,10 +2130,10 @@ var useHL7FHIRConverter = () => {
           language: dictationResponse.language,
           processingTimes: dictationResponse.processingTimes
         };
-        console.log("Converted HL7 dictation response:", finalResponse);
+        console.log(`[SERA] HL7 dictation converted | sessionId=${finalResponse.sessionId}, dictationLength=${finalResponse.dictation.length}`);
         return finalResponse;
       } catch (error) {
-        console.error("HL7 dictation conversion error:", error);
+        console.error("[SERA] HL7 dictation conversion error:", error);
         throw new Error(
           `Failed to convert HL7 dictation data: ${error instanceof Error ? error.message : "Unknown error"}`
         );
@@ -2191,20 +2146,16 @@ var useHL7FHIRConverter = () => {
       let dictationResponse = {};
       let parsedData = fhirData;
       if (typeof fhirData === "string") {
-        console.log("\u{1F4DD} Response is a string, parsing JSON...");
         try {
           parsedData = JSON.parse(fhirData);
-          console.log("\u2705 JSON parsed successfully");
         } catch (e) {
-          console.error("\u274C Failed to parse JSON string:", e);
+          console.error("[SERA] Failed to parse FHIR dictation JSON string:", e);
           throw new Error("Invalid JSON response from server");
         }
       }
-      console.log("Parsing FHIR dictation data:", parsedData);
       let resources = [];
       if (parsedData.resourceType === "Bundle" && parsedData.entry) {
         resources = parsedData.entry.map((entry) => entry.resource);
-        console.log(`\u{1F4E6} Found ${resources.length} resources in Bundle`);
       } else if (parsedData.resourceType) {
         resources = [parsedData];
       } else if (parsedData.resource) {
@@ -2212,26 +2163,17 @@ var useHL7FHIRConverter = () => {
       }
       for (let i = 0; i < resources.length; i++) {
         const resource = resources[i];
-        console.log(`
---- Processing resource [${i}]: ${resource?.resourceType || "unknown"} ---`);
         if (!resource || !resource.resourceType) continue;
         switch (resource.resourceType) {
           case "MessageHeader":
             dictationResponse.sessionId = resource.id;
-            console.log("\u2705 Session ID from MessageHeader:", resource.id);
             break;
           case "Media":
-            console.log("\u{1F3AF} Found Media resource for dictation");
             if (resource.extension && Array.isArray(resource.extension)) {
-              console.log(`\u{1F4CB} Processing ${resource.extension.length} extensions`);
               for (const ext of resource.extension) {
-                console.log(
-                  `  Extension URL: ${ext.url}, valueString: ${ext.valueString || ext.valueInteger}`
-                );
                 switch (ext.url) {
                   case "http://nuxera.ai/extensions/transcription":
                     dictationResponse.dictation = ext.valueString || "";
-                    console.log("\u2705\u2705 Extracted dictation text:", dictationResponse.dictation);
                     break;
                   case "http://nuxera.ai/extensions/audio-size":
                     if (!dictationResponse.processingTimes) {
@@ -2241,17 +2183,12 @@ var useHL7FHIRConverter = () => {
                     if (sizeMatch) {
                       dictationResponse.processingTimes.audioSizeMB = parseFloat(sizeMatch[1]);
                     }
-                    console.log(
-                      "\u2705 Extracted audio size:",
-                      dictationResponse.processingTimes.audioSizeMB
-                    );
                     break;
                   case "http://nuxera.ai/extensions/processing-timestamp":
                     if (!dictationResponse.processingTimes) {
                       dictationResponse.processingTimes = {};
                     }
                     dictationResponse.processingTimes.requestTimestamp = ext.valueInteger;
-                    console.log("\u2705 Extracted processing timestamp:", ext.valueInteger);
                     break;
                   case "http://nuxera.ai/extensions/confidence":
                     dictationResponse.confidence = ext.valueDecimal || ext.valueInteger;
@@ -2276,11 +2213,9 @@ var useHL7FHIRConverter = () => {
             }
             if (!dictationResponse.sessionId && resource.identifier && resource.identifier[0]) {
               dictationResponse.sessionId = resource.identifier[0].value;
-              console.log("\u2705 Session ID from Media.identifier:", dictationResponse.sessionId);
             }
             if (!dictationResponse.sessionId && resource.id) {
               dictationResponse.sessionId = resource.id;
-              console.log("\u2705 Session ID from Media.id:", dictationResponse.sessionId);
             }
             if (resource.createdDateTime && dictationResponse.processingTimes) {
               dictationResponse.processingTimes.processedAt = resource.createdDateTime;
@@ -2369,14 +2304,9 @@ var useHL7FHIRConverter = () => {
             dictationResponse.processingTimes.totalProcessingMs = Math.round(
               processedAtMs - requestMs
             );
-            console.log(
-              "\u2705 Calculated total processing time:",
-              dictationResponse.processingTimes.totalProcessingMs,
-              "ms"
-            );
           }
         } catch (e) {
-          console.warn("Could not calculate processing time:", e);
+          console.warn("[SERA] Could not calculate FHIR dictation processing time:", e);
         }
       }
       const finalResponse = {
@@ -2386,10 +2316,10 @@ var useHL7FHIRConverter = () => {
         language: dictationResponse.language,
         processingTimes: dictationResponse.processingTimes
       };
-      console.log("\u2705\u2705 Converted FHIR dictation response:", finalResponse);
+      console.log(`[SERA] FHIR dictation converted | sessionId=${finalResponse.sessionId}, dictationLength=${finalResponse.dictation.length}`);
       return finalResponse;
     } catch (error) {
-      console.error("\u274C FHIR dictation conversion error:", error);
+      console.error("[SERA] FHIR dictation conversion error:", error);
       throw new Error(
         `Failed to convert FHIR dictation data: ${error instanceof Error ? error.message : "Unknown error"}`
       );
@@ -2423,7 +2353,7 @@ var useHL7FHIRConverter = () => {
       } catch (error) {
         const errorMessage = error instanceof Error ? error.message : "Unknown conversion error";
         setConversionError(errorMessage);
-        console.error("Dictation conversion failed:", error);
+        console.error("[SERA] Dictation conversion failed:", error);
         return {
           dictation: "",
           sessionId: null,
@@ -2498,12 +2428,7 @@ var useHL7FHIRConverter = () => {
         )}|||||F|||${timestamp}`
       );
       const hl7Message = hl7Lines.join("\r\n") + "\r\n";
-      console.log("=== HL7 API Key Request Debug ===");
-      console.log("Operation:", operation);
-      console.log("API Key Data:", apiKeyData);
-      console.log("HL7 Message:");
-      console.log(hl7Message);
-      console.log("=== End Debug ===");
+      console.log(`[SERA] HL7 API key request constructed | operation=${operation}, size=${hl7Message.length}`);
       return hl7Message;
     },
     [escapeHL7]
@@ -2663,11 +2588,7 @@ var useHL7FHIRConverter = () => {
           });
         }
       }
-      console.log("=== FHIR API Key Request Debug ===");
-      console.log("Operation:", operation);
-      console.log("API Key Data:", apiKeyData);
-      console.log("FHIR Bundle:", JSON.stringify(fhirBundle, null, 2));
-      console.log("=== End Debug ===");
+      console.log(`[SERA] FHIR API key request constructed | operation=${operation}, entries=${fhirBundle.entry.length}`);
       return JSON.stringify(fhirBundle);
     },
     []
@@ -2844,9 +2765,6 @@ var createAudioProcessorWorker = () => {
             });
             this._audioLevelCheckInterval = 0;
             
-            // Debug: Log audio capture status every few seconds
-            if (this._audioLevelCheckInterval % 1000 === 0) {
-            }
           }
 
           if (audioLevel > this._audioThreshold) {
@@ -2902,7 +2820,6 @@ var createAudioProcessorWorker = () => {
                 },
                 [flat.buffer]
               );
-              console.log('[UPLOAD] Sending chunk: ' + (this._bufferSize / this._sampleRate).toFixed(1) + 's');
               // Clear buffer after upload
               this._buffer = [];
               this._bufferSize = 0;
@@ -2987,31 +2904,17 @@ var useAudioRecorder = ({
     clearFailedSessions
   } = useAudioRecovery_default(async (audioChunks, metadata) => {
     try {
-      console.log("\u{1F504} Retry callback started with audio chunks:", {
-        chunksCount: audioChunks.length,
-        totalSamples: audioChunks.reduce((sum, chunk) => sum + chunk.length, 0),
-        chunkDetails: audioChunks.map((chunk, idx) => ({
-          index: idx,
-          length: chunk.length,
-          hasData: chunk.length > 0
-        }))
-      });
       if (audioChunks.length === 0) {
         throw new Error("No audio chunks provided for retry");
       }
       const combinedAudio = combineAudioChunks(audioChunks);
-      console.log("[AUDIO] Combined audio for retry:", {
-        combinedLength: combinedAudio.length,
-        hasAudio: combinedAudio.length > 0
-      });
+      console.log(`[SERA] Recovery retry | chunks=${audioChunks.length}, samples=${combinedAudio.length}`);
       if (combinedAudio.length === 0) {
         throw new Error("Combined audio is empty");
       }
       if (!uploadChunkToServerRef.current) {
         throw new Error("Upload function not yet initialized");
       }
-      const newSessionId = `session_retry_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
-      console.log("\u{1F194} Generated new retry session ID:", newSessionId);
       await uploadChunkToServerRef.current(
         combinedAudio,
         true,
@@ -3020,9 +2923,9 @@ var useAudioRecorder = ({
         false,
         metadata.sampleRate
       );
-      console.log("[SUCCESS] Retry upload completed successfully");
+      console.log("[SERA] Recovery retry completed successfully");
     } catch (error2) {
-      console.error("[ERROR] Retry session failed:", error2);
+      console.error("[SERA] Recovery retry failed:", error2);
       throw error2;
     }
   });
@@ -3049,7 +2952,6 @@ var useAudioRecorder = ({
   const ffmpegLoadedRef = React3__namespace.default.useRef(ffmpegLoaded);
   React3__namespace.default.useEffect(() => {
     ffmpegLoadedRef.current = ffmpegLoaded;
-    console.log(`\u{1F504} ffmpegLoadedRef updated to: ${ffmpegLoaded}`);
   }, [ffmpegLoaded]);
   React3__namespace.default.useEffect(() => {
     selectedModelRef.current = selectedModel;
@@ -3064,11 +2966,6 @@ var useAudioRecorder = ({
     selectedFormatRef.current = selectedFormat;
   }, [selectedFormat]);
   React3__namespace.default.useEffect(() => {
-    console.log("Triggering onTranscriptionUpdate with:", {
-      alreadyDoneTranscription,
-      sessionId: sessionIdRef.current,
-      localSessionId: localSessionIdRef.current
-    });
     if (alreadyDoneTranscription.length > 0) {
       onTranscriptionUpdate(
         alreadyDoneTranscription,
@@ -3076,30 +2973,21 @@ var useAudioRecorder = ({
       );
     }
   }, [alreadyDoneTranscription]);
-  React3__namespace.default.useEffect(() => {
-    console.log("Speciality changed in useAudioRecorder:", speciality);
-  }, [speciality]);
   React3__namespace.default.useEffect(() => {
     let isMounted = true;
     if (!ffmpegLoadedRef.current) {
       (async () => {
-        console.log("Initializing FFmpeg WASM\u2026");
         try {
           const ok = await loadFFmpeg();
-          if (isMounted) {
-            console.log("FFmpeg init returned:", ok);
-            if (ok) {
-              console.log("FFmpeg WASM initialized successfully for audio recorder");
-            }
+          if (isMounted && ok) {
+            console.log("[SERA] FFmpeg WASM initialized");
           }
         } catch (error2) {
           if (isMounted) {
-            console.error("FFmpeg WASM initialization failed:", error2);
+            console.error("[SERA] FFmpeg WASM initialization failed:", error2);
           }
         }
       })();
-    } else {
-      console.log("FFmpeg WASM already initialized, skipping");
     }
     return () => {
       isMounted = false;
@@ -3123,12 +3011,11 @@ var useAudioRecorder = ({
         const track = audioTracks[0];
         const settings = track.getSettings();
         setCurrentDeviceId(settings.deviceId || null);
-        console.log();
       }
       testStream.getTracks().forEach((track) => track.stop());
       return true;
     } catch (error2) {
-      console.error("Microphone validation failed:", error2);
+      console.error("[SERA] Microphone validation failed:", error2);
       if (error2 instanceof Error) {
         let errorMessage = "";
         if (error2.name === "NotFoundError" || error2.name === "DevicesNotFoundError") {
@@ -3151,9 +3038,6 @@ var useAudioRecorder = ({
     }
   }, [currentDeviceId]);
   React3__namespace.default.useEffect(() => {
-    if (speciality) {
-      console.log("Speciality set, microphone validation will happen on recording start");
-    }
   }, [speciality]);
   const clearAllSessions = React3__namespace.default.useCallback(async () => {
     await clearFailedSessions();
@@ -3162,30 +3046,16 @@ var useAudioRecorder = ({
   const uploadChunkToServer = React3__namespace.default.useCallback(
     async (audioData, isFinalChunk, sequence, retry = false, isPausedChunk = false, sampleRateOverride) => {
       const currentFfmpegLoaded = ffmpegLoadedRef.current;
-      console.log("\u{1F527} uploadChunkToServer called with:", {
-        ffmpegLoaded: currentFfmpegLoaded,
-        silenceRemovalEnabled: removeSilenceRef.current,
-        hasRemoveSilenceFunction: typeof removeSilence === "function",
-        isFinalChunk,
-        sequence,
-        audioDataLength: audioData?.length,
-        requestFormat: selectedFormatRef.current,
-        sessionHasFailed: sessionHasFailedChunkRef.current
-      });
+      console.log(`[SERA] Step 6: Upload chunk | sequence=${sequence}, isFinal=${isFinalChunk}, samples=${audioData?.length || 0}, format=${selectedFormatRef.current}`);
       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(`[DB] \u2713 Successfully saved audio chunk ${sequence} to IndexedDB (${audioData.length} samples)`);
         } catch (error2) {
-          console.error(`[DB] \u2717 Failed to save audio chunk ${sequence} to IndexedDB:`, error2);
+          console.error(`[SERA] IndexedDB save failed for chunk ${sequence}:`, error2);
         }
-      } else {
-        console.log(`[DB] Skipping IndexedDB save: audioData=${!!audioData}, sessionId=${localSessionIdRef.current}, retry=${retry}`);
       }
       if (sessionHasFailedChunkRef.current && !retry) {
-        console.log(`[SKIP] Session has failed chunk - skipping server upload for sequence ${sequence}, continuing to record audio`);
         if (isFinalChunk) {
           setShowRetrySessionPrompt(true);
           setIsProcessing(false);
@@ -3193,151 +3063,96 @@ var useAudioRecorder = ({
         return;
       }
       try {
-        const data = await pRetry__default.default(
-          async (attemptNumber) => {
-            console.log(`\u{1F504} Transcribe attempt ${attemptNumber} for sequence ${sequence}`);
-            if (!audioData || audioData.length === 0) {
-              console.log();
-              if (retry) {
-                throw new pRetry.AbortError("No audio data provided for retry");
-              }
-              throw new Error("No audio data provided");
-            }
-            console.log();
-            const currentSampleRate = sampleRateOverride ?? recordingSampleRateRef.current ?? audioContextRef.current?.sampleRate;
-            if (!isValidSampleRate(currentSampleRate)) {
-              throw new InvalidSampleRateError(currentSampleRate);
-            }
-            console.log(
-              `[PROCESSING] Processing audio chunk: ${audioData.length} samples (${(audioData.length / currentSampleRate).toFixed(2)}s) at ${currentSampleRate}Hz`
-            );
-            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) {
-                nonZeroSamples++;
-              }
-            }
-            const audioPercentage = nonZeroSamples / audioData.length;
-            console.log(
-              `[AUDIO] Audio stats: maxAmplitude=${maxAmplitude.toFixed(4)}, audioContent=${(audioPercentage * 100).toFixed(2)}%, sequence=${sequence}, isFinal=${isFinalChunk}`
-            );
-            console.log(`[WAV] Converting to WAV with sample rate: ${currentSampleRate}Hz`);
-            const timestamp = Date.now();
-            const fileName = `audio-chunk-${timestamp}.wav`;
-            let wavFile = await convertToWav(audioData, currentSampleRate, fileName);
-            if (!wavFile) {
-              throw new Error("WAV conversion failed through FFmpeg");
-            }
-            console.log(`[INFO] Original WAV file: ${wavFile.size} bytes, ${wavFile.name}`);
-            if (currentFfmpegLoaded && removeSilenceRef.current) {
-              try {
-                console.log("[SILENCE] Attempting to remove silence from audio chunk...");
-                const processedFile = await removeSilence(wavFile);
-                if (processedFile) {
-                  console.log(
-                    `[SUCCESS] Silence removed successfully: ${processedFile.size} bytes (was ${wavFile.size} bytes)`
-                  );
-                  if (processedFile.size < 1e3) {
-                    console.warn(
-                      `[WARN] Processed file very small (${processedFile.size} bytes), using original file`
-                    );
-                  } else {
-                    wavFile = processedFile;
-                  }
-                } else {
-                  console.warn("Silence removal returned null, using original file");
-                }
-              } catch (silenceError) {
-                console.warn("Silence removal failed, using original file:", silenceError);
-              }
-            } else {
-              console.log("[SILENCE] Silence removal disabled or not loaded");
-            }
-            let audioFile = wavFile;
-            try {
-              console.log("[FLAC] Converting WAV to FLAC...");
-              const flacFile = await convertToFlac(wavFile);
-              if (flacFile && flacFile.type === "audio/flac") {
-                audioFile = flacFile;
-                console.log(
-                  `[FLAC] Conversion successful: ${wavFile.size} bytes WAV \u2192 ${flacFile.size} bytes FLAC`
-                );
-              } else {
-                console.warn("[FLAC] Conversion failed, using WAV file");
-              }
-            } catch (flacError) {
-              console.warn("[FLAC] Conversion error, using WAV file:", flacError);
+        if (!audioData || audioData.length === 0) {
+          if (retry) {
+            throw new pRetry.AbortError("No audio data provided for retry");
+          }
+          throw new Error("No audio data provided");
+        }
+        const currentSampleRate = sampleRateOverride ?? recordingSampleRateRef.current ?? audioContextRef.current?.sampleRate;
+        if (!isValidSampleRate(currentSampleRate)) {
+          throw new InvalidSampleRateError(currentSampleRate);
+        }
+        console.log(`[SERA] Step 7: Audio preparation | ${audioData.length} samples, ${(audioData.length / currentSampleRate).toFixed(1)}s, ${currentSampleRate}Hz`);
+        const timestamp = Date.now();
+        const fileName = `audio-chunk-${timestamp}.wav`;
+        let wavFile = await convertToWav(audioData, currentSampleRate, fileName);
+        if (!wavFile) {
+          throw new Error("WAV conversion failed through FFmpeg");
+        }
+        if (currentFfmpegLoaded && removeSilenceRef.current) {
+          try {
+            const processedFile = await removeSilence(wavFile);
+            if (processedFile && processedFile.size >= 1e3) {
+              wavFile = processedFile;
             }
-            console.log(
-              `[OUT] Final file for transcription: ${audioFile.size} bytes, ${audioFile.name}`
-            );
-            if (audioFile.size < 500) {
-              console.warn(
-                `[WARN] Small audio file (${audioFile.size} bytes) - may contain minimal audio data, sending to server anyway`
-              );
+          } catch (silenceError) {
+            console.warn("[SERA] Silence removal failed, using original file:", silenceError);
+          }
+        }
+        let audioFile = wavFile;
+        try {
+          const flacFile = await convertToFlac(wavFile);
+          if (flacFile && flacFile.type === "audio/flac") {
+            audioFile = flacFile;
+          }
+        } catch (flacError) {
+          console.warn("[SERA] FLAC conversion failed, using WAV file:", flacError);
+        }
+        console.log(`[SERA] Step 8: Audio file ready | ${audioFile.name}, ${audioFile.size} bytes`);
+        const patientDetailsPayload = patientDetails;
+        const requestData = {
+          sessionId: retry ? void 0 : sessionIdRef.current || void 0,
+          model: selectedModelRef.current,
+          doctorName,
+          patientDetails: patientDetailsPayload,
+          removeSilence: removeSilenceRef.current,
+          skipDiarization: skipDiarizationRef.current,
+          isFinalChunk,
+          isPaused: isPausedChunk,
+          sequence,
+          speciality,
+          retry
+        };
+        let formData;
+        switch (selectedFormatRef.current) {
+          case "hl7":
+            formData = createHL7TranscriptionRequest(audioFile, requestData);
+            break;
+          case "fhir":
+            formData = createFHIRTranscriptionRequest(audioFile, requestData);
+            break;
+          case "json":
+          default:
+            formData = new FormData();
+            if (retry) {
+              formData.append("retry", "true");
+            } else if (sessionIdRef.current) {
+              formData.append("sessionId", sessionIdRef.current);
             }
-            const patientDetailsPayload = patientDetails;
-            const requestData = {
-              sessionId: retry ? void 0 : sessionIdRef.current || void 0,
-              model: selectedModelRef.current,
-              doctorName,
-              patientDetails: patientDetailsPayload,
-              removeSilence: removeSilenceRef.current,
-              skipDiarization: skipDiarizationRef.current,
-              isFinalChunk,
-              isPaused: isPausedChunk,
-              sequence,
-              speciality,
-              retry
-            };
-            let formData;
-            let contentType;
-            switch (selectedFormatRef.current) {
-              case "hl7":
-                formData = createHL7TranscriptionRequest(audioFile, requestData);
-                contentType = "multipart/form-data; hl7-request=true";
-                console.log("Created HL7-formatted request");
-                console.log("HL7 FormData entries:", Array.from(formData.entries()));
-                break;
-              case "fhir":
-                formData = createFHIRTranscriptionRequest(audioFile, requestData);
-                contentType = "multipart/form-data; fhir-request=true";
-                console.log("Created FHIR-formatted request");
-                console.log("FHIR FormData entries:", Array.from(formData.entries()));
-                break;
-              case "json":
-              default:
-                formData = new FormData();
-                if (retry) {
-                  formData.append("retry", "true");
-                } else if (sessionIdRef.current) {
-                  formData.append("sessionId", sessionIdRef.current);
-                }
-                formData.append("audio", audioFile);
-                formData.append("model", selectedModelRef.current);
-                formData.append("doctorName", doctorName);
-                if (patientHistory) formData.append("patientHistory", patientHistory);
-                if (patientDetailsPayload) {
-                  formData.append("patientDetails", JSON.stringify(patientDetailsPayload));
-                }
-                formData.append("removeSilence", removeSilenceRef.current.toString());
-                formData.append("skipDiarization", skipDiarizationRef.current.toString());
-                formData.append("isFinalChunk", isFinalChunk.toString());
-                formData.append("isPaused", isPausedChunk.toString());
-                formData.append("sequence", sequence.toString());
-                formData.append("speciality", speciality);
-                console.log("Created JSON-formatted request");
-                break;
+            formData.append("audio", audioFile);
+            formData.append("model", selectedModelRef.current);
+            formData.append("doctorName", doctorName);
+            if (patientHistory) formData.append("patientHistory", patientHistory);
+            if (patientDetailsPayload) {
+              formData.append("patientDetails", JSON.stringify(patientDetailsPayload));
             }
-            const headers = {
-              "x-api-key": effectiveApiKey || "",
-              "x-response-format": selectedFormatRef.current,
-              "x-request-format": selectedFormatRef.current
-              // Add request format header
-            };
+            formData.append("removeSilence", removeSilenceRef.current.toString());
+            formData.append("skipDiarization", skipDiarizationRef.current.toString());
+            formData.append("isFinalChunk", isFinalChunk.toString());
+            formData.append("isPaused", isPausedChunk.toString());
+            formData.append("sequence", sequence.toString());
+            formData.append("speciality", speciality);
+            break;
+        }
+        const headers = {
+          "x-api-key": effectiveApiKey || "",
+          "x-response-format": selectedFormatRef.current,
+          "x-request-format": selectedFormatRef.current
+        };
+        const data = await pRetry__default.default(
+          async (attemptNumber) => {
+            console.log(`[SERA] Step 9: Sending to server | sequence=${sequence}, attempt=${attemptNumber}`);
             const response = await fetch(`${apiBaseUrl}/api/transcribe`, {
               method: "POST",
               headers,
@@ -3345,11 +3160,7 @@ var useAudioRecorder = ({
             });
             if (!response.ok) {
               const errorText = await response.text();
-              console.error("Transcription server error response:", {
-                status: response.status,
-                statusText: response.statusText,
-                body: errorText
-              });
+              console.error(`[SERA] Server error | status=${response.status}, body=${errorText}`);
               let errorMessage = `HTTP ${response.status}`;
               try {
                 const errorData = JSON.parse(errorText);
@@ -3370,30 +3181,20 @@ var useAudioRecorder = ({
             let responseData;
             if (selectedFormatRef.current === "json") {
               responseData = await response.json();
-              console.log("Parsed JSON response:", responseData);
             } else if (selectedFormatRef.current === "hl7") {
               responseData = await response.text();
-              console.log("Received HL7 response:", responseData);
             } else if (selectedFormatRef.current === "fhir") {
               responseData = await response.json();
-              console.log("Received FHIR response:", responseData);
             } else {
               const responseText = await response.text();
               try {
                 responseData = JSON.parse(responseText);
-                console.log("Fallback: Parsed as JSON:", responseData);
               } catch {
                 responseData = responseText;
-                console.log("Fallback: Using as text:", responseData);
               }
             }
-            const convertedData = convertTranscriptionResponse(
-              responseData,
-              selectedFormatRef.current
-            );
-            console.log("Original response:", responseData);
-            console.log("Converted response:", convertedData);
-            return convertedData;
+            console.log(`[SERA] Step 10: Server response received | sequence=${sequence}`);
+            return responseData;
           },
           {
             retries: 3,
@@ -3402,13 +3203,7 @@ var useAudioRecorder = ({
             maxTimeout: 1e4,
             randomize: true,
             onFailedAttempt: (error2) => {
-              console.warn(
-                `[WARN] Transcribe attempt ${error2.attemptNumber} failed for sequence ${sequence}:`,
-                {
-                  error: error2,
-                  retriesLeft: error2.retriesLeft
-                }
-              );
+              console.warn(`[SERA] Attempt ${error2.attemptNumber} failed for sequence ${sequence} | retriesLeft=${error2.retriesLeft}`);
               if (error2.retriesLeft > 0) {
                 setError(
                   `Network issue detected. Retrying... (${error2.retriesLeft} attempts remaining)`
@@ -3417,27 +3212,23 @@ var useAudioRecorder = ({
             }
           }
         );
+        const convertedData = convertTranscriptionResponse(data, selectedFormatRef.current);
         if (conversionError) {
           clearError();
         }
         if (error && error.includes("Retrying")) {
           setError(null);
         }
-        if (!data) {
+        if (!convertedData) {
           throw new Error("No data received from transcription server");
         }
-        console.log(`[SUCCESS] Received transcription for sequence ${sequence}:`, data);
-        if (retry && data.sessionId) {
-          console.log(
-            "[SUCCESS] Retry successful - received new server session ID:",
-            data.sessionId
-          );
-          sessionIdRef.current = data.sessionId;
-        } else if (!retry && data.sessionId && !sessionIdRef.current) {
-          console.log("[SUCCESS] Received initial server session ID:", data.sessionId);
-          sessionIdRef.current = data.sessionId;
+        if (retry && convertedData.sessionId) {
+          sessionIdRef.current = convertedData.sessionId;
+        } else if (!retry && convertedData.sessionId && !sessionIdRef.current) {
+          sessionIdRef.current = convertedData.sessionId;
         }
-        receivedTranscriptionsRef.current.set(sequence, data.transcription);
+        console.log(`[SERA] Step 11: Transcription received | sequence=${sequence}, sessionId=${sessionIdRef.current}`);
+        receivedTranscriptionsRef.current.set(sequence, convertedData.transcription);
         while (receivedTranscriptionsRef.current.has(nextExpectedSequenceRef.current)) {
           const t = receivedTranscriptionsRef.current.get(nextExpectedSequenceRef.current);
           setAlreadyDoneTranscription(t);
@@ -3445,17 +3236,21 @@ var useAudioRecorder = ({
           nextExpectedSequenceRef.current++;
         }
         if (isFinalChunk) {
+          console.log(`[SERA] Step 12: Final chunk complete - transcription done | sessionId=${sessionIdRef.current}`);
           setTranscriptionDone(true);
-          onTranscriptionComplete(data.transcription, data.classifiedInfo, sessionIdRef.current);
+          onTranscriptionComplete(
+            convertedData.transcription,
+            convertedData.classifiedInfo,
+            sessionIdRef.current
+          );
           if (localSessionIdRef.current) {
             await markSessionComplete(localSessionIdRef.current);
             setShowRetrySessionPrompt(false);
           }
         }
       } catch (err) {
-        console.error(`[ERROR] Upload error occurred after all retries:`, err);
+        console.error(`[SERA] Upload failed for sequence ${sequence}:`, err);
         if (conversionError) {
-          console.error("Conversion error during upload:", conversionError);
           setError(`Data conversion failed: ${conversionError}`);
         }
         const isAbortError = err instanceof Error && err.name === "AbortError";
@@ -3466,7 +3261,7 @@ var useAudioRecorder = ({
             localSessionIdRef.current,
             err instanceof Error ? err.message : "Unknown error"
           );
-          console.log(`[FAIL] Chunk ${sequence} failed - session marked as failed, will continue recording audio locally`);
+          console.warn(`[SERA] Chunk ${sequence} failed - continuing to record audio locally`);
           if (isFinalChunk) {
             setShowRetrySessionPrompt(true);
           }
@@ -3537,18 +3332,17 @@ var useAudioRecorder = ({
       if (failedSession) {
         const success = await retrySession(failedSession.id);
         if (success) {
-          console.log(`Successfully retried session ${failedSession.id}`);
           await deleteSession(failedSession.id);
-          console.log(`Deleted session ${failedSession.id} from IndexedDB after successful retry`);
+          console.log(`[SERA] Session retry succeeded | sessionId=${failedSession.id}`);
           setError(null);
           retrySucceeded = true;
         } else {
-          console.log(`Retry failed for session ${failedSession.id} - will show retry UI`);
+          console.warn(`[SERA] Session retry failed | sessionId=${failedSession.id}`);
           setError("Retry failed. Please check your connection and try again.");
         }
       }
     } catch (error2) {
-      console.error("Error retrying failed sessions:", error2);
+      console.error("[SERA] Error retrying failed session:", error2);
       setError("Failed to retry sessions. Please try again.");
     } finally {
       setIsRetryingSession(false);
@@ -3581,7 +3375,7 @@ var useAudioRecorder = ({
         const localSessionId = `session_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
         localSessionIdRef.current = localSessionId;
         sessionIdRef.current = null;
-        console.log("Created local session ID for IndexedDB:", localSessionId);
+        console.log(`[SERA] Step 1: New recording session created | localSessionId=${localSessionId}`);
       }
       const stream = await navigator.mediaDevices.getUserMedia({
         audio: {
@@ -3597,9 +3391,8 @@ var useAudioRecorder = ({
         const track = audioTracks[0];
         const settings = track.getSettings();
         setCurrentDeviceId(settings.deviceId || null);
-        console.log("Recording started with local session:", localSessionIdRef.current);
         track.addEventListener("ended", () => {
-          console.log("Audio track ended - device disconnected");
+          console.warn("[SERA] Microphone disconnected during recording");
           setError("Microphone disconnected. Session saved - please reconnect and retry.");
           stopRecording();
         });
@@ -3626,38 +3419,26 @@ var useAudioRecorder = ({
           level,
           silentDuration,
           hasDetectedAudio,
-          isInitialPhase,
-          totalRecordingTime,
-          lastAudioTime
+          isInitialPhase
         } = event.data;
         if (command === "finalChunk" && audioBuffer) {
           const sequence = sequenceCounterRef.current++;
           const audioArray = new Float32Array(audioBuffer);
-          console.log(`[RECEIVE] Final chunk: ${audioArray.length} samples, sequence: ${sequence}`);
+          console.log(`[SERA] Step 4: Final chunk received | sequence=${sequence}, samples=${audioArray.length}`);
           enqueueChunk(audioArray, true, sequence);
         } else if (command === "chunk" && audioBuffer) {
           const sequence = sequenceCounterRef.current++;
           const audioArray = new Float32Array(audioBuffer);
-          console.log(`[RECEIVE] Chunk: ${audioArray.length} samples, sequence: ${sequence}`);
+          console.log(`[SERA] Step 4: Chunk received | sequence=${sequence}, samples=${audioArray.length}`);
           enqueueChunk(audioArray, false, sequence);
         } else if (command === "pauseChunk" && 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);
         } else if (command === "prolongedSilence") {
-          console.log(
-            `Prolonged silence detected: ${Math.round(silentDuration)}s silent, ${Math.round(
-              totalRecordingTime
-            )}s total, last audio ${Math.round(lastAudioTime)}s ago`
-          );
+          console.warn(`[SERA] Prolonged silence: ${Math.round(silentDuration)}s`);
         } else if (command === "noAudioDetected") {
-          console.log(
-            `No audio detected: ${Math.round(
-              silentDuration
-            )}s silent, hasDetectedAudio: ${hasDetectedAudio}, isInitialPhase: ${isInitialPhase}`
-          );
           setNoAudioDetected(true);
           let errorMessage;
           if (isInitialPhase && !hasDetectedAudio) {
@@ -3677,7 +3458,7 @@ var useAudioRecorder = ({
       source.connect(processor);
       audioContextRef.current = audioContext;
       recordingSampleRateRef.current = audioContext.sampleRate;
-      console.log(`[AUDIO] Recording sample rate set to: ${audioContext.sampleRate}Hz`);
+      console.log(`[SERA] Step 2: Recording started | sampleRate=${audioContext.sampleRate}Hz`);
       processorRef.current = processor;
       setIsRecording(true);
       const intervalId = window.setInterval(() => {
@@ -3685,7 +3466,7 @@ var useAudioRecorder = ({
       }, 47e3);
       setUploadChunkInterval(intervalId);
     } catch (err) {
-      console.error("Recording start failed:", err);
+      console.error("[SERA] Recording start failed:", err);
     }
   }, [
     validateMicrophoneAccess,
@@ -3697,13 +3478,12 @@ var useAudioRecorder = ({
     currentDeviceId
   ]);
   const stopRecording = React3__namespace.default.useCallback(async () => {
-    console.log("Stopping recording...");
+    console.log("[SERA] Step 3: Stop recording requested");
     if (uploadChunkInterval) {
       clearInterval(uploadChunkInterval);
       setUploadChunkInterval(null);
     }
     if (processorRef.current) {
-      console.log("Stopping recording and sending final chunk --> ", isPaused ? "paused" : "final");
       processorRef.current.port.postMessage({ command: "stop" });
       setTimeout(async () => {
         if (processorRef.current) {
@@ -3721,18 +3501,13 @@ var useAudioRecorder = ({
       }, 500);
     }
     setIsRecording(false);
-    console.log("\u{1F50D} Stop recording - checking for failed session:", {
-      hasSessionFailed: sessionHasFailedChunkRef.current,
-      localSessionId: localSessionIdRef.current
-    });
     if (sessionHasFailedChunkRef.current && localSessionIdRef.current) {
-      console.log("\u26A0\uFE0F Recording stopped with failed session - showing retry UI");
+      console.warn("[SERA] Recording stopped with failed session - showing retry UI");
       setShowRetrySessionPrompt(true);
     }
   }, [uploadChunkInterval]);
   React3__namespace.default.useEffect(() => {
     const handleDeviceChange = async () => {
-      console.log("Audio device change detected");
       try {
         const devices = await navigator.mediaDevices.enumerateDevices();
         const audioInputDevices = devices.filter((device) => device.kind === "audioinput");
@@ -3751,7 +3526,7 @@ var useAudioRecorder = ({
           }
         }
       } catch (error2) {
-        console.error("Device change detection failed:", error2);
+        console.error("[SERA] Device change detection failed:", error2);
         setError("Unable to detect audio devices. Please check your microphone permissions.");
       }
     };
@@ -3771,7 +3546,7 @@ var useAudioRecorder = ({
           }, 1e3);
         }
       } catch (error2) {
-        console.error("Device selection failed:", error2);
+        console.error("[SERA] Device selection failed:", error2);
         setError("Failed to switch to selected microphone.");
       }
     },
@@ -3807,7 +3582,7 @@ var useAudioRecorder = ({
       return;
     }
     const { chunk, isFinal, sequence, isPaused: isPaused2 = false } = chunkQueueRef.current.shift();
-    console.log(`[QUEUE] Processing chunk ${sequence} from queue, remaining: ${chunkQueueRef.current.length}`);
+    console.log(`[SERA] Step 5: Queue processing | sequence=${sequence}, isFinal=${isFinal}, queued=${chunkQueueRef.current.length}`);
     isProcessingQueueRef.current = true;
     uploadChunkToServer(chunk, isFinal, sequence, false, isPaused2).finally(() => {
       isProcessingQueueRef.current = false;
@@ -3816,12 +3591,9 @@ var useAudioRecorder = ({
   }, [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) {
         if (!sessionHasFailedChunkRef.current) {
           setIsProcessing(true);
-        } else {
-          console.log("\u26A0\uFE0F Session has failed - skipping processing state (IndexedDB save only)");
         }
       }
       chunkQueueRef.current.push({
@@ -4531,21 +4303,13 @@ var AudioRecorder = ({
     patientDetails,
     selectedFormat,
     onTranscriptionUpdate: (text, sessionId) => {
-      console.log("onTranscriptionUpdate called with text:", text, "sessionId:", sessionId);
+      console.log(`[SERA] Transcription update received | sessionId=${sessionId}, textLength=${text.length}`);
       if (text.length > 0) {
-        console.log("Transcription update:", text, sessionId);
         onTranscriptionUpdate && onTranscriptionUpdate(text, sessionId);
       }
     },
     onTranscriptionComplete: (text, classification, sessionId) => {
-      console.log(
-        "onTranscriptionComplete called with text:",
-        text,
-        "classification:",
-        classification,
-        "sessionId:",
-        sessionId
-      );
+      console.log(`[SERA] Transcription complete | sessionId=${sessionId}, textLength=${text.length}, hasClassification=${!!classification}`);
       onTranscriptionComplete && onTranscriptionComplete(text, classification, sessionId);
     }
   });
@@ -4604,7 +4368,7 @@ var AudioRecorder = ({
     ] }) });
   }
   if (isMicrophoneError) {
-    console.log("\u{1F534} Showing microphone error UI");
+    console.log("[SERA] Showing microphone error UI");
     return /* @__PURE__ */ jsxRuntime.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__ */ jsxRuntime.jsxs("div", { className: "flex items-start", children: [
       /* @__PURE__ */ jsxRuntime.jsx("div", { className: "flex-shrink-0", children: /* @__PURE__ */ jsxRuntime.jsx(lucideReact.AlertTriangle, { className: "h-5 w-5 text-red-400" }) }),
       /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "ml-3 flex-1", children: [
@@ -4614,7 +4378,7 @@ var AudioRecorder = ({
           "button",
           {
             onClick: () => {
-              console.log("\u{1F504} Check Again button clicked");
+              console.log("[SERA] Microphone check again requested");
               validateMicrophoneAccess();
             },
             className: "bg-red-600 hover:bg-red-700 text-white px-3 py-1 rounded text-sm transition-colors",