@epicbagel/saas-kit 1.7.0 → 1.11.0

package/dist/chunk-ZZ7ICQR2.cjs

@@ -0,0 +1,412 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }"use client";
+
+// src/hooks/use-dictation.ts
+var _react = require('react');
+var DictationContext = _react.createContext.call(void 0, null);
+function DictationProvider({ transcribe, scopeKey, children }) {
+  const scope = _react.useRef.call(void 0, { key: scopeKey, generation: 0 });
+  if (scope.current.key !== scopeKey) scope.current = { key: scopeKey, generation: scope.current.generation + 1 };
+  const generation = scope.current.generation;
+  const value = _react.useMemo.call(void 0, () => ({ transcribe, scope, generation }), [transcribe, generation]);
+  return _react.createElement.call(void 0, DictationContext.Provider, { value }, children);
+}
+var EMPTY = { state: "idle", transcript: "", interimTranscript: "", error: null, canRetry: false };
+var MIME_TYPES = ["audio/webm;codecs=opus", "audio/mp4", "audio/ogg;codecs=opus", "audio/webm"];
+var SILENCE = [];
+function createAudioLevels() {
+  let bands = SILENCE;
+  const listeners = /* @__PURE__ */ new Set();
+  return {
+    subscribe: (listener) => {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    getSnapshot: () => bands,
+    update: (next) => {
+      if (next.length === bands.length && next.every((value, index) => value === bands[index])) return;
+      bands = next;
+      listeners.forEach((listener) => listener());
+    }
+  };
+}
+function meterStream(stream, levels, active) {
+  let context;
+  let source;
+  let analyser;
+  let frame;
+  let stopped = false;
+  const stop = () => {
+    if (stopped) return;
+    stopped = true;
+    if (frame !== void 0) cancelAnimationFrame(frame);
+    try {
+      _optionalChain([source, 'optionalAccess', _2 => _2.disconnect, 'call', _3 => _3()]);
+    } catch (e) {
+    }
+    try {
+      _optionalChain([analyser, 'optionalAccess', _4 => _4.disconnect, 'call', _5 => _5()]);
+    } catch (e2) {
+    }
+    try {
+      void _optionalChain([context, 'optionalAccess', _6 => _6.close, 'call', _7 => _7(), 'access', _8 => _8.catch, 'call', _9 => _9(() => {
+      })]);
+    } catch (e3) {
+    }
+    levels.update(SILENCE);
+  };
+  try {
+    const Constructor = _nullishCoalesce(window.AudioContext, () => ( window.webkitAudioContext));
+    if (!Constructor || typeof requestAnimationFrame !== "function") return stop;
+    context = new Constructor();
+    source = context.createMediaStreamSource(stream);
+    analyser = context.createAnalyser();
+    analyser.fftSize = 512;
+    analyser.smoothingTimeConstant = 0.7;
+    source.connect(analyser);
+    const bins = new Uint8Array(analyser.frequencyBinCount);
+    const binWidth = context.sampleRate / analyser.fftSize;
+    const highest = Math.min(8e3, context.sampleRate / 2);
+    let sampledAt = -Infinity;
+    const sample = (time) => {
+      if (stopped) return;
+      if (!active()) {
+        stop();
+        return;
+      }
+      try {
+        if (time - sampledAt >= 40) {
+          sampledAt = time;
+          analyser.getByteFrequencyData(bins);
+          const bands = Array.from({ length: 24 }, (_, index) => {
+            const from = Math.min(bins.length - 1, Math.floor(80 * (highest / 80) ** (index / 24) / binWidth));
+            const to = Math.min(bins.length, Math.max(from + 1, Math.ceil(80 * (highest / 80) ** ((index + 1) / 24) / binWidth)));
+            let total = 0;
+            for (let bin = from; bin < to; bin++) total += bins[bin];
+            return Math.round(total / (to - from) / 255 * 1e3) / 1e3;
+          });
+          levels.update(bands);
+        }
+        frame = requestAnimationFrame(sample);
+      } catch (e4) {
+        stop();
+      }
+    };
+    if (context.state === "suspended") void context.resume().catch(stop);
+    frame = requestAnimationFrame(sample);
+  } catch (e5) {
+    stop();
+  }
+  return stop;
+}
+function recognitionConstructor() {
+  if (typeof window === "undefined") return void 0;
+  const speech = window;
+  return _nullishCoalesce(speech.SpeechRecognition, () => ( speech.webkitSpeechRecognition));
+}
+function microphoneError(reason) {
+  const name = _optionalChain([reason, 'optionalAccess', _10 => _10.name]);
+  if (name === "NotAllowedError" || name === "SecurityError") return "Microphone access is blocked. Allow it in your browser and try again.";
+  if (name === "NotFoundError" || name === "NotReadableError") return "The microphone is unavailable. Check your microphone and try again.";
+  return "Recording could not start. Check your microphone and try again.";
+}
+function recognitionError(code) {
+  if (code === "not-allowed" || code === "service-not-allowed") return microphoneError({ name: "NotAllowedError" });
+  if (code === "audio-capture") return microphoneError({ name: "NotFoundError" });
+  if (code === "no-speech") return "No speech was detected. Try again.";
+  return "Speech recognition stopped. Try again.";
+}
+function releaseMeter(session) {
+  _optionalChain([session, 'access', _11 => _11.stopMeter, 'optionalCall', _12 => _12()]);
+  session.stopMeter = void 0;
+}
+function releaseTracks(session) {
+  releaseMeter(session);
+  _optionalChain([session, 'access', _13 => _13.stream, 'optionalAccess', _14 => _14.getTracks, 'call', _15 => _15(), 'access', _16 => _16.forEach, 'call', _17 => _17((track) => track.stop())]);
+  session.stream = void 0;
+}
+function dispose(session) {
+  session.controller.abort();
+  if (session.nativeTimer) clearTimeout(session.nativeTimer);
+  const recorder = session.recorder;
+  if (recorder) {
+    recorder.ondataavailable = null;
+    recorder.onstop = null;
+    recorder.onerror = null;
+    if (recorder.state !== "inactive") {
+      try {
+        recorder.stop();
+      } catch (e6) {
+      }
+    }
+  }
+  const recognition = session.recognition;
+  if (recognition) {
+    recognition.onresult = null;
+    recognition.onerror = null;
+    recognition.onend = null;
+    try {
+      recognition.abort();
+    } catch (e7) {
+    }
+  }
+  releaseTracks(session);
+  session.resolveCapture(null);
+  session.resolveNativeEnd();
+}
+function useDictation({ lang = "en-US", continuous = true, onTranscript } = {}) {
+  const provider = _react.useContext.call(void 0, DictationContext);
+  const transcribe = _nullishCoalesce(_optionalChain([provider, 'optionalAccess', _18 => _18.transcribe]), () => ( null));
+  const scope = _nullishCoalesce(_optionalChain([provider, 'optionalAccess', _19 => _19.scope]), () => ( null));
+  const scopeGeneration = _nullishCoalesce(_optionalChain([provider, 'optionalAccess', _20 => _20.generation]), () => ( 0));
+  const [snapshot, setSnapshot] = _react.useState.call(void 0, EMPTY);
+  const [supported, setSupported] = _react.useState.call(void 0, false);
+  const current = _react.useRef.call(void 0, null);
+  const mounted = _react.useRef.call(void 0, true);
+  const callback = _react.useRef.call(void 0, onTranscript);
+  const activeScope = _react.useRef.call(void 0, scope);
+  activeScope.current = scope;
+  callback.current = onTranscript;
+  _react.useEffect.call(void 0, () => {
+    setSupported(transcribe ? typeof navigator !== "undefined" && !!_optionalChain([navigator, 'access', _21 => _21.mediaDevices, 'optionalAccess', _22 => _22.getUserMedia]) && typeof MediaRecorder !== "undefined" : typeof recognitionConstructor() === "function");
+  }, [transcribe]);
+  const cancel = _react.useCallback.call(void 0, () => {
+    const session = current.current;
+    current.current = null;
+    if (session) dispose(session);
+    if (mounted.current) setSnapshot(EMPTY);
+  }, []);
+  _react.useEffect.call(void 0, () => {
+    const session = current.current;
+    if (session && (session.scope !== scope || session.scopeGeneration !== scopeGeneration)) cancel();
+  }, [cancel, scope, scopeGeneration]);
+  _react.useEffect.call(void 0, () => {
+    mounted.current = true;
+    return () => {
+      mounted.current = false;
+      const session = current.current;
+      current.current = null;
+      if (session) dispose(session);
+    };
+  }, []);
+  const isCurrent = _react.useCallback.call(void 0, (session) => mounted.current && current.current === session && session.scope === activeScope.current && session.scopeGeneration === (_nullishCoalesce(_optionalChain([session, 'access', _23 => _23.scope, 'optionalAccess', _24 => _24.current, 'access', _25 => _25.generation]), () => ( 0))) && !session.controller.signal.aborted, []);
+  const start = _react.useCallback.call(void 0, async () => {
+    if (scope !== activeScope.current || scopeGeneration !== (_nullishCoalesce(_optionalChain([scope, 'optionalAccess', _26 => _26.current, 'access', _27 => _27.generation]), () => ( 0)))) return;
+    if (current.current && isCurrent(current.current) && ["requesting", "recording", "transcribing"].includes(current.current.phase)) return;
+    cancel();
+    let resolveCapture;
+    let resolveNativeEnd;
+    const session = {
+      language: lang,
+      transcribe,
+      scope,
+      scopeGeneration,
+      controller: new AbortController(),
+      phase: "requesting",
+      chunks: [],
+      capture: new Promise((resolve) => {
+        resolveCapture = resolve;
+      }),
+      resolveCapture: (blob) => resolveCapture(blob),
+      nativeEnd: new Promise((resolve) => {
+        resolveNativeEnd = resolve;
+      }),
+      resolveNativeEnd: () => resolveNativeEnd(),
+      nativeEnded: false,
+      transcript: "",
+      interim: "",
+      notified: /* @__PURE__ */ new Set(),
+      audioLevels: transcribe ? createAudioLevels() : void 0
+    };
+    current.current = session;
+    setSnapshot({ ...EMPTY, state: "requesting" });
+    if (transcribe) {
+      try {
+        if (!_optionalChain([navigator, 'access', _28 => _28.mediaDevices, 'optionalAccess', _29 => _29.getUserMedia]) || typeof MediaRecorder === "undefined") throw new Error("unsupported");
+        const stream = await navigator.mediaDevices.getUserMedia({ audio: true });
+        if (!isCurrent(session)) {
+          stream.getTracks().forEach((track) => track.stop());
+          return;
+        }
+        session.stream = stream;
+        const mimeType = MIME_TYPES.find((mime) => _optionalChain([MediaRecorder, 'access', _30 => _30.isTypeSupported, 'optionalCall', _31 => _31(mime)]));
+        const recorder = mimeType ? new MediaRecorder(stream, { mimeType }) : new MediaRecorder(stream);
+        session.recorder = recorder;
+        recorder.ondataavailable = (event) => {
+          if (isCurrent(session) && event.data.size) session.chunks.push(event.data);
+        };
+        recorder.onstop = () => {
+          releaseTracks(session);
+          if (!isCurrent(session)) {
+            session.resolveCapture(null);
+            return;
+          }
+          const type = recorder.mimeType || _optionalChain([session, 'access', _32 => _32.chunks, 'access', _33 => _33[0], 'optionalAccess', _34 => _34.type]) || mimeType || "audio/webm";
+          const blob = new Blob(session.chunks, { type });
+          session.blob = blob;
+          session.chunks = [];
+          session.resolveCapture(blob);
+        };
+        recorder.onerror = () => {
+          if (!isCurrent(session)) return;
+          releaseTracks(session);
+          session.phase = "error";
+          session.resolveCapture(null);
+          setSnapshot({ ...EMPTY, state: "error", error: "Recording was interrupted. Try again." });
+        };
+        recorder.start();
+        session.phase = "recording";
+        session.stopMeter = meterStream(stream, session.audioLevels, () => isCurrent(session) && session.phase === "recording");
+        setSnapshot({ ...EMPTY, state: "recording" });
+      } catch (error) {
+        releaseTracks(session);
+        if (!isCurrent(session)) return;
+        session.phase = "error";
+        setSnapshot({ ...EMPTY, state: "error", error: microphoneError(error) });
+      }
+      return;
+    }
+    try {
+      const Constructor = recognitionConstructor();
+      if (!Constructor) throw new Error("unsupported");
+      const recognition = new Constructor();
+      session.recognition = recognition;
+      recognition.lang = lang;
+      recognition.continuous = continuous;
+      recognition.interimResults = true;
+      recognition.onresult = (event) => {
+        if (!isCurrent(session) || session.phase === "error") return;
+        const final = [];
+        const interim = [];
+        const chunks = [];
+        for (let i = 0; i < event.results.length; i++) {
+          const result = event.results[i];
+          if (!result) continue;
+          const text = result[0].transcript.trim();
+          if (result.isFinal) {
+            final.push(text);
+            if (!session.notified.has(i)) {
+              session.notified.add(i);
+              if (text) chunks.push(text);
+            }
+          } else interim.push(text);
+        }
+        session.transcript = final.join(" ");
+        session.interim = interim.join(" ");
+        setSnapshot((previous) => ({ ...previous, transcript: session.transcript, interimTranscript: session.interim }));
+        if (chunks.length) _optionalChain([callback, 'access', _35 => _35.current, 'optionalCall', _36 => _36(chunks.join(" "))]);
+      };
+      recognition.onend = () => {
+        session.nativeEnded = true;
+        session.resolveNativeEnd();
+        if (isCurrent(session) && session.phase === "recording") {
+          session.phase = "ready";
+          setSnapshot((previous) => ({ ...previous, state: "ready" }));
+        }
+      };
+      recognition.onerror = (event) => {
+        if (!isCurrent(session)) return;
+        session.phase = "error";
+        session.nativeEnded = true;
+        session.resolveNativeEnd();
+        setSnapshot((previous) => ({ ...previous, state: "error", error: recognitionError(event.error) }));
+      };
+      recognition.start();
+      session.phase = "recording";
+      setSnapshot({ ...EMPTY, state: "recording" });
+    } catch (error) {
+      if (!isCurrent(session)) return;
+      session.phase = "error";
+      setSnapshot({ ...EMPTY, state: "error", error: microphoneError(error) });
+    }
+  }, [cancel, continuous, isCurrent, lang, scope, scopeGeneration, transcribe]);
+  const finish = _react.useCallback.call(void 0, async (session) => {
+    if (!isCurrent(session)) return null;
+    releaseMeter(session);
+    session.phase = "transcribing";
+    setSnapshot((previous) => ({ ...previous, state: "transcribing", error: null, canRetry: false }));
+    if (!session.transcribe) {
+      if (!session.nativeEnded) {
+        session.nativeTimer = setTimeout(() => {
+          try {
+            _optionalChain([session, 'access', _37 => _37.recognition, 'optionalAccess', _38 => _38.abort, 'call', _39 => _39()]);
+          } catch (e8) {
+          }
+          session.resolveNativeEnd();
+        }, 1e3);
+        try {
+          _optionalChain([session, 'access', _40 => _40.recognition, 'optionalAccess', _41 => _41.stop, 'call', _42 => _42()]);
+        } catch (e9) {
+          session.resolveNativeEnd();
+        }
+        await session.nativeEnd;
+        clearTimeout(session.nativeTimer);
+      }
+      if (!isCurrent(session) || session.phase === "error") return null;
+      const text2 = [session.transcript, session.interim].filter(Boolean).join(" ").trim();
+      session.phase = "ready";
+      setSnapshot({ ...EMPTY, state: "ready", transcript: text2 });
+      return text2;
+    }
+    let text;
+    try {
+      if (!session.blob) {
+        if (_optionalChain([session, 'access', _43 => _43.recorder, 'optionalAccess', _44 => _44.state]) !== "inactive") _optionalChain([session, 'access', _45 => _45.recorder, 'optionalAccess', _46 => _46.stop, 'call', _47 => _47()]);
+        const blob = await session.capture;
+        if (!isCurrent(session) || !blob) return null;
+        session.blob = blob;
+      }
+      if (!session.blob.size) throw new Error("No audio was recorded. Try again.");
+      text = (await session.transcribe(session.blob, { language: session.language, signal: session.controller.signal })).trim();
+      if (!isCurrent(session)) return null;
+      if (!text) throw new Error("No speech was detected. Record again.");
+    } catch (error) {
+      if (!isCurrent(session)) return null;
+      releaseTracks(session);
+      session.phase = "error";
+      const message = error instanceof Error && error.message ? error.message : "Transcription failed. Try again.";
+      setSnapshot({ ...EMPTY, state: "error", error: message, canRetry: !!_optionalChain([session, 'access', _48 => _48.blob, 'optionalAccess', _49 => _49.size]) });
+      return null;
+    }
+    session.transcript = text;
+    session.phase = "ready";
+    setSnapshot({ ...EMPTY, state: "ready", transcript: text });
+    _optionalChain([callback, 'access', _50 => _50.current, 'optionalCall', _51 => _51(text)]);
+    return text;
+  }, [isCurrent]);
+  const stop = _react.useCallback.call(void 0, () => {
+    const session = current.current;
+    if (!session) return Promise.resolve(null);
+    if (!isCurrent(session)) {
+      cancel();
+      return Promise.resolve(null);
+    }
+    if (session.phase === "requesting") {
+      cancel();
+      return Promise.resolve(null);
+    }
+    if (session.finish) return session.finish;
+    if (session.phase === "error") return Promise.resolve(null);
+    session.finish = finish(session);
+    return session.finish;
+  }, [cancel, finish, isCurrent]);
+  const retry = _react.useCallback.call(void 0, () => {
+    const session = current.current;
+    if (session && !isCurrent(session)) {
+      cancel();
+      return Promise.resolve(null);
+    }
+    if (!_optionalChain([session, 'optionalAccess', _52 => _52.transcribe]) || !_optionalChain([session, 'access', _53 => _53.blob, 'optionalAccess', _54 => _54.size])) return Promise.resolve(null);
+    if (session.phase !== "error") return _nullishCoalesce(session.finish, () => ( Promise.resolve(null)));
+    session.finish = finish(session);
+    return session.finish;
+  }, [cancel, finish, isCurrent]);
+  const visibleSnapshot = current.current && !isCurrent(current.current) ? EMPTY : snapshot;
+  return { ...visibleSnapshot, audioLevels: current.current && isCurrent(current.current) ? current.current.audioLevels : void 0, supported, start, stop, retry, cancel };
+}
+
+
+
+
+exports.DictationProvider = DictationProvider; exports.useDictation = useDictation;

package/dist/hooks/use-agent-audio-visualizer-bar.cjs

@@ -0,0 +1,8 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});"use client";
+"use client";
+
+
+var _chunk2BSFYU22cjs = require('../chunk-2BSFYU22.cjs');
+
+
+exports.useAgentAudioVisualizerBarAnimator = _chunk2BSFYU22cjs.useAgentAudioVisualizerBarAnimator;

