@simfinity/constellation-react 0.0.1

package/dist/index.js

@@ -0,0 +1,880 @@
+// src/constellationProvider.tsx
+import React, { useEffect, useMemo, useRef as useRef3 } from "react";
+import { WebClient } from "@simfinity/constellation-client";
+
+// src/useAudioPlayback.tsx
+import { useRef, useCallback } from "react";
+
+// src/lib/pcm16.ts
+function float32ToPcm16Base64(float32) {
+  const pcm16 = new Int16Array(float32.length);
+  for (let i = 0; i < float32.length; i++) {
+    const s = Math.max(-1, Math.min(1, float32[i]));
+    pcm16[i] = s < 0 ? s * 32768 : s * 32767;
+  }
+  const bytes = new Uint8Array(pcm16.buffer);
+  let binary = "";
+  for (let i = 0; i < bytes.length; i++) {
+    binary += String.fromCharCode(bytes[i]);
+  }
+  return btoa(binary);
+}
+function pcm16Base64ToFloat32(base64) {
+  const binary = atob(base64);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) {
+    bytes[i] = binary.charCodeAt(i);
+  }
+  const pcm16 = new Int16Array(bytes.buffer);
+  const float32 = new Float32Array(pcm16.length);
+  for (let i = 0; i < pcm16.length; i++) {
+    float32[i] = pcm16[i] / (pcm16[i] < 0 ? 32768 : 32767);
+  }
+  return float32;
+}
+
+// src/lib/stateStore.ts
+var StateStore = class {
+  constructor(state) {
+    this.state = state;
+    this.listeners = /* @__PURE__ */ new Set();
+    this.subscribe = (listener) => {
+      this.listeners.add(listener);
+      return () => this.listeners.delete(listener);
+    };
+  }
+  update(patch) {
+    this.state = { ...this.state, ...patch };
+    this.listeners.forEach((l) => l());
+  }
+  get snapshot() {
+    return this.state;
+  }
+};
+
+// src/useAudioPlayback.tsx
+var PLAYBACK_SAMPLE_RATE = 24e3;
+var PREBUFFER_SAMPLES = Math.ceil(PLAYBACK_SAMPLE_RATE * 0.2);
+var PREBUFFER_FLUSH_TIMEOUT_MS = 400;
+function useAudioPlayback() {
+  const stateRef = useRef(new StateStore({ playing: false }));
+  const contextRef = useRef(null);
+  const queueRef = useRef([]);
+  const sourcesRef = useRef(/* @__PURE__ */ new Set());
+  const nextStartTimeRef = useRef(0);
+  const playbackStartTimeRef = useRef(null);
+  const prebufferRef = useRef([]);
+  const prebufferedSamplesRef = useRef(0);
+  const isPreBufferingRef = useRef(false);
+  const prebufferFlushTimerRef = useRef(null);
+  const getContext = useCallback(() => {
+    if (!contextRef.current || contextRef.current.state === "closed") {
+      contextRef.current = new AudioContext({ sampleRate: PLAYBACK_SAMPLE_RATE });
+    }
+    return contextRef.current;
+  }, []);
+  const scheduleChunk = useCallback((ctx, samples) => {
+    const buffer = ctx.createBuffer(1, samples.length, PLAYBACK_SAMPLE_RATE);
+    buffer.getChannelData(0).set(samples);
+    const source = ctx.createBufferSource();
+    source.buffer = buffer;
+    source.connect(ctx.destination);
+    const startTime = Math.max(ctx.currentTime, nextStartTimeRef.current);
+    source.start(startTime);
+    sourcesRef.current.add(source);
+    nextStartTimeRef.current = startTime + buffer.duration;
+    source.onended = () => {
+      sourcesRef.current.delete(source);
+      if (ctx.currentTime >= nextStartTimeRef.current - 0.01) {
+        playbackStartTimeRef.current = null;
+        stateRef.current.update({ playing: false });
+      }
+    };
+  }, []);
+  const flushPrebuffer = useCallback((ctx) => {
+    if (prebufferFlushTimerRef.current !== null) {
+      clearTimeout(prebufferFlushTimerRef.current);
+      prebufferFlushTimerRef.current = null;
+    }
+    isPreBufferingRef.current = false;
+    nextStartTimeRef.current = ctx.currentTime;
+    for (const bufferedSamples of prebufferRef.current) {
+      scheduleChunk(ctx, bufferedSamples);
+    }
+    prebufferRef.current = [];
+    prebufferedSamplesRef.current = 0;
+  }, [scheduleChunk]);
+  const enqueue = useCallback((base64Chunk) => {
+    const samples = pcm16Base64ToFloat32(base64Chunk);
+    const ctx = getContext();
+    const isSilent = !isPreBufferingRef.current && sourcesRef.current.size === 0 && ctx.currentTime >= nextStartTimeRef.current - 0.01;
+    const flushPreBufferOrScheduleTimeout = () => {
+      if (prebufferedSamplesRef.current >= PREBUFFER_SAMPLES) {
+        flushPrebuffer(ctx);
+        return;
+      }
+      if (prebufferFlushTimerRef.current !== null) {
+        clearTimeout(prebufferFlushTimerRef.current);
+      }
+      prebufferFlushTimerRef.current = setTimeout(() => {
+        prebufferFlushTimerRef.current = null;
+        if (isPreBufferingRef.current && prebufferRef.current.length > 0) {
+          flushPrebuffer(getContext());
+        }
+      }, PREBUFFER_FLUSH_TIMEOUT_MS);
+    };
+    if (isSilent) {
+      isPreBufferingRef.current = true;
+      prebufferRef.current = [samples];
+      prebufferedSamplesRef.current = samples.length;
+      playbackStartTimeRef.current = performance.now();
+      stateRef.current.update({ playing: true });
+      flushPreBufferOrScheduleTimeout();
+      return;
+    }
+    if (isPreBufferingRef.current) {
+      prebufferRef.current.push(samples);
+      prebufferedSamplesRef.current += samples.length;
+      flushPreBufferOrScheduleTimeout();
+      return;
+    }
+    scheduleChunk(ctx, samples);
+    if (!playbackStartTimeRef.current) {
+      playbackStartTimeRef.current = performance.now();
+      stateRef.current.update({ playing: true });
+    }
+  }, [getContext, scheduleChunk, flushPrebuffer]);
+  const clearQueue = useCallback((minPlaybackDurationMs) => {
+    const ctx = contextRef.current;
+    const playbackDurationMs = getPlayingDurationMs();
+    if (minPlaybackDurationMs && playbackDurationMs <= minPlaybackDurationMs) {
+      return;
+    }
+    sourcesRef.current.forEach((source) => {
+      try {
+        source.stop(0);
+      } catch {
+      }
+    });
+    sourcesRef.current.clear();
+    if (ctx) {
+      nextStartTimeRef.current = ctx.currentTime;
+    } else {
+      nextStartTimeRef.current = 0;
+    }
+    if (prebufferFlushTimerRef.current !== null) {
+      clearTimeout(prebufferFlushTimerRef.current);
+      prebufferFlushTimerRef.current = null;
+    }
+    isPreBufferingRef.current = false;
+    prebufferRef.current = [];
+    prebufferedSamplesRef.current = 0;
+    playbackStartTimeRef.current = null;
+    stateRef.current.update({ playing: false });
+  }, []);
+  const release = useCallback(async () => {
+    if (prebufferFlushTimerRef.current !== null) {
+      clearTimeout(prebufferFlushTimerRef.current);
+      prebufferFlushTimerRef.current = null;
+    }
+    if (contextRef.current && contextRef.current.state !== "closed") {
+      await contextRef.current.close();
+      contextRef.current = null;
+    }
+    queueRef.current = [];
+    isPreBufferingRef.current = false;
+    prebufferRef.current = [];
+    prebufferedSamplesRef.current = 0;
+    nextStartTimeRef.current = 0;
+    playbackStartTimeRef.current = null;
+    stateRef.current.update({ playing: false });
+  }, []);
+  const getPlayingDurationMs = useCallback(() => {
+    return isPreBufferingRef.current || !playbackStartTimeRef.current ? Infinity : performance.now() - playbackStartTimeRef.current;
+  }, []);
+  return {
+    sampleRate: PLAYBACK_SAMPLE_RATE,
+    preBufferDurationsMs: PREBUFFER_SAMPLES,
+    enqueue,
+    clearQueue,
+    release,
+    getPlayingDurationMs,
+    subscribeState: stateRef.current.subscribe,
+    getState: () => stateRef.current.snapshot
+  };
+}
+
+// src/useAudioCapture.tsx
+import { useRef as useRef2, useCallback as useCallback2 } from "react";
+
+// src/lib/audioRingBuffer.ts
+var VadState = {
+  Idle: 0,
+  PreSpeech: 1,
+  // noise candidate
+  Speaking: 2,
+  // confirmed speech
+  PostSpeech: 3
+  // silence after speech
+};
+var AudioRingBufferConstants = {
+  /**
+   * Number of speech-chunks before the early speech signal is fired.
+   */
+  preSpeechEarlySignalChunksCount: 2,
+  /**
+   * Number of silence-chunks before the pre-speech state fails & return to idle.
+   */
+  preSpeechSilenceChunksDebounceCount: 10,
+  /**
+   * Silence duration allowed before transitioning from Speaking to Post-Speech state.
+   * Expressed in % of total silence allowed before end-of-speech i.e. RingBufferConfig.silenceDurationMs.
+   *
+   * @remarks
+   * This does not delay end-of-speech, the amount of time waited before transitioning to post-speech is
+   * transferred to the post-speech state. Thus, a value of 0.5 here for a silence duration of 1s means that the
+   * post-speech silence only has to last 500ms, having already waited 500ms before leaving Speaking state.
+   *
+   * TODO: consider exposing this as setting
+   */
+  speechSilenceThresholdPercent: 0.5,
+  /**
+   * RMS detection stabilizer:
+   * Very important with fine-grained chunks (AudioWorklet typically have ~8ms chunks):
+   * The subtleties of the human voice are reflected in the chunks, having many ups and down
+   * with very short silence or near silence gaps.
+   *
+   * @remarks
+   * Smaller is smoother with more lag, higher is more responsive but jumpy.
+   */
+  rmsSmoothing: 0.3
+};
+var AudioRingBuffer = class {
+  constructor(config) {
+    this.consts = AudioRingBufferConstants;
+    this.chunkDuration = 8;
+    this.buffer = [];
+    this.smoothedRms = 0;
+    // -- State machine
+    this.state = VadState.Idle;
+    // Current stage
+    this.readIndex = 0;
+    // Streaming cursor: consumer read new data start here
+    // Stage index trackers
+    this.globalIndex = 0;
+    // Global/absolute chunk index counter, goes beyond buffer boundaries
+    this.globalBufferStartIndex = 0;
+    // The global index of this.buffer[0]
+    this.speechStartIndex = 0;
+    // Global index of when confirmed speech started
+    // Not used for now, but might become useful in future features
+    //private silenceStartIndex = 0; // Global index of when post-speech silence started
+    // -- State transition counters
+    // [Post-Speech Silence] count consequence silence chunks (in post-speech)
+    this.silenceChunkCount = 0;
+    // [Post-Speech Silence] For confirmed silence, add a short debounce period to go back to speaking
+    this.silenceDebounceStartIndex = 0;
+    // [Post-Speech Silence] In silence debounce, queue a pending commit
+    this.pendingCommit = false;
+    // [Pre-Speech] In Pre-Speech add short debounce to not reset on first silence
+    this.preSpeechSilenceChunks = 0;
+    // [Speaking] Count consecutive speech chunks
+    this.speechChunkCount = 0;
+    // [Speaking] Early signal speech-start, before confirmed speech
+    this.speechStartSignaled = false;
+    this.config = config;
+    this.maxChunks = Math.ceil(config.maxDurationMs / this.chunkDuration);
+  }
+  /**
+   * Wipes internal state and speech tracking, the ring buffer remains
+   * ready to be filled again, only starting from a blank page.s
+   */
+  forceResetState() {
+    this.reset();
+  }
+  /**
+   * Returns chunks that should be streamed NOW
+   */
+  consume() {
+    if (this.state === VadState.Idle || this.state === VadState.PreSpeech) {
+      return [];
+    }
+    const out = [];
+    while (this.readIndex < this.globalIndex) {
+      const index = this.readIndex - this.globalBufferStartIndex;
+      if (index >= 0 && index < this.buffer.length) {
+        out.push(this.buffer[index].data);
+      }
+      this.readIndex++;
+    }
+    return out;
+  }
+  /**
+   * Push a new chunk of data into the ring buffer
+   * @param chunk
+   */
+  push(chunk) {
+    this.buffer.push(chunk);
+    this.globalIndex++;
+    if (this.buffer.length > this.maxChunks) {
+      this.buffer.shift();
+      this.globalBufferStartIndex++;
+      if (this.readIndex < this.globalBufferStartIndex) {
+        this.readIndex = this.globalBufferStartIndex;
+      }
+    }
+    this.updateSmoothRms(chunk.rms);
+    this.updateState();
+  }
+  // --- Getters
+  get speaking() {
+    return this.state === VadState.Speaking;
+  }
+  get stateName() {
+    return this.state;
+  }
+  // --- Setters
+  set chunkDurationMs(duration) {
+    this.chunkDuration = duration;
+    this.maxChunks = Math.ceil(this.config.maxDurationMs / this.chunkDuration);
+  }
+  // --- Private API ---
+  updateState() {
+    var _a, _b, _c;
+    const log = (message) => {
+      console.log(`${Date.now() % 1e5} - ${message}`);
+    };
+    const isSpeech = this.smoothedRms > this.config.silenceThreshold;
+    switch (this.state) {
+      case VadState.Idle:
+        if (isSpeech) {
+          log("[AudioBuffer] [Idle] Entering Pre-Speech state");
+          this.state = VadState.PreSpeech;
+          this.speechStartIndex = this.globalIndex;
+          this.readIndex = this.speechStartIndex;
+          this.speechChunkCount = 1;
+          this.speechStartSignaled = false;
+        }
+        break;
+      case VadState.PreSpeech:
+        if (isSpeech) {
+          this.preSpeechSilenceChunks = 0;
+          this.speechChunkCount++;
+          if (!this.speechStartSignaled && this.speechChunkCount >= this.consts.preSpeechEarlySignalChunksCount) {
+            (_a = this.onSpeechStart) == null ? void 0 : _a.call(this, "early");
+            this.speechStartSignaled = true;
+          }
+          if (this.speechChunkCount * this.chunkDuration >= this.config.minSpeechDurationMs) {
+            log("[AudioBuffer] [Pre-Speech] Entering Speaking state");
+            this.state = VadState.Speaking;
+            (_b = this.onSpeechStart) == null ? void 0 : _b.call(this, "confirmed");
+          }
+        } else {
+          this.preSpeechSilenceChunks++;
+          if (this.preSpeechSilenceChunks > this.consts.preSpeechSilenceChunksDebounceCount) {
+            log("[AudioBuffer] [Pre-Speech] Debounce failed");
+            this.reset();
+          }
+        }
+        break;
+      case VadState.Speaking:
+        if (isSpeech) {
+          this.silenceChunkCount = 0;
+        } else {
+          this.silenceChunkCount++;
+          const silenceDuration = this.silenceChunkCount * this.chunkDuration;
+          if (silenceDuration >= this.config.silenceDurationMs * this.consts.speechSilenceThresholdPercent) {
+            log("[AudioBuffer] [Speaking] Speaking silence threshold reached, entering Post-Speech state");
+            this.state = VadState.PostSpeech;
+          }
+        }
+        break;
+      case VadState.PostSpeech:
+        if (isSpeech) {
+          log("[AudioBuffer] [Post-Speech] Speech detected, reverting to Speaking state");
+          this.state = VadState.Speaking;
+          this.silenceChunkCount = 0;
+          this.pendingCommit = false;
+        } else {
+          this.silenceChunkCount++;
+          const silenceDuration = this.silenceChunkCount * this.chunkDuration;
+          if (!this.pendingCommit) {
+            if (silenceDuration >= this.config.silenceDurationMs) {
+              log("[AudioBuffer] [Post-Speech] Silence debounce state");
+              this.pendingCommit = true;
+              this.silenceDebounceStartIndex = this.globalIndex;
+            }
+          } else {
+            const debounceDuration = this.durationSince(this.silenceDebounceStartIndex);
+            if (debounceDuration >= this.config.silenceDebounceMs) {
+              log("[AudioBuffer] [Post-Speech] Silence debounce passed");
+              (_c = this.onCommit) == null ? void 0 : _c.call(this);
+              this.reset();
+            }
+          }
+        }
+        break;
+    }
+  }
+  durationSince(startIndex) {
+    return (this.globalIndex - startIndex) * this.chunkDuration;
+  }
+  updateSmoothRms(rms) {
+    this.smoothedRms = this.consts.rmsSmoothing * rms + (1 - this.consts.rmsSmoothing) * this.smoothedRms;
+  }
+  reset() {
+    this.state = VadState.Idle;
+    this.speechStartIndex = 0;
+    this.silenceChunkCount = 0;
+    this.pendingCommit = false;
+    this.silenceDebounceStartIndex = 0;
+    this.preSpeechSilenceChunks = 0;
+    this.readIndex = this.globalIndex;
+  }
+};
+
+// src/lib/rms.ts
+function computeRms(samples) {
+  let sum = 0;
+  for (let i = 0; i < samples.length; i++) {
+    sum += samples[i] * samples[i];
+  }
+  return Math.sqrt(sum / samples.length);
+}
+
+// src/useAudioCapture.tsx
+var workletCode = `
+class CaptureProcessor extends AudioWorkletProcessor {
+  process(inputs) {
+    const input = inputs[0];
+    if (input && input[0]) {
+      // Send Float32Array to main thread
+      this.port.postMessage(input[0]);
+    }
+    return true;
+  }
+}
+
+registerProcessor('capture-processor', CaptureProcessor);
+`;
+var SAMPLE_RATE = 24e3;
+var SILENCE_THRESHOLD = 0.04;
+var SILENCE_DURATION_MS = 1e3;
+var MIN_SPEECH_DURATION_MS = 200;
+var AudioCaptureConfig = class {
+  constructor() {
+    this.sampleRate = SAMPLE_RATE;
+    /**
+     * Minimum amount of energy for a noise to be considered as actual input and be recorded.
+     *  - Below it, audio data is silently discarded
+     *  - Above it, onAudioChunk events containing the audio stream will be fired
+     *
+     *  @remarks
+     *  This is the main parameter for noise-cancelling
+     */
+    this.silenceThreshold = SILENCE_THRESHOLD;
+    /**
+     * Once an input was detected, this is the duration of silence required before
+     * detecting the end-of-speech and triggering the onSilenceCommit event.
+     *
+     * IMPORTANT:
+     * Internally, duration is computed on audio chunks count, not system clock.
+     * A chunk is usually 8ms, therefore to see the effect of a silence duration change, it must be
+     * such that the number of chunks count changes e.g. going from 800ms to 810ms increases
+     * the chunk count by one.
+     *
+     * @remarks
+     * This is the main voice-activation-detection parameter.
+     */
+    this.silenceDurationMs = SILENCE_DURATION_MS;
+    /**
+     * Minimum input duration: below it, an input will not trigger an onSilenceCommit event.
+     *
+     * @remarks
+     * This is an important interruption parameter: it prevents very short inputs from
+     * interrupting an ongoing audio response.
+     */
+    this.minSpeechDurationMs = MIN_SPEECH_DURATION_MS;
+  }
+};
+function useAudioCapture() {
+  const stateRef = useRef2(new StateStore({
+    recording: false,
+    speaking: false,
+    muted: false
+  }));
+  const configRef = useRef2(new AudioCaptureConfig());
+  const mediaStreamRef = useRef2(null);
+  const contextRef = useRef2(null);
+  const sourceRef = useRef2(null);
+  const workletUrlRef = useRef2(null);
+  const workletNodeRef = useRef2(null);
+  const audioCallbackRef = useRef2(null);
+  const commitCallbackRef = useRef2(null);
+  const speechEarlyRef = useRef2(null);
+  const speechConfirmedRef = useRef2(null);
+  const ringRef = useRef2(null);
+  const chunkDurationMsRef = useRef2(0);
+  const configure = useCallback2((settings) => {
+    configRef.current = settings;
+  }, []);
+  const start = useCallback2(async (params) => {
+    var _a, _b, _c;
+    await stop();
+    try {
+      audioCallbackRef.current = params.onAudioChunk;
+      commitCallbackRef.current = (_a = params.onSilenceCommit) != null ? _a : null;
+      speechEarlyRef.current = (_b = params.onSpeechConsidered) != null ? _b : null;
+      speechConfirmedRef.current = (_c = params.onSpeechConfirmed) != null ? _c : null;
+      const stream = await navigator.mediaDevices.getUserMedia({
+        audio: {
+          sampleRate: configRef.current.sampleRate,
+          channelCount: 1,
+          echoCancellation: true,
+          noiseSuppression: true
+        }
+      });
+      mediaStreamRef.current = stream;
+      const audioContext = new AudioContext({ sampleRate: configRef.current.sampleRate });
+      contextRef.current = audioContext;
+      const source = audioContext.createMediaStreamSource(stream);
+      sourceRef.current = source;
+      const ringDuration = 1.25 * configRef.current.minSpeechDurationMs + configRef.current.silenceDurationMs;
+      ringRef.current = new AudioRingBuffer({
+        maxDurationMs: ringDuration,
+        silenceThreshold: configRef.current.silenceThreshold,
+        minSpeechDurationMs: configRef.current.minSpeechDurationMs,
+        silenceDurationMs: configRef.current.silenceDurationMs,
+        silenceDebounceMs: 350
+      });
+      ringRef.current.onCommit = () => {
+        var _a2;
+        console.log("[Audio] Commit triggered");
+        stateRef.current.update({ speaking: false });
+        (_a2 = commitCallbackRef.current) == null ? void 0 : _a2.call(commitCallbackRef);
+      };
+      ringRef.current.onSpeechStart = (stage) => {
+        var _a2, _b2;
+        if (stage === "early") {
+          (_a2 = speechEarlyRef.current) == null ? void 0 : _a2.call(speechEarlyRef);
+        }
+        if (stage === "confirmed") {
+          (_b2 = speechConfirmedRef.current) == null ? void 0 : _b2.call(speechConfirmedRef);
+        }
+      };
+      const onAudioChunkReceived = (inputData) => {
+        var _a2;
+        if (stateRef.current.snapshot.muted) {
+          if (stateRef.current.snapshot.speaking) {
+            stateRef.current.update({ speaking: false });
+          }
+          return;
+        }
+        const rms = computeRms(inputData);
+        const chunkBase64 = float32ToPcm16Base64(inputData);
+        const ring = ringRef.current;
+        if (!ring) return;
+        const originalState = ring.stateName;
+        ring.push({ data: chunkBase64, rms });
+        if (ring.speaking && !stateRef.current.snapshot.speaking) {
+          stateRef.current.update({ speaking: true });
+        }
+        const chunksToSend = ring.consume();
+        for (const chunk of chunksToSend) {
+          (_a2 = audioCallbackRef.current) == null ? void 0 : _a2.call(audioCallbackRef, chunk);
+        }
+        if (originalState !== ring.stateName) {
+          console.log("[Audio]", { state: ring.stateName, speaking: ring.speaking });
+        }
+      };
+      const blob = new Blob([workletCode], { type: "application/javascript" });
+      const url = URL.createObjectURL(blob);
+      workletUrlRef.current = url;
+      await audioContext.audioWorklet.addModule(url);
+      const workletNode = new AudioWorkletNode(audioContext, "capture-processor");
+      workletNodeRef.current = workletNode;
+      workletNode.port.onmessage = (event) => {
+        const inputData = event.data;
+        if (!chunkDurationMsRef.current) {
+          chunkDurationMsRef.current = inputData.length / configRef.current.sampleRate * 1e3;
+          if (ringRef.current) {
+            ringRef.current.chunkDurationMs = chunkDurationMsRef.current;
+          }
+          console.log("[AudioCapture] chunkDurationMs =", chunkDurationMsRef.current);
+        }
+        onAudioChunkReceived(inputData);
+      };
+      source.connect(workletNode);
+      workletNode.connect(audioContext.destination);
+      stateRef.current.update({ recording: true });
+    } catch (ex) {
+      await stop();
+      throw ex;
+    }
+  }, []);
+  const stop = useCallback2(async () => {
+    try {
+      if (mediaStreamRef.current) {
+        mediaStreamRef.current.getTracks().forEach((t) => t.stop());
+      }
+      if (sourceRef.current) {
+        sourceRef.current.disconnect();
+      }
+      if (workletNodeRef.current) {
+        workletNodeRef.current.port.onmessage = null;
+        workletNodeRef.current = null;
+      }
+      if (contextRef.current) {
+        await contextRef.current.close();
+      }
+      sourceRef.current = null;
+      contextRef.current = null;
+      mediaStreamRef.current = null;
+      audioCallbackRef.current = null;
+      commitCallbackRef.current = null;
+      speechEarlyRef.current = null;
+      speechConfirmedRef.current = null;
+      chunkDurationMsRef.current = 0;
+      ringRef.current = null;
+      stateRef.current.update({ recording: false, speaking: false });
+    } finally {
+      if (workletUrlRef.current) {
+        URL.revokeObjectURL(workletUrlRef.current);
+        workletUrlRef.current = null;
+      }
+    }
+  }, []);
+  const setMuted = useCallback2((muted) => {
+    if (!stateRef.current.snapshot.muted && muted) {
+      if (ringRef.current) {
+        ringRef.current.forceResetState();
+      }
+    }
+    if (stateRef.current.snapshot.muted != muted) {
+      const speaking = muted ? false : stateRef.current.snapshot.speaking;
+      stateRef.current.update({ muted, speaking });
+    }
+  }, []);
+  return {
+    start,
+    stop,
+    configure,
+    setMuted,
+    subscribeState: stateRef.current.subscribe,
+    getState: () => stateRef.current.snapshot
+  };
+}
+
+// src/constellationProvider.tsx
+import { jsx } from "react/jsx-runtime";
+var ConstellationContext = React.createContext(null);
+function ConstellationProvider({ config, children }) {
+  const clientRef = useRef3(null);
+  if (!clientRef.current) {
+    clientRef.current = new WebClient(config);
+  }
+  const audioPlayback = useAudioPlayback();
+  const audioCapture = useAudioCapture();
+  const value = useMemo(() => ({
+    client: clientRef.current,
+    audioPlayback,
+    audioCapture
+  }), [audioPlayback, audioCapture]);
+  useEffect(() => {
+    return () => {
+      var _a, _b;
+      (_b = (_a = clientRef.current) == null ? void 0 : _a.closeStream) == null ? void 0 : _b.call(_a);
+      void audioCapture.stop();
+      void audioPlayback.release();
+    };
+  }, [audioCapture, audioPlayback]);
+  return /* @__PURE__ */ jsx(ConstellationContext.Provider, { value, children });
+}
+
+// src/useConstellationSession.tsx
+import { useCallback as useCallback3, useContext, useEffect as useEffect2, useMemo as useMemo2, useRef as useRef4, useState } from "react";
+import {
+  WebClientEvents
+} from "@simfinity/constellation-client";
+function handleResponsePacket(event, handlers, enqueueAudio) {
+  var _a, _b, _c, _d, _e, _f;
+  const data = event.data;
+  if (data.audio) {
+    if (data.audio.data !== "") {
+      enqueueAudio(data.audio.data);
+    }
+    if (data.audio.done) {
+    }
+  }
+  if (data.transcript) {
+    if (data.transcript.input) {
+      if (data.transcript.input.done) {
+        (_a = handlers.onTranscriptInput) == null ? void 0 : _a.call(handlers, data.transcript.input.text);
+      } else {
+        (_b = handlers.onTranscriptInputPart) == null ? void 0 : _b.call(handlers, data.transcript.input.text, data.transcript.input.done);
+      }
+    }
+    if (data.transcript.response) {
+      if (data.transcript.response.done) {
+        (_c = handlers.onTranscriptResponse) == null ? void 0 : _c.call(handlers, data.transcript.response.text);
+      } else {
+        (_d = handlers.onTranscriptResponsePart) == null ? void 0 : _d.call(handlers, data.transcript.response.text, data.transcript.response.done);
+      }
+    }
+  }
+  if (data.done) {
+    (_f = handlers.onResponseEnd) == null ? void 0 : _f.call(handlers, (_e = data.canceled) != null ? _e : false);
+  }
+}
+function useConstellationSession() {
+  const ctx = useContext(ConstellationContext);
+  if (!ctx) throw new Error("Must be used inside ConstellationProvider");
+  const [sessionId, setSessionId] = useState(null);
+  const unsubscribersRef = useRef4([]);
+  const clearEventSubscriptions = useCallback3(() => {
+    for (const unsubscribe of unsubscribersRef.current) {
+      unsubscribe();
+    }
+    unsubscribersRef.current = [];
+  }, []);
+  useEffect2(() => {
+    return () => clearEventSubscriptions();
+  }, [clearEventSubscriptions]);
+  return useMemo2(() => ({
+    startSession: async (params) => {
+      await ctx.client.startSession(params);
+      setSessionId(ctx.client.session);
+    },
+    endSession: async () => {
+      clearEventSubscriptions();
+      const stats = await ctx.client.endSession();
+      setSessionId(null);
+      ctx.audioCapture.stop();
+      ctx.audioPlayback.release();
+      return stats;
+    },
+    joinSession: async (audio, handlers) => {
+      clearEventSubscriptions();
+      unsubscribersRef.current.push(
+        ctx.client.on(WebClientEvents.SystemConnectionClosed, (e) => {
+          var _a;
+          handlers.onStreamClosed((_a = e.data.reason) != null ? _a : "");
+        })
+      );
+      unsubscribersRef.current.push(
+        ctx.client.on(WebClientEvents.ResponsePacket, (e) => {
+          handleResponsePacket(e, handlers, ctx.audioPlayback.enqueue);
+        })
+      );
+      if (handlers.onLatencyUpdate) {
+        unsubscribersRef.current.push(
+          ctx.client.on(WebClientEvents.SystemLatency, (e) => {
+            var _a;
+            (_a = handlers.onLatencyUpdate) == null ? void 0 : _a.call(handlers, e.data.latencyMs);
+          })
+        );
+      }
+      if (handlers.onSessionConfigured) {
+        unsubscribersRef.current.push(
+          ctx.client.on(WebClientEvents.SessionConfigured, (e) => {
+            var _a;
+            (_a = handlers.onSessionConfigured) == null ? void 0 : _a.call(handlers, e.data);
+          })
+        );
+      }
+      if (handlers.onAgentResponse) {
+        unsubscribersRef.current.push(
+          ctx.client.on(WebClientEvents.AgentResponse, (e) => {
+            var _a;
+            (_a = handlers.onAgentResponse) == null ? void 0 : _a.call(handlers, e.data);
+          })
+        );
+      }
+      if (handlers.onClientAction) {
+        unsubscribersRef.current.push(
+          ctx.client.on(WebClientEvents.ClientAction, (e) => {
+            var _a;
+            (_a = handlers.onClientAction) == null ? void 0 : _a.call(handlers, e.data.action, e.data.payload);
+          })
+        );
+      }
+      if (handlers.onTechnicalError) {
+        unsubscribersRef.current.push(
+          ctx.client.on(WebClientEvents.TechnicalError, (e) => {
+            var _a;
+            (_a = handlers.onTechnicalError) == null ? void 0 : _a.call(handlers, e.data.error);
+          })
+        );
+      }
+      try {
+        await ctx.client.joinSession(
+          audio
+          /*, { ...handlers, onAudioResponseChunk: (chunk: string) => { ctx.audioPlayback.enqueue(chunk); }}*/
+        );
+      } catch (ex) {
+        clearEventSubscriptions();
+        throw ex;
+      }
+    },
+    configureSession: (settings) => {
+      ctx.client.configureSession(settings);
+    },
+    sendText: (text) => {
+      ctx.client.sendText(text);
+    },
+    sendWhisper: (text) => {
+      ctx.client.sendWhisper(text);
+    },
+    audioDevice: () => ({
+      in: {
+        start: async () => {
+          const captureParams = {
+            onSpeechConsidered: () => {
+            },
+            onSpeechConfirmed: () => ctx.audioPlayback.clearQueue(),
+            onAudioChunk: (chunk) => ctx.client.sendAudioChunk(chunk),
+            onSilenceCommit: () => ctx.client.commitAudioChunks()
+          };
+          await ctx.audioCapture.start(captureParams);
+        },
+        stop: async () => {
+          await ctx.audioCapture.stop();
+        },
+        setMuted: (muted) => {
+          ctx.audioCapture.setMuted(muted);
+        }
+      },
+      out: {}
+    }),
+    sessionId
+  }), [ctx, sessionId]);
+}
+
+// src/useAudioPlaybackState.tsx
+import { useContext as useContext2, useSyncExternalStore } from "react";
+function useAudioPlaybackState(selector) {
+  const ctx = useContext2(ConstellationContext);
+  if (!ctx) throw new Error("Must be used inside ConstellationProvider");
+  return useSyncExternalStore(
+    ctx.audioPlayback.subscribeState,
+    () => selector(ctx.audioPlayback.getState())
+  );
+}
+
+// src/useAudioCaptureState.tsx
+import { useContext as useContext3, useSyncExternalStore as useSyncExternalStore2 } from "react";
+function useAudioCaptureState(selector) {
+  const ctx = useContext3(ConstellationContext);
+  if (!ctx) throw new Error("Must be used inside ConstellationProvider");
+  return useSyncExternalStore2(
+    ctx.audioCapture.subscribeState,
+    () => selector(ctx.audioCapture.getState())
+  );
+}
+export {
+  AudioCaptureConfig,
+  ConstellationProvider,
+  useAudioCaptureState,
+  useAudioPlaybackState,
+  useConstellationSession
+};