@backbay/glia-agent 0.1.0

package/dist/chunk-XE2IVCKJ.js

@@ -0,0 +1,743 @@
+// src/audio/types.ts
+var DEFAULT_TARGET_AVO = {
+  // Match the emotion system's "idle" anchor for a stable neutral baseline.
+  arousal: 0.25,
+  valence: 0.6,
+  openness: 0.35
+};
+function clamp01(value) {
+  return Math.max(0, Math.min(1, value));
+}
+function createTraceId() {
+  if (typeof crypto !== "undefined" && "randomUUID" in crypto) {
+    return crypto.randomUUID();
+  }
+  return `trace_${Date.now()}_${Math.random().toString(16).slice(2)}`;
+}
+
+// src/audio/schema.ts
+import { z } from "zod";
+var AudioProofVersionSchema = z.enum(["1.0"]);
+var AudioFormatSchema = z.enum(["wav", "pcm_s16le", "opus", "mp3", "flac"]);
+var VoiceLicenseCategorySchema = z.enum(["cc0", "cc-by", "cc-by-nc", "custom", "unknown"]);
+var AvoSchema = z.object({
+  valence: z.number().min(0).max(1),
+  arousal: z.number().min(0).max(1),
+  openness: z.number().min(0).max(1)
+});
+var AudioArtifactSchema = z.object({
+  id: z.string().min(1),
+  uri: z.string().optional(),
+  format: AudioFormatSchema,
+  sha256: z.string().min(32),
+  sampleRateHz: z.number().int().min(8e3).optional(),
+  channels: z.number().int().min(1).max(8).optional(),
+  durationMs: z.number().int().min(1)
+});
+var AudioGateResultSchema = z.object({
+  passed: z.boolean(),
+  metrics: z.record(z.string(), z.unknown()).optional(),
+  reason: z.string().optional()
+});
+var AudioGatesSchema = z.object({
+  quality: AudioGateResultSchema,
+  semantic: AudioGateResultSchema,
+  affect: AudioGateResultSchema,
+  multimodalConsistency: AudioGateResultSchema.optional(),
+  watermark: AudioGateResultSchema.optional(),
+  speakerConsistency: AudioGateResultSchema.optional(),
+  antiSpoof: AudioGateResultSchema.optional(),
+  mos: AudioGateResultSchema.optional(),
+  safetyText: AudioGateResultSchema.optional(),
+  safetyAudio: AudioGateResultSchema.optional()
+});
+var EvidenceRefSchema = z.object({
+  type: z.enum(["run", "run_receipt", "artifact", "ui"]),
+  runId: z.string().optional(),
+  receiptHash: z.string().optional(),
+  path: z.string().optional(),
+  digest: z.string().optional(),
+  componentId: z.string().optional(),
+  note: z.string().optional()
+});
+var AudioProofSchema = z.object({
+  version: AudioProofVersionSchema,
+  createdAt: z.string().datetime(),
+  manifest: z.object({
+    traceId: z.string().optional(),
+    runId: z.string().optional(),
+    text: z.string().min(1),
+    language: z.string().optional(),
+    targetAffect: AvoSchema,
+    policy: z.object({
+      safetyMode: z.boolean(),
+      trustTier: z.string().optional(),
+      voiceCloningAllowed: z.boolean()
+    }),
+    cognitionSnapshot: z.record(z.string(), z.unknown()).optional()
+  }),
+  proof: z.object({
+    synthesis: z.object({
+      providerId: z.string().min(1),
+      model: z.object({
+        id: z.string().min(1),
+        revision: z.string().optional(),
+        sha256: z.string().optional()
+      }),
+      voice: z.object({
+        voiceId: z.string().min(1),
+        licenseCategory: VoiceLicenseCategorySchema,
+        licenseText: z.string().optional(),
+        source: z.string().optional()
+      }),
+      controls: z.record(z.string(), z.unknown()).optional(),
+      seed: z.number().int().min(0).optional()
+    }),
+    attempts: z.array(
+      z.object({
+        attempt: z.number().int().min(1),
+        artifactRef: z.string().min(1),
+        notes: z.string().optional(),
+        gates: AudioGatesSchema
+      })
+    ).optional(),
+    artifacts: z.array(AudioArtifactSchema).min(1),
+    gates: AudioGatesSchema,
+    evidence: z.array(EvidenceRefSchema).optional()
+  }),
+  verdict: z.object({
+    passed: z.boolean(),
+    reason: z.string().optional(),
+    score: z.number().optional()
+  })
+});
+function validateAudioProof(audioProof) {
+  const result = AudioProofSchema.safeParse(audioProof);
+  if (result.success) {
+    return { success: true, data: result.data };
+  }
+  return { success: false, errors: result.error };
+}
+
+// src/audio/planner.ts
+function pickFirstAllowedVoiceId(voices, allowedVoiceIds) {
+  const list = voices.list();
+  for (const entry of list) {
+    if (!allowedVoiceIds || allowedVoiceIds.includes(entry.voiceId)) {
+      return entry.voiceId;
+    }
+  }
+  return null;
+}
+function pickVoiceId(args) {
+  const { voices, allowedVoiceIds, preferredVoiceId, requiredTag } = args;
+  if (preferredVoiceId) {
+    const entry = voices.get(preferredVoiceId);
+    if (entry && (!allowedVoiceIds || allowedVoiceIds.includes(entry.voiceId))) {
+      if (!requiredTag || (entry.tags ?? []).includes(requiredTag)) {
+        return entry.voiceId;
+      }
+    }
+  }
+  for (const entry of voices.list()) {
+    if (allowedVoiceIds && !allowedVoiceIds.includes(entry.voiceId)) continue;
+    if (requiredTag && !(entry.tags ?? []).includes(requiredTag)) continue;
+    return entry.voiceId;
+  }
+  return null;
+}
+function stripExcessPunctuation(text) {
+  return text.replace(/[!?]{2,}/g, (m) => m[0] ?? "!").replace(/\.{3,}/g, "\u2026");
+}
+function clampTextForSafetyMode(text) {
+  return stripExcessPunctuation(text).replace(/!/g, ".");
+}
+function planSpeech(input) {
+  const {
+    text,
+    language,
+    runId,
+    targetAffect,
+    policy,
+    voices,
+    signals,
+    defaults
+  } = input;
+  const personaDriftRisk = clamp01(signals?.personaDriftRisk ?? 0);
+  const confidence = clamp01(signals?.confidence ?? 0.8);
+  const risk = clamp01(signals?.risk ?? 1 - confidence);
+  const groundedVoiceTag = defaults?.groundedVoiceTag ?? "grounded";
+  const defaultVoiceTag = defaults?.defaultVoiceTag ?? "default";
+  const requireGrounded = policy.safetyMode || personaDriftRisk >= 0.6 || risk >= 0.7 && confidence <= 0.5;
+  const voiceId = (requireGrounded ? pickVoiceId({
+    voices,
+    allowedVoiceIds: policy.allowedVoiceIds,
+    preferredVoiceId: defaults?.voiceId,
+    requiredTag: groundedVoiceTag
+  }) : pickVoiceId({
+    voices,
+    allowedVoiceIds: policy.allowedVoiceIds,
+    preferredVoiceId: defaults?.voiceId,
+    requiredTag: defaultVoiceTag
+  })) ?? pickVoiceId({
+    voices,
+    allowedVoiceIds: policy.allowedVoiceIds,
+    preferredVoiceId: defaults?.voiceId
+  }) ?? pickFirstAllowedVoiceId(voices, policy.allowedVoiceIds);
+  if (!voiceId) {
+    throw new Error("No available voices (voice catalog is empty or policy blocks all voices)");
+  }
+  const baseTemperature = clamp01(defaults?.temperature ?? 0.65);
+  const temperature = requireGrounded ? Math.min(baseTemperature, 0.25) : baseTemperature;
+  const controls = {
+    temperature
+  };
+  const plannedText = policy.safetyMode || personaDriftRisk >= 0.7 ? clampTextForSafetyMode(text) : stripExcessPunctuation(text);
+  return {
+    traceId: createTraceId(),
+    runId,
+    text: plannedText,
+    language,
+    voiceId,
+    targetAffect: targetAffect ?? DEFAULT_TARGET_AVO,
+    controls,
+    policy: {
+      safetyMode: policy.safetyMode,
+      trustTier: policy.trustTier,
+      voiceCloningAllowed: policy.voiceCloningAllowed
+    }
+  };
+}
+function planSpeechFromCognition(input) {
+  const { cognition, ...rest } = input;
+  const signals = {
+    mode: cognition.mode,
+    personaDriftRisk: cognition.personaDriftRisk,
+    confidence: cognition.confidence,
+    risk: cognition.risk
+  };
+  const targetAffect = rest.targetAffect ?? cognition.emotionAVO;
+  return planSpeech({
+    ...rest,
+    targetAffect,
+    signals
+  });
+}
+
+// src/audio/overlay.ts
+var DEFAULT_OVERLAY_PHRASES = {
+  ack: ["Got it.", "Okay.", "Understood."],
+  hold: ["One moment.", "Give me a second.", "Hang on."],
+  done: ["Done.", "All set.", "Finished."],
+  error: ["I hit an error.", "Something went wrong.", "I ran into a problem."],
+  warning: ["Careful.", "Heads up.", "Just a note."]
+};
+function pickOverlayPhrase(args) {
+  const { token, library, index = 0 } = args;
+  const phrases = library?.[token] ?? DEFAULT_OVERLAY_PHRASES[token];
+  if (!phrases || phrases.length === 0) {
+    return DEFAULT_OVERLAY_PHRASES[token][0];
+  }
+  return phrases[index % phrases.length] ?? phrases[0];
+}
+
+// src/audio/providers/httpSpeechSynthesisProvider.ts
+var HttpSpeechSynthesisProvider = class {
+  providerId = "http";
+  baseUrl;
+  headers;
+  synthPath;
+  constructor(options) {
+    this.baseUrl = options.baseUrl.replace(/\/$/, "");
+    this.headers = options.headers ?? {};
+    this.synthPath = options.synthPath ?? "/v1/tts";
+  }
+  async synthesizeSpeech(request, options) {
+    const response = await fetch(`${this.baseUrl}${this.synthPath}`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        ...this.headers
+      },
+      body: JSON.stringify(request),
+      signal: options?.signal
+    });
+    if (!response.ok) {
+      const text = await response.text().catch(() => "");
+      throw new Error(`TTS request failed: HTTP ${response.status} ${response.statusText}${text ? ` - ${text}` : ""}`);
+    }
+    const contentType = response.headers.get("content-type") ?? "";
+    if (contentType.startsWith("audio/") || contentType === "application/octet-stream") {
+      throw new Error(
+        "TTS endpoint returned raw audio bytes; bb-ui requires a JSON response with artifact metadata for verification-first operation"
+      );
+    }
+    const payload = await response.json();
+    if (!payload?.artifact?.id || !payload?.artifact?.sha256 || !payload?.artifact?.durationMs) {
+      throw new Error("TTS endpoint response missing required `artifact` fields");
+    }
+    const audio = await this.resolveAudio(payload);
+    let proof = payload.proof;
+    if (proof) {
+      const parsed = validateAudioProof(proof);
+      if (!parsed.success) {
+        throw new Error("Invalid AudioProof from TTS endpoint");
+      }
+      proof = parsed.data;
+    }
+    return {
+      audio,
+      artifact: payload.artifact,
+      proof
+    };
+  }
+  async resolveAudio(payload) {
+    if (payload.audioBase64) {
+      const bytes = typeof atob !== "undefined" ? (() => {
+        const byteString = atob(payload.audioBase64 ?? "");
+        const arr = new Uint8Array(byteString.length);
+        for (let i = 0; i < byteString.length; i++) {
+          arr[i] = byteString.charCodeAt(i);
+        }
+        return arr;
+      })() : (() => {
+        const BufferCtor = globalThis.Buffer;
+        if (!BufferCtor) {
+          throw new Error("Base64 decoding is not supported in this environment");
+        }
+        return Uint8Array.from(BufferCtor.from(payload.audioBase64, "base64"));
+      })();
+      return new Blob([bytes], { type: "audio/wav" });
+    }
+    if (payload.audioUrl) {
+      const res = await fetch(payload.audioUrl);
+      if (!res.ok) {
+        throw new Error(`Failed to fetch audioUrl: HTTP ${res.status}`);
+      }
+      return await res.blob();
+    }
+    throw new Error("TTS endpoint response missing `audioBase64` or `audioUrl`");
+  }
+};
+
+// src/audio/hooks/useAudioPlayer.ts
+import { useCallback, useEffect, useRef, useState } from "react";
+function useAudioPlayer(options = {}) {
+  const { volume = 1, onEnded, onError } = options;
+  const audioRef = useRef(null);
+  const objectUrlRef = useRef(null);
+  const [isPlaying, setIsPlaying] = useState(false);
+  const [error, setError] = useState(null);
+  if (!audioRef.current && typeof Audio !== "undefined") {
+    audioRef.current = new Audio();
+  }
+  const stop = useCallback(() => {
+    const audio = audioRef.current;
+    if (!audio) return;
+    try {
+      audio.pause();
+      audio.currentTime = 0;
+    } catch {
+    } finally {
+      setIsPlaying(false);
+    }
+  }, []);
+  const play = useCallback(
+    async (source) => {
+      const audio = audioRef.current;
+      if (!audio) {
+        throw new Error("Audio playback not supported in this environment");
+      }
+      setError(null);
+      if (objectUrlRef.current) {
+        URL.revokeObjectURL(objectUrlRef.current);
+        objectUrlRef.current = null;
+      }
+      const src = typeof source === "string" ? source : URL.createObjectURL(source);
+      if (typeof source !== "string") {
+        objectUrlRef.current = src;
+      }
+      audio.volume = volume;
+      audio.src = src;
+      try {
+        await audio.play();
+        setIsPlaying(true);
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Failed to play audio";
+        setIsPlaying(false);
+        setError(message);
+        onError?.(err instanceof Error ? err : new Error(message));
+        throw err instanceof Error ? err : new Error(message);
+      }
+    },
+    [volume, onError]
+  );
+  useEffect(() => {
+    const audio = audioRef.current;
+    if (!audio) return;
+    const handleEnded = () => {
+      setIsPlaying(false);
+      onEnded?.();
+    };
+    const handleError = () => {
+      setIsPlaying(false);
+      const message = "Audio element error";
+      setError(message);
+      onError?.(new Error(message));
+    };
+    audio.addEventListener("ended", handleEnded);
+    audio.addEventListener("error", handleError);
+    return () => {
+      audio.removeEventListener("ended", handleEnded);
+      audio.removeEventListener("error", handleError);
+    };
+  }, [onEnded, onError]);
+  useEffect(() => {
+    return () => {
+      stop();
+      if (objectUrlRef.current) {
+        URL.revokeObjectURL(objectUrlRef.current);
+        objectUrlRef.current = null;
+      }
+    };
+  }, [stop]);
+  return {
+    isPlaying,
+    error,
+    play,
+    stop,
+    audioElement: audioRef.current
+  };
+}
+
+// src/audio/hooks/useBargeIn.ts
+import { useEffect as useEffect2, useRef as useRef2, useState as useState2 } from "react";
+function useBargeIn(options) {
+  const { stream, enabled = true, threshold = 0.02, hangoverMs = 250, onBargeIn } = options;
+  const [isUserSpeaking, setIsUserSpeaking] = useState2(false);
+  const [levelRms, setLevelRms] = useState2(0);
+  const rafRef = useRef2(null);
+  const lastAboveRef = useRef2(0);
+  const prevSpeakingRef = useRef2(false);
+  useEffect2(() => {
+    if (!enabled || !stream) {
+      setIsUserSpeaking(false);
+      setLevelRms(0);
+      return;
+    }
+    if (typeof AudioContext === "undefined") {
+      return;
+    }
+    const audioContext = new AudioContext();
+    const source = audioContext.createMediaStreamSource(stream);
+    const analyser = audioContext.createAnalyser();
+    analyser.fftSize = 2048;
+    source.connect(analyser);
+    const buffer = new Float32Array(analyser.fftSize);
+    const tick = () => {
+      analyser.getFloatTimeDomainData(buffer);
+      let sum = 0;
+      for (let i = 0; i < buffer.length; i++) {
+        const x = buffer[i];
+        sum += x * x;
+      }
+      const rms = Math.sqrt(sum / buffer.length);
+      setLevelRms(rms);
+      const now = performance.now();
+      if (rms >= threshold) {
+        lastAboveRef.current = now;
+      }
+      const speaking = rms >= threshold || now - lastAboveRef.current <= hangoverMs;
+      setIsUserSpeaking(speaking);
+      if (!prevSpeakingRef.current && speaking) {
+        onBargeIn?.();
+      }
+      prevSpeakingRef.current = speaking;
+      rafRef.current = requestAnimationFrame(tick);
+    };
+    rafRef.current = requestAnimationFrame(tick);
+    return () => {
+      if (rafRef.current) cancelAnimationFrame(rafRef.current);
+      rafRef.current = null;
+      try {
+        source.disconnect();
+        analyser.disconnect();
+      } catch {
+      }
+      audioContext.close().catch(() => {
+      });
+    };
+  }, [stream, enabled, threshold, hangoverMs, onBargeIn]);
+  return { isUserSpeaking, levelRms };
+}
+
+// src/audio/hooks/useSpeechSynthesis.ts
+import { useCallback as useCallback2, useEffect as useEffect3, useMemo, useRef as useRef3, useState as useState3 } from "react";
+function useSpeechSynthesis(options) {
+  const {
+    provider,
+    verifier,
+    voices,
+    policy,
+    signals,
+    defaults,
+    bargeIn,
+    volume = 1,
+    verificationMode,
+    onProof,
+    onBargeIn,
+    onError
+  } = options;
+  const effectiveVerificationMode = useMemo(() => {
+    if (verificationMode) return verificationMode;
+    if (policy.requireProofBeforePlayback) return "before_playback";
+    if (verifier) return "after_playback";
+    return "never";
+  }, [verificationMode, policy.requireProofBeforePlayback, verifier]);
+  const abortRef = useRef3(null);
+  const [isSynthesizing, setIsSynthesizing] = useState3(false);
+  const [error, setError] = useState3(null);
+  const [lastRequest, setLastRequest] = useState3(null);
+  const [lastResult, setLastResult] = useState3(null);
+  const [lastProof, setLastProof] = useState3(null);
+  const player = useAudioPlayer({
+    volume,
+    onError: (err) => {
+      setError(err.message);
+      onError?.(err);
+    }
+  });
+  const bargeInState = useBargeIn({
+    stream: bargeIn?.stream ?? null,
+    enabled: !!bargeIn?.stream,
+    threshold: bargeIn?.threshold,
+    hangoverMs: bargeIn?.hangoverMs,
+    onBargeIn: () => {
+      onBargeIn?.();
+    }
+  });
+  const cancel = useCallback2(() => {
+    abortRef.current?.abort();
+    abortRef.current = null;
+    setIsSynthesizing(false);
+    player.stop();
+  }, [player]);
+  useEffect3(() => {
+    if (!bargeIn?.stream) return;
+    if (!bargeInState.isUserSpeaking) return;
+    cancel();
+  }, [bargeIn?.stream, bargeInState.isUserSpeaking, cancel]);
+  const speak = useCallback2(
+    async (text, speakOptions) => {
+      cancel();
+      setError(null);
+      setIsSynthesizing(true);
+      const controller = new AbortController();
+      abortRef.current = controller;
+      try {
+        const request = planSpeech({
+          text,
+          language: speakOptions?.language,
+          runId: speakOptions?.runId,
+          targetAffect: speakOptions?.targetAffect,
+          policy,
+          voices,
+          signals,
+          defaults
+        });
+        setLastRequest(request);
+        const result = await provider.synthesizeSpeech(request, { signal: controller.signal });
+        setLastResult(result);
+        let proof = result.proof;
+        if (proof) {
+          const parsed = validateAudioProof(proof);
+          if (!parsed.success) {
+            throw new Error("Provider returned invalid AudioProof");
+          }
+          proof = parsed.data;
+        }
+        const verifyNow = effectiveVerificationMode === "before_playback" && (!proof || !proof.verdict?.passed) && !!verifier;
+        if (verifyNow && verifier) {
+          proof = await verifier.verifySpeech({ request, result, policy });
+          const parsed = validateAudioProof(proof);
+          if (!parsed.success) {
+            throw new Error("Verifier returned invalid AudioProof");
+          }
+          proof = parsed.data;
+        }
+        if (policy.requireProofBeforePlayback && (!proof || proof.verdict.passed !== true)) {
+          throw new Error("Playback blocked by policy: missing or failing AudioProof");
+        }
+        await player.play(result.audio);
+        if (effectiveVerificationMode === "after_playback" && verifier && !proof) {
+          void (async () => {
+            try {
+              const p = await verifier.verifySpeech({ request, result, policy });
+              const parsed = validateAudioProof(p);
+              if (!parsed.success) return;
+              setLastProof(parsed.data);
+              onProof?.(parsed.data);
+            } catch {
+            }
+          })();
+        }
+        if (proof) {
+          setLastProof(proof);
+          onProof?.(proof);
+        }
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Speech synthesis failed";
+        setError(message);
+        onError?.(err instanceof Error ? err : new Error(message));
+        throw err instanceof Error ? err : new Error(message);
+      } finally {
+        setIsSynthesizing(false);
+        abortRef.current = null;
+      }
+    },
+    [
+      cancel,
+      policy,
+      voices,
+      signals,
+      defaults,
+      provider,
+      verifier,
+      effectiveVerificationMode,
+      player,
+      onProof,
+      onError
+    ]
+  );
+  return {
+    isSynthesizing,
+    isSpeaking: player.isPlaying,
+    error,
+    lastRequest,
+    lastResult,
+    lastProof,
+    speak,
+    cancel
+  };
+}
+
+// src/audio/hooks/useAudioOverlay.ts
+import { useCallback as useCallback3, useMemo as useMemo2, useRef as useRef4 } from "react";
+function useAudioOverlay(options) {
+  const {
+    provider,
+    verifier,
+    voices,
+    policy,
+    signals,
+    defaults,
+    phrases,
+    bargeIn,
+    volume,
+    verificationMode,
+    onProof,
+    onBargeIn,
+    onError
+  } = options;
+  const phraseIndexRef = useRef4(0);
+  const overlayDefaults = useMemo2(() => {
+    return {
+      ...defaults,
+      // Default to low temperature so overlay cues are stable and “assistant-like”.
+      temperature: defaults?.temperature ?? 0.2
+    };
+  }, [defaults]);
+  const speech = useSpeechSynthesis({
+    provider,
+    verifier,
+    voices,
+    policy,
+    signals,
+    defaults: overlayDefaults,
+    bargeIn,
+    volume,
+    verificationMode,
+    onProof,
+    onBargeIn,
+    onError
+  });
+  const speakToken = useCallback3(
+    async (token, overlaySpeakOptions) => {
+      const idx = phraseIndexRef.current++;
+      const text = pickOverlayPhrase({ token, library: phrases, index: idx });
+      await speech.speak(text, overlaySpeakOptions);
+    },
+    [speech, phrases]
+  );
+  const speakText = useCallback3(
+    async (text, overlaySpeakOptions) => {
+      await speech.speak(text, overlaySpeakOptions);
+    },
+    [speech]
+  );
+  return {
+    isSynthesizing: speech.isSynthesizing,
+    isSpeaking: speech.isSpeaking,
+    error: speech.error,
+    lastProof: speech.lastProof,
+    speakToken,
+    speakText,
+    cancel: speech.cancel
+  };
+}
+
+// src/audio/hooks/useHybridSpeech.ts
+import { useCallback as useCallback4, useEffect as useEffect4 } from "react";
+function useHybridSpeech(options) {
+  const { main: mainOptions, overlay: overlayOptions, stopOverlayOnMainSpeak = true } = options;
+  const main = useSpeechSynthesis(mainOptions);
+  const overlayEnabled = overlayOptions.enabled !== false;
+  const overlay = useAudioOverlay(overlayOptions);
+  useEffect4(() => {
+    if (!stopOverlayOnMainSpeak) return;
+    if (!overlayEnabled) return;
+    if (!main.isSpeaking) return;
+    overlay.cancel();
+  }, [stopOverlayOnMainSpeak, overlayEnabled, main.isSpeaking, overlay]);
+  const speakWithAck = useCallback4(
+    async (text, speakOptions) => {
+      if (overlayEnabled) {
+        void overlay.speakToken("ack", speakOptions).catch(() => {
+        });
+      }
+      try {
+        await main.speak(text, speakOptions);
+      } catch (err) {
+        if (overlayEnabled) overlay.cancel();
+        throw err;
+      }
+    },
+    [overlayEnabled, overlay, main]
+  );
+  const cancelAll = useCallback4(() => {
+    main.cancel();
+    if (overlayEnabled) overlay.cancel();
+  }, [main, overlayEnabled, overlay]);
+  return { main, overlay, speakWithAck, cancelAll };
+}
+
+export {
+  DEFAULT_TARGET_AVO,
+  clamp01,
+  createTraceId,
+  AudioFormatSchema,
+  VoiceLicenseCategorySchema,
+  AudioProofSchema,
+  validateAudioProof,
+  planSpeech,
+  planSpeechFromCognition,
+  DEFAULT_OVERLAY_PHRASES,
+  pickOverlayPhrase,
+  HttpSpeechSynthesisProvider,
+  useAudioPlayer,
+  useBargeIn,
+  useSpeechSynthesis,
+  useAudioOverlay,
+  useHybridSpeech
+};
+//# sourceMappingURL=chunk-XE2IVCKJ.js.map