package/dist/hooks/use-agent-audio-visualizer-bar.d.cts

@@ -0,0 +1,4 @@
+type AgentVisualizerState = 'disconnected' | 'connecting' | 'initializing' | 'listening' | 'thinking' | 'speaking' | 'failed';
+declare function useAgentAudioVisualizerBarAnimator(state: AgentVisualizerState | undefined, columns: number, interval: number): number[];
+
+export { type AgentVisualizerState, useAgentAudioVisualizerBarAnimator };

package/dist/hooks/use-agent-audio-visualizer-bar.d.ts

@@ -0,0 +1,4 @@
+type AgentVisualizerState = 'disconnected' | 'connecting' | 'initializing' | 'listening' | 'thinking' | 'speaking' | 'failed';
+declare function useAgentAudioVisualizerBarAnimator(state: AgentVisualizerState | undefined, columns: number, interval: number): number[];
+
+export { type AgentVisualizerState, useAgentAudioVisualizerBarAnimator };

package/dist/hooks/use-agent-audio-visualizer-bar.js

@@ -0,0 +1,8 @@
+"use client";
+"use client";
+import {
+  useAgentAudioVisualizerBarAnimator
+} from "../chunk-GJ7S3L6R.js";
+export {
+  useAgentAudioVisualizerBarAnimator
+};

