@absolutejs/voice 0.0.22-beta.656 → 0.0.22-beta.658

package/dist/index.js

@@ -39835,6 +39835,7 @@ var createVoiceMonitorRunnerRoutes = (options) => {
 };
 
 // src/core/plugin.ts
+var socketIdentity = (ws) => ws.raw && typeof ws.raw === "object" ? ws.raw : ws;
 var resolveQueryScenario = (query) => {
   if (typeof query?.scenarioId === "string" && query.scenarioId.trim()) {
     return query.scenarioId.trim();
@@ -39946,14 +39947,15 @@ var parseClientMessage = (raw) => {
 };
 var resolveSessionId3 = (runtime, ws) => {
   const query = ws.data && typeof ws.data === "object" && "query" in ws.data ? ws.data.query : undefined;
-  const existing = runtime.socketSessions.get(ws);
+  const identity = socketIdentity(ws);
+  const existing = runtime.socketSessions.get(identity);
   const providedSessionId = typeof query?.sessionId === "string" && query.sessionId.trim() ? query.sessionId.trim() : existing?.sessionId ?? createId();
   const scenarioId = resolveQueryScenario(query) ?? existing?.scenarioId ?? null;
   const resolved = {
     scenarioId,
     sessionId: providedSessionId
   };
-  runtime.socketSessions.set(ws, resolved);
+  runtime.socketSessions.set(identity, resolved);
   return resolved;
 };
 var resolveSocketQuery = (ws) => ws.data && typeof ws.data === "object" && ("query" in ws.data) ? ws.data.query ?? {} : {};
@@ -40158,30 +40160,48 @@ var voice = (config) => {
     socketSessions: new WeakMap
   };
   const authorizedSockets = new WeakSet;
-  const authorizeSocket = async (ws, sessionId, scenarioId) => {
-    if (!config.authorizeConnection) {
-      authorizedSockets.add(ws);
+  const pendingSocketAuthorizations = new WeakMap;
+  const authorizeSocket = (ws, sessionId, scenarioId) => {
+    const identity = socketIdentity(ws);
+    const existing = pendingSocketAuthorizations.get(identity);
+    if (existing)
+      return existing;
+    const authorization = (async () => {
+      if (!config.authorizeConnection) {
+        authorizedSockets.add(identity);
+        return true;
+      }
+      let authorized = false;
+      try {
+        authorized = await config.authorizeConnection({
+          context: ws.data,
+          headers: resolveSocketHeaders(ws),
+          path: config.path,
+          query: resolveSocketQuery(ws),
+          scenarioId,
+          sessionId
+        });
+      } catch (error) {
+        runtime.logger.warn?.(`[voice] connection authorization failed for session "${sessionId}": ${error instanceof Error ? error.message : String(error)}`);
+      }
+      if (!authorized) {
+        ws.close(4401, "unauthorized");
+        return false;
+      }
+      authorizedSockets.add(identity);
       return true;
-    }
-    let authorized = false;
-    try {
-      authorized = await config.authorizeConnection({
-        context: ws.data,
-        headers: resolveSocketHeaders(ws),
-        path: config.path,
-        query: resolveSocketQuery(ws),
-        scenarioId,
-        sessionId
-      });
-    } catch (error) {
-      runtime.logger.warn?.(`[voice] connection authorization failed for session "${sessionId}": ${error instanceof Error ? error.message : String(error)}`);
-    }
-    if (!authorized) {
-      ws.close(4401, "unauthorized");
+    })();
+    pendingSocketAuthorizations.set(identity, authorization);
+    return authorization;
+  };
+  const waitForSocketAuthorization = async (ws) => {
+    const identity = socketIdentity(ws);
+    if (authorizedSockets.has(identity))
+      return true;
+    const pending = pendingSocketAuthorizations.get(identity);
+    if (!pending)
       return false;
-    }
-    authorizedSockets.add(ws);
-    return true;
+    return pending;
   };
   const { monitor } = config;
   const registerMonitorSession = (sessionId, handle) => {
@@ -40491,8 +40511,9 @@ var voice = (config) => {
   };
   return new Elysia70({ name: "absolutejs-voice" }).ws(config.path, {
     close: async (ws, code, reason) => {
-      const socketState = runtime.socketSessions.get(ws);
-      if (!socketState || runtime.activeSockets.get(socketState.sessionId) !== ws) {
+      const identity = socketIdentity(ws);
+      const socketState = runtime.socketSessions.get(identity);
+      if (!socketState || runtime.activeSockets.get(socketState.sessionId) !== identity) {
         return;
       }
       runtime.activeSockets.delete(socketState.sessionId);
@@ -40509,7 +40530,7 @@ var voice = (config) => {
       }
     },
     message: async (ws, raw) => {
-      if (!authorizedSockets.has(ws)) {
+      if (!await waitForSocketAuthorization(ws)) {
         ws.close(4401, "unauthorized");
         return;
       }
@@ -40595,8 +40616,8 @@ var voice = (config) => {
             deregisterMonitorSession(sessionState.sessionId, "session-switch");
           }
           sessionState.sessionId = message.sessionId;
-          runtime.activeSockets.set(message.sessionId, ws);
-          runtime.socketSessions.set(ws, {
+          runtime.activeSockets.set(message.sessionId, socketIdentity(ws));
+          runtime.socketSessions.set(socketIdentity(ws), {
             ...sessionState,
             sessionId: message.sessionId,
             scenarioId: sessionState.scenarioId
@@ -40604,7 +40625,7 @@ var voice = (config) => {
         }
         if (message.type === "start" && message.scenarioId) {
           sessionState.scenarioId = message.scenarioId;
-          runtime.socketSessions.set(ws, {
+          runtime.socketSessions.set(socketIdentity(ws), {
             ...sessionState,
             scenarioId: message.scenarioId
           });
@@ -40624,7 +40645,7 @@ var voice = (config) => {
         return;
       }
       const existing = runtime.activeSessions.get(sessionState.sessionId);
-      runtime.activeSockets.set(sessionState.sessionId, ws);
+      runtime.activeSockets.set(sessionState.sessionId, socketIdentity(ws));
       if (existing) {
         await existing.disconnect({
           code: 1006,

package/dist/react/index.js

@@ -11442,6 +11442,7 @@ var DEFAULT_MAX_RECONNECT_ATTEMPTS = 15;
 var DEFAULT_PING_INTERVAL = 30000;
 var DEFAULT_RECONNECT_RESET_AFTER_MS = 30000;
 var DEFAULT_CALL_CONTROL_ACK_TIMEOUT_MS = 5000;
+var DEFAULT_PREPARE_RECONNECT_TIMEOUT_MS = 1e4;
 var MAX_PENDING_CONTROL_MESSAGES = 100;
 var RECONNECT_BASE_DELAY_MS = 500;
 var DEFAULT_RECONNECT_MAX_DELAY_MS = 8000;
@@ -11535,6 +11536,7 @@ var createVoiceConnection = (path, options = {}) => {
   const reconnectResetAfterMs = options.reconnectResetAfterMs ?? DEFAULT_RECONNECT_RESET_AFTER_MS;
   let lifecycleGeneration = 0;
   let disposed = false;
+  let reconnectPreparationAbort = null;
   const computeReconnectDelayMs = (attempt) => computeVoiceReconnectDelayMs(attempt, RECONNECT_BASE_DELAY_MS, reconnectMaxDelayMs);
   const state = {
     isConnected: false,
@@ -11622,12 +11624,30 @@ var createVoiceConnection = (path, options = {}) => {
         return;
       }
       try {
-        await options.prepareReconnect?.({
-          attempt: state.reconnectAttempts,
-          path,
-          scenarioId: state.scenarioId,
-          sessionId: state.sessionId
-        });
+        if (options.prepareReconnect) {
+          const preparationAbort = new AbortController;
+          reconnectPreparationAbort = preparationAbort;
+          const timeout = setTimeout(() => preparationAbort.abort("Voice reconnect preparation timed out"), options.prepareReconnectTimeoutMs ?? DEFAULT_PREPARE_RECONNECT_TIMEOUT_MS);
+          try {
+            await Promise.race([
+              options.prepareReconnect({
+                attempt: state.reconnectAttempts,
+                path,
+                scenarioId: state.scenarioId,
+                sessionId: state.sessionId,
+                signal: preparationAbort.signal
+              }),
+              new Promise((_, reject) => {
+                preparationAbort.signal.addEventListener("abort", () => reject(new Error("Voice reconnect preparation timed out.")), { once: true });
+              })
+            ]);
+          } finally {
+            clearTimeout(timeout);
+            if (reconnectPreparationAbort === preparationAbort) {
+              reconnectPreparationAbort = null;
+            }
+          }
+        }
       } catch (error) {
         if (disposed || lifecycleGeneration !== scheduledGeneration)
           return;
@@ -11751,6 +11771,8 @@ var createVoiceConnection = (path, options = {}) => {
     state.ws = ws;
   };
   const sendSerialized = (value) => {
+    if (disposed)
+      return;
     if (state.ws?.readyState === WS_OPEN) {
       state.ws.send(value);
       return;
@@ -11805,6 +11827,8 @@ var createVoiceConnection = (path, options = {}) => {
   };
   const close = (reason = "client-close") => {
     disposed = true;
+    reconnectPreparationAbort?.abort();
+    reconnectPreparationAbort = null;
     lifecycleGeneration += 1;
     clearTimers();
     rejectPendingCallControls("Voice connection closed");
@@ -11822,6 +11846,8 @@ var createVoiceConnection = (path, options = {}) => {
   };
   const disconnect = () => {
     disposed = true;
+    reconnectPreparationAbort?.abort();
+    reconnectPreparationAbort = null;
     lifecycleGeneration += 1;
     clearTimers();
     rejectPendingCallControls("Voice connection disconnected");
@@ -12073,7 +12099,10 @@ var createVoiceStream = (path, options = {}) => {
     getSessionId: () => options.browserMedia ? options.browserMedia.getSessionId?.() ?? connection.getSessionId() : connection.getSessionId()
   }) : null;
   const subscribers = new Set;
+  let disposed = false;
   const start = (input) => Promise.resolve().then(() => {
+    if (disposed)
+      return;
     if (!input?.sessionId && !input?.scenarioId) {
       return;
     }
@@ -12132,6 +12161,7 @@ var createVoiceStream = (path, options = {}) => {
       return connection.callControl(message);
     },
     close(reason) {
+      disposed = true;
       unsubscribeConnection();
       browserMediaReporter?.close();
       connection.close(reason);
@@ -12139,6 +12169,7 @@ var createVoiceStream = (path, options = {}) => {
       notify();
     },
     disconnect() {
+      disposed = true;
       unsubscribeConnection();
       browserMediaReporter?.close();
       connection.disconnect();
@@ -12336,48 +12367,89 @@ var createMicrophoneCapture = (options) => {
   let sourceNode = null;
   let processorNode = null;
   let mediaStream = null;
-  const start = async () => {
-    if (!options.stream && (typeof navigator === "undefined" || !navigator.mediaDevices?.getUserMedia)) {
-      throw new Error("Browser microphone capture requires navigator.mediaDevices.getUserMedia.");
-    }
-    const AudioContextCtor = (typeof window !== "undefined" ? window.AudioContext ?? window.webkitAudioContext : undefined) ?? AudioContext;
-    if (!AudioContextCtor) {
-      throw new Error("Browser microphone capture requires AudioContext support.");
-    }
-    try {
-      mediaStream = options.stream ?? await navigator.mediaDevices.getUserMedia({
-        audio: {
-          autoGainControl: true,
-          channelCount: options.channelCount ?? 1,
-          echoCancellation: true,
-          noiseSuppression: true
+  let lifecycleGeneration = 0;
+  let startPromise = null;
+  const release = (resources) => {
+    resources.processorNode?.disconnect();
+    resources.sourceNode?.disconnect();
+    resources.mediaStream?.getTracks().forEach((track) => track.stop());
+    resources.audioContext?.close();
+  };
+  const start = () => {
+    if (mediaStream)
+      return Promise.resolve();
+    if (startPromise)
+      return startPromise;
+    const generation = ++lifecycleGeneration;
+    const operation = async () => {
+      if (!options.stream && (typeof navigator === "undefined" || !navigator.mediaDevices?.getUserMedia)) {
+        throw new Error("Browser microphone capture requires navigator.mediaDevices.getUserMedia.");
+      }
+      const AudioContextCtor = (typeof window !== "undefined" ? window.AudioContext ?? window.webkitAudioContext : undefined) ?? AudioContext;
+      if (!AudioContextCtor) {
+        throw new Error("Browser microphone capture requires AudioContext support.");
+      }
+      let pendingAudioContext = null;
+      let pendingMediaStream = null;
+      let pendingProcessorNode = null;
+      let pendingSourceNode = null;
+      try {
+        pendingMediaStream = options.stream ?? await navigator.mediaDevices.getUserMedia({
+          audio: {
+            autoGainControl: true,
+            channelCount: options.channelCount ?? 1,
+            echoCancellation: true,
+            noiseSuppression: true
+          }
+        });
+        if (generation !== lifecycleGeneration) {
+          throw new Error("Microphone capture stopped during startup.");
         }
-      });
-      audioContext = new AudioContextCtor;
-      if (audioContext.state === "suspended") {
-        await audioContext.resume();
+        pendingAudioContext = new AudioContextCtor;
+        if (pendingAudioContext.state === "suspended") {
+          await pendingAudioContext.resume();
+        }
+        if (generation !== lifecycleGeneration) {
+          throw new Error("Microphone capture stopped during startup.");
+        }
+        pendingSourceNode = pendingAudioContext.createMediaStreamSource(pendingMediaStream);
+        pendingProcessorNode = pendingAudioContext.createScriptProcessor(4096, 1, 1);
+        pendingProcessorNode.onaudioprocess = (event) => {
+          const channel = event.inputBuffer.getChannelData(0);
+          const downsampled = downsampleBuffer(channel, pendingAudioContext?.sampleRate ?? 48000, options.sampleRateHz ?? 16000);
+          const pcm = floatTo16BitPCM(downsampled);
+          options.onLevel?.(getPcmLevel(pcm));
+          options.onAudio(pcm);
+        };
+        pendingSourceNode.connect(pendingProcessorNode);
+        pendingProcessorNode.connect(pendingAudioContext.destination);
+        if (generation !== lifecycleGeneration) {
+          throw new Error("Microphone capture stopped during startup.");
+        }
+        audioContext = pendingAudioContext;
+        mediaStream = pendingMediaStream;
+        processorNode = pendingProcessorNode;
+        sourceNode = pendingSourceNode;
+      } catch (error) {
+        release({
+          audioContext: pendingAudioContext,
+          mediaStream: pendingMediaStream,
+          processorNode: pendingProcessorNode,
+          sourceNode: pendingSourceNode
+        });
+        throw error;
       }
-      sourceNode = audioContext.createMediaStreamSource(mediaStream);
-      processorNode = audioContext.createScriptProcessor(4096, 1, 1);
-      processorNode.onaudioprocess = (event) => {
-        const channel = event.inputBuffer.getChannelData(0);
-        const downsampled = downsampleBuffer(channel, audioContext?.sampleRate ?? 48000, options.sampleRateHz ?? 16000);
-        const pcm = floatTo16BitPCM(downsampled);
-        options.onLevel?.(getPcmLevel(pcm));
-        options.onAudio(pcm);
-      };
-      sourceNode.connect(processorNode);
-      processorNode.connect(audioContext.destination);
-    } catch (error) {
-      stop();
-      throw error;
-    }
+    };
+    const pending = operation().finally(() => {
+      if (startPromise === pending)
+        startPromise = null;
+    });
+    startPromise = pending;
+    return pending;
   };
   const stop = () => {
-    processorNode?.disconnect();
-    sourceNode?.disconnect();
-    mediaStream?.getTracks().forEach((track) => track.stop());
-    audioContext?.close();
+    lifecycleGeneration += 1;
+    release({ audioContext, mediaStream, processorNode, sourceNode });
     options.onLevel?.(0);
     audioContext = null;
     mediaStream = null;
@@ -12733,6 +12805,9 @@ var createVoiceController = (path, options = {}) => {
     ...options.connection
   });
   let capture = null;
+  let captureGeneration = 0;
+  let disposed = false;
+  let startRecordingPromise = null;
   let state = createInitialState2(stream);
   const subscribers = new Set;
   const notify = () => {
@@ -12789,6 +12864,7 @@ var createVoiceController = (path, options = {}) => {
     return capture;
   };
   const stopRecording = () => {
+    captureGeneration += 1;
     capture?.stop();
     capture = null;
     state = {
@@ -12798,39 +12874,63 @@ var createVoiceController = (path, options = {}) => {
     notify();
   };
   const startRecording = async () => {
+    if (disposed) {
+      throw new Error("Voice controller is closed.");
+    }
     if (state.isRecording) {
       return;
     }
-    try {
-      state = {
-        ...state,
-        recordingError: null
-      };
-      notify();
-      await ensureCapture().start();
-      state = {
-        ...state,
-        isRecording: true
-      };
-      notify();
-    } catch (error) {
-      capture?.stop();
-      capture = null;
-      state = {
-        ...state,
-        isRecording: false,
-        recordingError: error instanceof Error ? error.message : String(error)
-      };
-      notify();
-      throw error;
-    }
+    if (startRecordingPromise)
+      return startRecordingPromise;
+    const generation = ++captureGeneration;
+    const activeCapture = ensureCapture();
+    const operation = (async () => {
+      try {
+        state = {
+          ...state,
+          recordingError: null
+        };
+        notify();
+        await activeCapture.start();
+        if (disposed || generation !== captureGeneration || capture !== activeCapture) {
+          activeCapture.stop();
+          return;
+        }
+        state = {
+          ...state,
+          isRecording: true
+        };
+        notify();
+      } catch (error) {
+        activeCapture.stop();
+        if (generation !== captureGeneration || capture !== activeCapture) {
+          throw error;
+        }
+        capture = null;
+        state = {
+          ...state,
+          isRecording: false,
+          recordingError: error instanceof Error ? error.message : String(error)
+        };
+        notify();
+        throw error;
+      }
+    })();
+    const pending = operation.finally(() => {
+      if (startRecordingPromise === pending)
+        startRecordingPromise = null;
+    });
+    startRecordingPromise = pending;
+    return startRecordingPromise;
   };
   const close = (reason) => {
+    disposed = true;
     unsubscribeStream();
     stopRecording();
     stream.close(reason);
   };
   const disconnect = () => {
+    disposed = true;
     unsubscribeStream();
     stopRecording();
     stream.disconnect();