@epicbagel/saas-kit 1.7.0 → 1.10.0

package/dist/chunk-O6F3LVZY.cjs

@@ -0,0 +1,316 @@
+"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"];
+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', _ => _.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 releaseTracks(session) {
+  _optionalChain([session, 'access', _2 => _2.stream, 'optionalAccess', _3 => _3.getTracks, 'call', _4 => _4(), 'access', _5 => _5.forEach, 'call', _6 => _6((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 (e) {
+      }
+    }
+  }
+  const recognition = session.recognition;
+  if (recognition) {
+    recognition.onresult = null;
+    recognition.onerror = null;
+    recognition.onend = null;
+    try {
+      recognition.abort();
+    } catch (e2) {
+    }
+  }
+  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', _7 => _7.transcribe]), () => ( null));
+  const scope = _nullishCoalesce(_optionalChain([provider, 'optionalAccess', _8 => _8.scope]), () => ( null));
+  const scopeGeneration = _nullishCoalesce(_optionalChain([provider, 'optionalAccess', _9 => _9.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', _10 => _10.mediaDevices, 'optionalAccess', _11 => _11.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', _12 => _12.scope, 'optionalAccess', _13 => _13.current, 'access', _14 => _14.generation]), () => ( 0))) && !session.controller.signal.aborted, []);
+  const start = _react.useCallback.call(void 0, async () => {
+    if (scope !== activeScope.current || scopeGeneration !== (_nullishCoalesce(_optionalChain([scope, 'optionalAccess', _15 => _15.current, 'access', _16 => _16.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()
+    };
+    current.current = session;
+    setSnapshot({ ...EMPTY, state: "requesting" });
+    if (transcribe) {
+      try {
+        if (!_optionalChain([navigator, 'access', _17 => _17.mediaDevices, 'optionalAccess', _18 => _18.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', _19 => _19.isTypeSupported, 'optionalCall', _20 => _20(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', _21 => _21.chunks, 'access', _22 => _22[0], 'optionalAccess', _23 => _23.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";
+        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', _24 => _24.current, 'optionalCall', _25 => _25(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;
+    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', _26 => _26.recognition, 'optionalAccess', _27 => _27.abort, 'call', _28 => _28()]);
+          } catch (e3) {
+          }
+          session.resolveNativeEnd();
+        }, 1e3);
+        try {
+          _optionalChain([session, 'access', _29 => _29.recognition, 'optionalAccess', _30 => _30.stop, 'call', _31 => _31()]);
+        } catch (e4) {
+          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', _32 => _32.recorder, 'optionalAccess', _33 => _33.state]) !== "inactive") _optionalChain([session, 'access', _34 => _34.recorder, 'optionalAccess', _35 => _35.stop, 'call', _36 => _36()]);
+        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', _37 => _37.blob, 'optionalAccess', _38 => _38.size]) });
+      return null;
+    }
+    session.transcript = text;
+    session.phase = "ready";
+    setSnapshot({ ...EMPTY, state: "ready", transcript: text });
+    _optionalChain([callback, 'access', _39 => _39.current, 'optionalCall', _40 => _40(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', _41 => _41.transcribe]) || !_optionalChain([session, 'access', _42 => _42.blob, 'optionalAccess', _43 => _43.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, supported, start, stop, retry, cancel };
+}
+
+
+
+
+exports.DictationProvider = DictationProvider; exports.useDictation = useDictation;

package/dist/chunk-UW67GSZ4.cjs

@@ -0,0 +1,127 @@
+"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";
+
+
+var _chunkXB2D4NQKcjs = require('./chunk-XB2D4NQK.cjs');
+
+
+var _chunkJDEXZGIYcjs = require('./chunk-JDEXZGIY.cjs');
+
+
+var _chunkKWLSBTB2cjs = require('./chunk-KWLSBTB2.cjs');
+
+// src/primitives/voice-session-controls.tsx
+var _react = require('react');
+var _lucidereact = require('lucide-react');
+var _jsxruntime = require('react/jsx-runtime');
+var SILENCE = [];
+var silence = () => SILENCE;
+var noSubscription = () => () => {
+};
+var DEFAULT_LABELS = {
+  disconnected: "Voice chat",
+  connecting: "Connecting\u2026",
+  listening: "Listening",
+  thinking: "Thinking\u2026",
+  speaking: "Speaking",
+  reconnecting: "Reconnecting\u2026",
+  error: "Voice chat unavailable",
+  start: "Start voice chat",
+  end: "End voice chat",
+  mute: "Mute microphone",
+  unmute: "Unmute microphone",
+  muted: "Microphone muted",
+  retry: "Retry voice chat"
+};
+function VoiceSessionControls({
+  state,
+  onStart,
+  onEnd,
+  muted = false,
+  onMutedChange,
+  disabled = false,
+  error,
+  volumeBands,
+  audioLevels,
+  labels,
+  size = "icon",
+  className
+}) {
+  const liveBands = _react.useSyncExternalStore.call(void 0, _nullishCoalesce(_optionalChain([audioLevels, 'optionalAccess', _ => _.subscribe]), () => ( noSubscription)), _nullishCoalesce(_optionalChain([audioLevels, 'optionalAccess', _2 => _2.getSnapshot]), () => ( silence)), silence);
+  const copy = { ...DEFAULT_LABELS, ...labels };
+  const active = state !== "disconnected" && state !== "error";
+  const waiting = state === "connecting" || state === "reconnecting";
+  return /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, 
+    "div",
+    {
+      "data-slot": "voice-session-controls",
+      "data-state": state,
+      className: _chunkKWLSBTB2cjs.cn.call(void 0, "flex min-w-0 items-center gap-2", active && "w-full flex-col gap-3 py-4", !active && "flex-wrap", className),
+      children: [
+        active ? /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, _jsxruntime.Fragment, { children: [
+          /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+            _chunkXB2D4NQKcjs.AgentAudioVisualizerBar,
+            {
+              "aria-hidden": "true",
+              size: "sm",
+              barCount: 5,
+              state: state === "reconnecting" ? "connecting" : state,
+              volumeBands: _nullishCoalesce(volumeBands, () => ( liveBands))
+            }
+          ),
+          /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "span", { role: "status", className: "text-sm text-muted-foreground", children: muted && state === "listening" ? copy.muted : copy[state] }),
+          /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, "div", { className: "flex items-center gap-2", children: [
+            /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+              _chunkJDEXZGIYcjs.Button,
+              {
+                type: "button",
+                variant: "ghost",
+                size: "icon",
+                className: "min-h-[44px] min-w-[44px] shrink-0",
+                "aria-label": muted ? copy.unmute : copy.mute,
+                title: muted ? copy.unmute : copy.mute,
+                "aria-pressed": muted,
+                disabled: waiting,
+                onClick: () => onMutedChange(!muted),
+                children: muted ? /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _lucidereact.MicOff, { "aria-hidden": "true" }) : /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _lucidereact.Mic, { "aria-hidden": "true" })
+              }
+            ),
+            /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, 
+              _chunkJDEXZGIYcjs.Button,
+              {
+                type: "button",
+                variant: "outline",
+                shape: "pill",
+                className: "min-h-[44px] shrink-0",
+                "aria-label": copy.end,
+                title: copy.end,
+                onClick: onEnd,
+                children: [
+                  /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _lucidereact.PhoneOff, { "aria-hidden": "true" }),
+                  copy.end
+                ]
+              }
+            )
+          ] })
+        ] }) : /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+          _chunkJDEXZGIYcjs.Button,
+          {
+            type: "button",
+            size: "icon",
+            shape: "circle",
+            disabled,
+            onClick: onStart,
+            "aria-label": state === "error" ? copy.retry : copy.start,
+            title: state === "error" ? copy.retry : copy.start,
+            className: _chunkKWLSBTB2cjs.cn.call(void 0, "min-h-[44px] min-w-[44px] shrink-0 rounded-full", size === "hero" && "size-24 [&_svg]:size-7"),
+            children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _lucidereact.AudioLines, { "aria-hidden": "true" })
+          }
+        ),
+        state === "error" && /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "span", { role: "alert", className: "basis-full text-xs text-destructive", children: error || copy.error })
+      ]
+    }
+  );
+}
+
+
+
+exports.VoiceSessionControls = VoiceSessionControls;