package/dist/hooks/use-dictation.cjs

@@ -0,0 +1,10 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});"use client";
+"use client";
+
+
+
+var _chunkZZ7ICQR2cjs = require('../chunk-ZZ7ICQR2.cjs');
+
+
+
+exports.DictationProvider = _chunkZZ7ICQR2cjs.DictationProvider; exports.useDictation = _chunkZZ7ICQR2cjs.useDictation;

package/dist/hooks/use-dictation.d.cts

@@ -0,0 +1,61 @@
+import * as React from 'react';
+import { ReactNode } from 'react';
+
+interface DictationTranscribeOptions {
+    /** BCP-47 language requested by the control. */
+    language: string;
+    /** Cancel the upload/provider request when the control is dismissed. */
+    signal: AbortSignal;
+}
+/** The host authenticates this request; provider credentials never belong in the kit. */
+type DictationTranscribe = (audio: Blob, options: DictationTranscribeOptions) => Promise<string>;
+interface DictationProviderProps {
+    transcribe: DictationTranscribe;
+    /** Change when the acting user or workspace changes to discard its active take. */
+    scopeKey?: string;
+    children: ReactNode;
+}
+type DictationScope = {
+    current: {
+        key: string | undefined;
+        generation: number;
+    };
+};
+type DictationContextValue = {
+    transcribe: DictationTranscribe;
+    scope: DictationScope;
+    generation: number;
+};
+/** Use recorded audio + the host's API for every descendant dictation control. */
+declare function DictationProvider({ transcribe, scopeKey, children }: DictationProviderProps): React.FunctionComponentElement<React.ProviderProps<DictationContextValue | null>>;
+type DictationState = "idle" | "requesting" | "recording" | "transcribing" | "ready" | "error";
+interface UseDictationOptions {
+    lang?: string;
+    /** Applies to native recognition. API capture finishes when stop is called. */
+    continuous?: boolean;
+    /** Native final chunks, or one complete API transcript. Do not also commit stop's result. */
+    onTranscript?: (text: string) => void;
+}
+interface DictationCapture {
+    state: DictationState;
+    supported: boolean;
+    transcript: string;
+    interimTranscript: string;
+    error: string | null;
+    canRetry: boolean;
+    /** Live bands from the recording stream. Native speech recognition exposes no audio meter. */
+    audioLevels?: {
+        subscribe: (listener: () => void) => () => void;
+        getSnapshot: () => number[];
+    };
+    start: () => Promise<void>;
+    /** Returns null on cancellation/failure; concurrent stops share one transcription. */
+    stop: () => Promise<string | null>;
+    /** Retries the same recorded take after an API failure. */
+    retry: () => Promise<string | null>;
+    cancel: () => void;
+}
+/** Shared microphone lifecycle. Without a provider, existing native dictation keeps working. */
+declare function useDictation({ lang, continuous, onTranscript }?: UseDictationOptions): DictationCapture;
+
+export { type DictationCapture, DictationProvider, type DictationProviderProps, type DictationState, type DictationTranscribe, type DictationTranscribeOptions, type UseDictationOptions, useDictation };

