sera-ai 1.0.29 → 1.0.30

package/dist/index.js

@@ -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;
     }