@absolutejs/voice 0.0.22-beta.655 → 0.0.22-beta.657

package/dist/react/index.js

@@ -11442,11 +11442,19 @@ 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;
 var computeVoiceReconnectDelayMs = (attempt, baseMs, maxDelayMs) => Math.min(maxDelayMs, baseMs * 2 ** (Math.max(1, attempt) - 1));
 var DEFAULT_SCENARIO_QUERY_PARAM = "scenarioId";
+
+class VoiceReconnectRejectedError extends Error {
+  constructor(message = "Voice authorization could not be renewed.") {
+    super(message);
+    this.name = "VoiceReconnectRejectedError";
+  }
+}
 var noop = () => {};
 var noopAsync = () => Promise.resolve();
 var noopUnsubscribe = () => noop;
@@ -11526,6 +11534,9 @@ var createVoiceConnection = (path, options = {}) => {
   const reconnectMaxDelayMs = options.reconnectMaxDelayMs ?? DEFAULT_RECONNECT_MAX_DELAY_MS;
   const pingInterval = options.pingInterval ?? DEFAULT_PING_INTERVAL;
   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,
@@ -11589,6 +11600,9 @@ var createVoiceConnection = (path, options = {}) => {
     pendingCallControls.clear();
   };
   const scheduleReconnect = () => {
+    if (disposed)
+      return;
+    const scheduledGeneration = lifecycleGeneration;
     state.reconnectAttempts += 1;
     const delayMs = computeReconnectDelayMs(state.reconnectAttempts);
     const nextAttemptAt = Date.now() + delayMs;
@@ -11603,18 +11617,44 @@ var createVoiceConnection = (path, options = {}) => {
       type: "connection"
     });
     state.reconnectTimeout = setTimeout(async () => {
+      if (disposed || lifecycleGeneration !== scheduledGeneration)
+        return;
       if (state.reconnectAttempts > maxReconnectAttempts) {
         emitTerminalFailure("Voice connection could not be restored.");
         return;
       }
       try {
-        await options.prepareReconnect?.({
-          attempt: state.reconnectAttempts,
-          path,
-          scenarioId: state.scenarioId,
-          sessionId: state.sessionId
-        });
-      } catch {
+        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;
+        if (error instanceof VoiceReconnectRejectedError) {
+          emitTerminalFailure(error.message);
+          return;
+        }
         if (state.reconnectAttempts < maxReconnectAttempts) {
           scheduleReconnect();
         } else {
@@ -11622,10 +11662,14 @@ var createVoiceConnection = (path, options = {}) => {
         }
         return;
       }
+      if (disposed || lifecycleGeneration !== scheduledGeneration)
+        return;
       connect();
     }, delayMs);
   };
   const connect = () => {
+    if (disposed)
+      return;
     const ws = new WebSocket(buildWsUrl(path, state.sessionId, state.scenarioId, options.query ?? {}));
     ws.binaryType = "arraybuffer";
     ws.onopen = () => {
@@ -11696,6 +11740,7 @@ var createVoiceConnection = (path, options = {}) => {
       state.ws = null;
       state.isConnected = false;
       clearTimers();
+      rejectPendingCallControls("Voice connection interrupted");
       const reconnectable = shouldReconnect && event.code !== WS_NORMAL_CLOSURE && event.code !== WS_UNAUTHORIZED && event.code !== WS_FORBIDDEN && state.reconnectAttempts < maxReconnectAttempts;
       const authorizationFailure = event.code === WS_UNAUTHORIZED || event.code === WS_FORBIDDEN;
       if (authorizationFailure) {
@@ -11726,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;
@@ -11761,6 +11808,9 @@ var createVoiceConnection = (path, options = {}) => {
     send({ type: "end_turn" });
   };
   const callControl = (message) => {
+    if (state.ws?.readyState !== WS_OPEN) {
+      return Promise.reject(new Error(`${message.action} is unavailable while disconnected`));
+    }
     const requestId = crypto.randomUUID();
     const { promise, reject, resolve } = Promise.withResolvers();
     const timeout = setTimeout(() => {
@@ -11768,16 +11818,21 @@ var createVoiceConnection = (path, options = {}) => {
       reject(new Error(`${message.action} acknowledgement timed out`));
     }, DEFAULT_CALL_CONTROL_ACK_TIMEOUT_MS);
     pendingCallControls.set(requestId, { reject, resolve, timeout });
-    send({
+    state.ws.send(JSON.stringify({
       ...message,
       requestId,
       type: "call_control"
-    });
+    }));
     return promise;
   };
   const close = (reason = "client-close") => {
+    disposed = true;
+    reconnectPreparationAbort?.abort();
+    reconnectPreparationAbort = null;
+    lifecycleGeneration += 1;
     clearTimers();
     rejectPendingCallControls("Voice connection closed");
+    state.pendingMessages.length = 0;
     if (state.ws) {
       const ws = state.ws;
       state.ws = null;
@@ -11790,8 +11845,13 @@ var createVoiceConnection = (path, options = {}) => {
     listeners.clear();
   };
   const disconnect = () => {
+    disposed = true;
+    reconnectPreparationAbort?.abort();
+    reconnectPreparationAbort = null;
+    lifecycleGeneration += 1;
     clearTimers();
     rejectPendingCallControls("Voice connection disconnected");
+    state.pendingMessages.length = 0;
     if (state.ws) {
       const ws = state.ws;
       state.ws = null;
@@ -12039,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;
     }
@@ -12098,6 +12161,7 @@ var createVoiceStream = (path, options = {}) => {
       return connection.callControl(message);
     },
     close(reason) {
+      disposed = true;
       unsubscribeConnection();
       browserMediaReporter?.close();
       connection.close(reason);
@@ -12105,6 +12169,7 @@ var createVoiceStream = (path, options = {}) => {
       notify();
     },
     disconnect() {
+      disposed = true;
       unsubscribeConnection();
       browserMediaReporter?.close();
       connection.disconnect();
@@ -12302,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;
@@ -12699,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 = () => {
@@ -12755,6 +12864,7 @@ var createVoiceController = (path, options = {}) => {
     return capture;
   };
   const stopRecording = () => {
+    captureGeneration += 1;
     capture?.stop();
     capture = null;
     state = {
@@ -12764,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();