package/dist/hooks/use-dictation.d.ts

@@ -0,0 +1,61 @@
+import * as React from 'react';
+import { ReactNode } from 'react';
+
+interface DictationTranscribeOptions {
+    /** BCP-47 language requested by the control. */
+    language: string;
+    /** Cancel the upload/provider request when the control is dismissed. */
+    signal: AbortSignal;
+}
+/** The host authenticates this request; provider credentials never belong in the kit. */
+type DictationTranscribe = (audio: Blob, options: DictationTranscribeOptions) => Promise<string>;
+interface DictationProviderProps {
+    transcribe: DictationTranscribe;
+    /** Change when the acting user or workspace changes to discard its active take. */
+    scopeKey?: string;
+    children: ReactNode;
+}
+type DictationScope = {
+    current: {
+        key: string | undefined;
+        generation: number;
+    };
+};
+type DictationContextValue = {
+    transcribe: DictationTranscribe;
+    scope: DictationScope;
+    generation: number;
+};
+/** Use recorded audio + the host's API for every descendant dictation control. */
+declare function DictationProvider({ transcribe, scopeKey, children }: DictationProviderProps): React.FunctionComponentElement<React.ProviderProps<DictationContextValue | null>>;
+type DictationState = "idle" | "requesting" | "recording" | "transcribing" | "ready" | "error";
+interface UseDictationOptions {
+    lang?: string;
+    /** Applies to native recognition. API capture finishes when stop is called. */
+    continuous?: boolean;
+    /** Native final chunks, or one complete API transcript. Do not also commit stop's result. */
+    onTranscript?: (text: string) => void;
+}
+interface DictationCapture {
+    state: DictationState;
+    supported: boolean;
+    transcript: string;
+    interimTranscript: string;
+    error: string | null;
+    canRetry: boolean;
+    /** Live bands from the recording stream. Native speech recognition exposes no audio meter. */
+    audioLevels?: {
+        subscribe: (listener: () => void) => () => void;
+        getSnapshot: () => number[];
+    };
+    start: () => Promise<void>;
+    /** Returns null on cancellation/failure; concurrent stops share one transcription. */
+    stop: () => Promise<string | null>;
+    /** Retries the same recorded take after an API failure. */
+    retry: () => Promise<string | null>;
+    cancel: () => void;
+}
+/** Shared microphone lifecycle. Without a provider, existing native dictation keeps working. */
+declare function useDictation({ lang, continuous, onTranscript }?: UseDictationOptions): DictationCapture;
+
+export { type DictationCapture, DictationProvider, type DictationProviderProps, type DictationState, type DictationTranscribe, type DictationTranscribeOptions, type UseDictationOptions, useDictation };

