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

package/dist/client/index.js

@@ -110,6 +110,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;
@@ -203,6 +204,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,
@@ -290,12 +292,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;
@@ -419,6 +439,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;
@@ -473,6 +495,8 @@ var createVoiceConnection = (path, options = {}) => {
   };
   const close = (reason = "client-close") => {
     disposed = true;
+    reconnectPreparationAbort?.abort();
+    reconnectPreparationAbort = null;
     lifecycleGeneration += 1;
     clearTimers();
     rejectPendingCallControls("Voice connection closed");
@@ -490,6 +514,8 @@ var createVoiceConnection = (path, options = {}) => {
   };
   const disconnect = () => {
     disposed = true;
+    reconnectPreparationAbort?.abort();
+    reconnectPreparationAbort = null;
     lifecycleGeneration += 1;
     clearTimers();
     rejectPendingCallControls("Voice connection disconnected");
@@ -1663,7 +1689,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;
     }
@@ -1722,6 +1751,7 @@ var createVoiceStream = (path, options = {}) => {
       return connection.callControl(message);
     },
     close(reason) {
+      disposed = true;
       unsubscribeConnection();
       browserMediaReporter?.close();
       connection.close(reason);
@@ -1729,6 +1759,7 @@ var createVoiceStream = (path, options = {}) => {
       notify();
     },
     disconnect() {
+      disposed = true;
       unsubscribeConnection();
       browserMediaReporter?.close();
       connection.disconnect();
@@ -1887,48 +1918,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;
@@ -2284,6 +2356,9 @@ var createVoiceController = (path, options = {}) => {
     ...options.connection
   });
   let capture = null;
+  let captureGeneration = 0;
+  let disposed = false;
+  let startRecordingPromise = null;
   let state = createInitialState3(stream);
   const subscribers = new Set;
   const notify = () => {
@@ -2340,6 +2415,7 @@ var createVoiceController = (path, options = {}) => {
     return capture;
   };
   const stopRecording = () => {
+    captureGeneration += 1;
     capture?.stop();
     capture = null;
     state = {
@@ -2349,39 +2425,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();

package/dist/core/types.d.ts

@@ -1367,7 +1367,11 @@ export type VoiceConnectionOptions = {
         path: string;
         scenarioId: string | null;
         sessionId: string;
+        signal: AbortSignal;
     }) => Promise<void> | void;
+    /** Maximum time allowed for one prepareReconnect hook. A hook that exceeds
+     * this deadline is aborted and consumes the attempt. Default 10000. */
+    prepareReconnectTimeoutMs?: number;
     pingInterval?: number;
     /** Additional query values sent on every initial or reconnecting socket. */
     query?: Record<string, string>;