package/dist/chunk-VBKJXNEL.js

@@ -0,0 +1,157 @@
+"use client";
+import {
+  cn
+} from "./chunk-G6SRSWXB.js";
+import {
+  useAgentAudioVisualizerBarAnimator
+} from "./chunk-GJ7S3L6R.js";
+
+// src/primitives/agent-audio-visualizer-bar.tsx
+import React, {
+  Children,
+  cloneElement,
+  isValidElement,
+  useMemo
+} from "react";
+import { cva } from "class-variance-authority";
+import { jsx } from "react/jsx-runtime";
+function normalizeVolumeBands(bands, count) {
+  if (bands.length === count) return bands;
+  if (bands.length > count) return bands.slice(0, count);
+  const lastValue = bands[bands.length - 1] ?? 0;
+  return [...bands, ...new Array(count - bands.length).fill(lastValue)];
+}
+function cloneSingleChild(children, props, key) {
+  return Children.map(children, (child) => {
+    if (isValidElement(child) && Children.only(children)) {
+      const childProps = child.props;
+      if (childProps.className) {
+        props ??= {};
+        props.className = cn(childProps.className, props.className);
+        props.style = {
+          ...childProps.style,
+          ...props.style
+        };
+      }
+      return cloneElement(child, { ...props, key: key ? String(key) : void 0 });
+    }
+    return child;
+  });
+}
+var AgentAudioVisualizerBarElementVariants = cva(
+  [
+    "rounded-full transition-colors duration-250 ease-linear motion-reduce:transition-none",
+    "bg-current/10 data-[lk-highlighted=true]:bg-current"
+  ],
+  {
+    variants: {
+      size: {
+        icon: "w-[4px] min-h-[4px]",
+        sm: "w-[8px] min-h-[8px]",
+        md: "w-[16px] min-h-[16px]",
+        lg: "w-[32px] min-h-[32px]",
+        xl: "w-[64px] min-h-[64px]"
+      }
+    },
+    defaultVariants: {
+      size: "md"
+    }
+  }
+);
+var AgentAudioVisualizerBarVariants = cva("relative flex items-center justify-center", {
+  variants: {
+    size: {
+      icon: "h-[24px] gap-[2px]",
+      sm: "h-[56px] gap-[4px]",
+      md: "h-[112px] gap-[8px]",
+      lg: "h-[224px] gap-[16px]",
+      xl: "h-[448px] gap-[32px]"
+    }
+  },
+  defaultVariants: {
+    size: "md"
+  }
+});
+function AgentAudioVisualizerBar({
+  size = "md",
+  state = "connecting",
+  color,
+  barCount,
+  volumeBands,
+  className,
+  children,
+  style,
+  ...props
+}) {
+  const _barCount = useMemo(() => {
+    if (barCount && Number.isFinite(barCount)) {
+      return Math.max(1, Math.min(64, Math.floor(barCount)));
+    }
+    switch (size) {
+      case "icon":
+      case "sm":
+        return 3;
+      default:
+        return 5;
+    }
+  }, [barCount, size]);
+  const resolvedVolumeBands = normalizeVolumeBands(volumeBands ?? [], _barCount).map((value) => Number.isFinite(value) ? Math.max(0, Math.min(1, value)) : 0);
+  const sequencerInterval = useMemo(() => {
+    switch (state) {
+      case "connecting":
+        return 2e3 / _barCount;
+      case "initializing":
+        return 2e3;
+      case "listening":
+        return 500;
+      case "thinking":
+        return 150;
+      default:
+        return 1e3;
+    }
+  }, [state, _barCount]);
+  const highlightedIndices = useAgentAudioVisualizerBarAnimator(
+    state,
+    _barCount,
+    sequencerInterval
+  );
+  const bands = useMemo(
+    () => state === "speaking" ? resolvedVolumeBands : new Array(_barCount).fill(0),
+    [state, resolvedVolumeBands, _barCount]
+  );
+  if (children && Array.isArray(children)) {
+    throw new Error("AgentAudioVisualizerBar children must be a single element.");
+  }
+  return /* @__PURE__ */ jsx(
+    "div",
+    {
+      "data-lk-state": state,
+      style: { ...style, color },
+      className: cn(AgentAudioVisualizerBarVariants({ size }), className),
+      ...props,
+      children: bands.map(
+        (band, idx) => children ? /* @__PURE__ */ jsx(React.Fragment, { children: cloneSingleChild(children, {
+          "data-lk-index": idx,
+          "data-lk-highlighted": highlightedIndices.includes(idx),
+          style: { height: `${band * 100}%` }
+        }) }, idx) : /* @__PURE__ */ jsx(
+          "div",
+          {
+            "data-lk-index": idx,
+            "data-lk-highlighted": highlightedIndices.includes(idx),
+            style: { height: `${band * 100}%` },
+            className: cn(AgentAudioVisualizerBarElementVariants({ size }))
+          },
+          idx
+        )
+      )
+    }
+  );
+}
+
+export {
+  normalizeVolumeBands,
+  AgentAudioVisualizerBarElementVariants,
+  AgentAudioVisualizerBarVariants,
+  AgentAudioVisualizerBar
+};