package/dist/hooks/use-dictation.js

@@ -0,0 +1,10 @@
+"use client";
+"use client";
+import {
+  DictationProvider,
+  useDictation
+} from "../chunk-HLAHOVEI.js";
+export {
+  DictationProvider,
+  useDictation
+};

package/dist/primitives/activity-feed.cjs

@@ -4,13 +4,13 @@
 var _chunkKGFL3VWYcjs = require('../chunk-KGFL3VWY.cjs');
 
 
+var _chunkPQUSJEXLcjs = require('../chunk-PQUSJEXL.cjs');
+require('../chunk-VGTINL5Q.cjs');
 
 
-var _chunkWABCLRBRcjs = require('../chunk-WABCLRBR.cjs');
 
 
-var _chunkPQUSJEXLcjs = require('../chunk-PQUSJEXL.cjs');
-require('../chunk-VGTINL5Q.cjs');
+var _chunkWABCLRBRcjs = require('../chunk-WABCLRBR.cjs');
 require('../chunk-I6GUOEBO.cjs');
 
 

package/dist/primitives/activity-feed.js

@@ -2,15 +2,15 @@
 import {
   ChipTabs
 } from "../chunk-QD63LB2F.js";
+import {
+  Input
+} from "../chunk-QMA3WVB7.js";
+import "../chunk-H7TETFLB.js";
 import {
   Avatar,
   AvatarFallback,
   AvatarImage
 } from "../chunk-3OWGL4Q2.js";
-import {
-  Input
-} from "../chunk-QMA3WVB7.js";
-import "../chunk-H7TETFLB.js";
 import "../chunk-D4ZL2OEQ.js";
 import {
   EmptyState

package/dist/primitives/agent-audio-visualizer-bar.cjs

@@ -0,0 +1,16 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});"use client";
+"use client";
+
+
+
+
+
+var _chunkNKWHDI4Ccjs = require('../chunk-NKWHDI4C.cjs');
+require('../chunk-KWLSBTB2.cjs');
+require('../chunk-2BSFYU22.cjs');
+
+
+
+
+
+exports.AgentAudioVisualizerBar = _chunkNKWHDI4Ccjs.AgentAudioVisualizerBar; exports.AgentAudioVisualizerBarElementVariants = _chunkNKWHDI4Ccjs.AgentAudioVisualizerBarElementVariants; exports.AgentAudioVisualizerBarVariants = _chunkNKWHDI4Ccjs.AgentAudioVisualizerBarVariants; exports.normalizeVolumeBands = _chunkNKWHDI4Ccjs.normalizeVolumeBands;