@epicbagel/saas-kit 1.7.0 → 1.11.0

package/dist/chunk-HLAHOVEI.js

@@ -0,0 +1,412 @@
+"use client";
+
+// src/hooks/use-dictation.ts
+import { createContext, createElement, useCallback, useContext, useEffect, useMemo, useRef, useState } from "react";
+var DictationContext = createContext(null);
+function DictationProvider({ transcribe, scopeKey, children }) {
+  const scope = useRef({ 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 = useMemo(() => ({ transcribe, scope, generation }), [transcribe, generation]);
+  return createElement(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 {
+      source?.disconnect();
+    } catch {
+    }
+    try {
+      analyser?.disconnect();
+    } catch {
+    }
+    try {
+      void context?.close().catch(() => {
+      });
+    } catch {
+    }
+    levels.update(SILENCE);
+  };
+  try {
+    const Constructor = 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 {
+        stop();
+      }
+    };
+    if (context.state === "suspended") void context.resume().catch(stop);
+    frame = requestAnimationFrame(sample);
+  } catch {
+    stop();
+  }
+  return stop;
+}
+function recognitionConstructor() {
+  if (typeof window === "undefined") return void 0;
+  const speech = window;
+  return speech.SpeechRecognition ?? speech.webkitSpeechRecognition;
+}
+function microphoneError(reason) {
+  const name = reason?.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) {
+  session.stopMeter?.();
+  session.stopMeter = void 0;
+}
+function releaseTracks(session) {
+  releaseMeter(session);
+  session.stream?.getTracks().forEach((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 {
+      }
+    }
+  }
+  const recognition = session.recognition;
+  if (recognition) {
+    recognition.onresult = null;
+    recognition.onerror = null;
+    recognition.onend = null;
+    try {
+      recognition.abort();
+    } catch {
+    }
+  }
+  releaseTracks(session);
+  session.resolveCapture(null);
+  session.resolveNativeEnd();
+}
+function useDictation({ lang = "en-US", continuous = true, onTranscript } = {}) {
+  const provider = useContext(DictationContext);
+  const transcribe = provider?.transcribe ?? null;
+  const scope = provider?.scope ?? null;
+  const scopeGeneration = provider?.generation ?? 0;
+  const [snapshot, setSnapshot] = useState(EMPTY);
+  const [supported, setSupported] = useState(false);
+  const current = useRef(null);
+  const mounted = useRef(true);
+  const callback = useRef(onTranscript);
+  const activeScope = useRef(scope);
+  activeScope.current = scope;
+  callback.current = onTranscript;
+  useEffect(() => {
+    setSupported(transcribe ? typeof navigator !== "undefined" && !!navigator.mediaDevices?.getUserMedia && typeof MediaRecorder !== "undefined" : typeof recognitionConstructor() === "function");
+  }, [transcribe]);
+  const cancel = useCallback(() => {
+    const session = current.current;
+    current.current = null;
+    if (session) dispose(session);
+    if (mounted.current) setSnapshot(EMPTY);
+  }, []);
+  useEffect(() => {
+    const session = current.current;
+    if (session && (session.scope !== scope || session.scopeGeneration !== scopeGeneration)) cancel();
+  }, [cancel, scope, scopeGeneration]);
+  useEffect(() => {
+    mounted.current = true;
+    return () => {
+      mounted.current = false;
+      const session = current.current;
+      current.current = null;
+      if (session) dispose(session);
+    };
+  }, []);
+  const isCurrent = useCallback((session) => mounted.current && current.current === session && session.scope === activeScope.current && session.scopeGeneration === (session.scope?.current.generation ?? 0) && !session.controller.signal.aborted, []);
+  const start = useCallback(async () => {
+    if (scope !== activeScope.current || scopeGeneration !== (scope?.current.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 (!navigator.mediaDevices?.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) => MediaRecorder.isTypeSupported?.(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 || session.chunks[0]?.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) callback.current?.(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 = useCallback(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 {
+            session.recognition?.abort();
+          } catch {
+          }
+          session.resolveNativeEnd();
+        }, 1e3);
+        try {
+          session.recognition?.stop();
+        } catch {
+          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 (session.recorder?.state !== "inactive") session.recorder?.stop();
+        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: !!session.blob?.size });
+      return null;
+    }
+    session.transcript = text;
+    session.phase = "ready";
+    setSnapshot({ ...EMPTY, state: "ready", transcript: text });
+    callback.current?.(text);
+    return text;
+  }, [isCurrent]);
+  const stop = useCallback(() => {
+    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 = useCallback(() => {
+    const session = current.current;
+    if (session && !isCurrent(session)) {
+      cancel();
+      return Promise.resolve(null);
+    }
+    if (!session?.transcribe || !session.blob?.size) return Promise.resolve(null);
+    if (session.phase !== "error") return 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 };
+}
+
+export {
+  DictationProvider,
+  useDictation
+};

package/dist/{chunk-F3B4M6DU.js → chunk-HTPPNW74.js}

@@ -1,7 +1,7 @@
 "use client";
 import {
   CopyButton
-} from "./chunk-HREEZUKL.js";
+} from "./chunk-DILYV4FI.js";
 import {
   cn
 } from "./chunk-G6SRSWXB.js";

package/dist/chunk-KQBXAQAY.cjs

@@ -0,0 +1,221 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } 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 _chunkNKWHDI4Ccjs = require('./chunk-NKWHDI4C.cjs');
+
+
+var _chunkJDEXZGIYcjs = require('./chunk-JDEXZGIY.cjs');
+
+
+var _chunkKWLSBTB2cjs = require('./chunk-KWLSBTB2.cjs');
+
+
+var _chunkZZ7ICQR2cjs = require('./chunk-ZZ7ICQR2.cjs');
+
+// src/primitives/voice-dictation-button.tsx
+
+
+
+
+
+
+var _react = require('react');
+var _reactdialog = require('@radix-ui/react-dialog'); var DialogPrimitive = _interopRequireWildcard(_reactdialog);
+var _lucidereact = require('lucide-react');
+var _jsxruntime = require('react/jsx-runtime');
+function VoiceDictationButton({
+  onCommit,
+  onCancel,
+  title = "Dictate your message",
+  caption = "Recording",
+  lang = "en-US",
+  continuous = true,
+  className,
+  size = "sm",
+  showLabel = false,
+  children,
+  disabled = false,
+  visibility = "visible",
+  shrink = true
+}) {
+  const [open, setOpen] = _react.useState.call(void 0, false);
+  const capture = _chunkZZ7ICQR2cjs.useDictation.call(void 0, { lang, continuous });
+  const { transcript, interimTranscript: interim, supported, error } = capture;
+  const generation = _react.useRef.call(void 0, 0);
+  const finishing = _react.useRef.call(void 0, false);
+  const previousFocus = _react.useRef.call(void 0, null);
+  const elapsed = useRecordingTime(capture.state);
+  const busy = capture.state === "requesting" || capture.state === "transcribing";
+  const openOverlay = _react.useCallback.call(void 0, () => {
+    previousFocus.current = document.activeElement instanceof HTMLElement ? document.activeElement : null;
+    generation.current++;
+    finishing.current = false;
+    setOpen(true);
+    void capture.start();
+  }, [capture.start]);
+  const closeOverlay = _react.useCallback.call(void 0, () => {
+    generation.current++;
+    finishing.current = false;
+    capture.cancel();
+    setOpen(false);
+  }, [capture.cancel]);
+  const handleDone = _react.useCallback.call(void 0, async () => {
+    if (finishing.current || busy) return;
+    if (capture.state === "error" && !capture.canRetry) {
+      void capture.start();
+      return;
+    }
+    finishing.current = true;
+    const started = generation.current;
+    const final = await (capture.canRetry ? capture.retry() : capture.stop());
+    if (started !== generation.current) return;
+    finishing.current = false;
+    if (final === null) return;
+    closeOverlay();
+    if (final) onCommit(final);
+    else _optionalChain([onCancel, 'optionalCall', _ => _()]);
+  }, [busy, capture.canRetry, capture.retry, capture.start, capture.state, capture.stop, onCommit, onCancel, closeOverlay]);
+  const handleCancel = _react.useCallback.call(void 0, () => {
+    closeOverlay();
+    _optionalChain([onCancel, 'optionalCall', _2 => _2()]);
+  }, [closeOverlay, onCancel]);
+  _react.useEffect.call(void 0, () => {
+    if (open && capture.state === "idle") handleCancel();
+  }, [capture.state, handleCancel, open]);
+  _react.useEffect.call(void 0, () => {
+    return () => {
+      generation.current++;
+    };
+  }, []);
+  if (!supported) return null;
+  const displayTranscript = `${transcript}${interim ? (transcript ? " " : "") + interim : ""}`;
+  return /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, _jsxruntime.Fragment, { children: [
+    children ? /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+      "button",
+      {
+        type: "button",
+        onClick: openOverlay,
+        disabled,
+        "aria-label": "Start dictation",
+        className: _chunkKWLSBTB2cjs.cn.call(void 0, visibility === "hidden" && "hidden", className),
+        children
+      }
+    ) : /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+      _chunkJDEXZGIYcjs.Button,
+      {
+        type: "button",
+        onClick: openOverlay,
+        disabled,
+        variant: "outline",
+        size,
+        "aria-label": "Start dictation",
+        className: _chunkKWLSBTB2cjs.cn.call(void 0, "transition-colors", visibility === "hidden" && "hidden", !shrink && "shrink-0", className),
+        children: /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, "span", { className: "flex items-center justify-center gap-2", children: [
+          /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _lucidereact.Mic, { className: "h-4 w-4" }),
+          showLabel && /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "span", { children: "Speak" })
+        ] })
+      }
+    ),
+    /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+      DialogPrimitive.Root,
+      {
+        open,
+        onOpenChange: (next) => {
+          if (!next) handleCancel();
+        },
+        children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, DialogPrimitive.Portal, { children: /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, 
+          DialogPrimitive.Content,
+          {
+            "aria-label": "Voice dictation",
+            "aria-labelledby": void 0,
+            "data-slot": "voice-dictation-panel",
+            "data-state": capture.state,
+            onCloseAutoFocus: (event) => {
+              event.preventDefault();
+              if (_optionalChain([previousFocus, 'access', _3 => _3.current, 'optionalAccess', _4 => _4.isConnected])) previousFocus.current.focus();
+            },
+            onKeyDown: (event) => {
+              if (event.key === "Enter" && !event.shiftKey && !(event.target instanceof HTMLElement && event.target.closest("button, input, textarea, select"))) {
+                event.preventDefault();
+                void handleDone();
+              }
+            },
+            className: "fixed bottom-4 left-1/2 z-[200] flex max-h-[calc(100dvh-2rem)] w-[calc(100%-2rem)] max-w-sm -translate-x-1/2 flex-col gap-3 overflow-y-auto rounded-2xl border border-border bg-background p-4 text-foreground shadow-lg outline-hidden sm:bottom-6",
+            children: [
+              /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, "div", { className: "flex min-w-0 items-start justify-between gap-3", children: [
+                /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, "div", { className: "min-w-0 space-y-1", children: [
+                  /* @__PURE__ */ _jsxruntime.jsx.call(void 0, DialogPrimitive.Title, { className: "text-sm font-medium", children: title || "Voice dictation" }),
+                  /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, "span", { role: "status", className: "flex items-center gap-1.5 text-xs text-muted-foreground", children: [
+                    busy ? /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _lucidereact.LoaderCircle, { "aria-hidden": "true", className: "size-3.5 animate-spin motion-reduce:animate-none" }) : /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _lucidereact.Mic, { "aria-hidden": "true", className: "size-3.5" }),
+                    capture.state === "transcribing" ? "Transcribing\u2026" : capture.state === "requesting" ? "Waiting for microphone\u2026" : error ? "Recording not saved" : capture.state === "ready" ? "Ready" : caption
+                  ] })
+                ] }),
+                /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, "time", { "aria-label": "Recording duration", dateTime: `PT${elapsed}S`, className: "pt-0.5 font-mono text-xs tabular-nums text-muted-foreground", children: [
+                  Math.floor(elapsed / 60).toString().padStart(2, "0"),
+                  ":",
+                  (elapsed % 60).toString().padStart(2, "0")
+                ] })
+              ] }),
+              capture.audioLevels && /* @__PURE__ */ _jsxruntime.jsx.call(void 0, DictationWaveform, { source: capture.audioLevels, state: capture.state }),
+              /* @__PURE__ */ _jsxruntime.jsx.call(void 0, DialogPrimitive.Description, { className: "text-xs text-muted-foreground", children: capture.state === "transcribing" ? "Converting your recording to text\u2026" : capture.state === "requesting" ? "Allow microphone access to start." : error ? capture.canRetry ? "Retry this take or record again." : "Check microphone access, then try again." : "Speak, then choose Done to add the text." }),
+              displayTranscript && /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, "p", { className: "max-h-24 overflow-y-auto text-sm leading-relaxed", children: [
+                transcript,
+                interim && /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, "span", { className: "text-muted-foreground", children: [
+                  transcript ? " " : "",
+                  interim
+                ] })
+              ] }),
+              error && /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "p", { role: "alert", className: "text-xs text-destructive", children: error }),
+              /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, "div", { className: "flex flex-wrap items-center justify-end gap-2", children: [
+                /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _chunkJDEXZGIYcjs.Button, { type: "button", variant: "ghost", size: "sm", className: "min-h-[44px]", onClick: handleCancel, children: "Cancel" }),
+                capture.canRetry && /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _chunkJDEXZGIYcjs.Button, { type: "button", variant: "outline", size: "sm", className: "min-h-[44px]", onClick: () => void capture.start(), children: "Record again" }),
+                /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _chunkJDEXZGIYcjs.Button, { type: "button", size: "sm", className: "min-h-[44px]", onClick: () => void handleDone(), disabled: busy, children: capture.state === "transcribing" ? "Transcribing\u2026" : capture.canRetry ? "Retry transcription" : error ? "Try again" : "Done" })
+              ] })
+            ]
+          }
+        ) })
+      }
+    )
+  ] });
+}
+var SILENCE = [];
+var silence = () => SILENCE;
+function DictationWaveform({ source, state }) {
+  const bands = _react.useSyncExternalStore.call(void 0, source.subscribe, source.getSnapshot, silence);
+  return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+    _chunkNKWHDI4Ccjs.AgentAudioVisualizerBar,
+    {
+      "aria-hidden": "true",
+      "data-slot": "dictation-waveform",
+      size: "icon",
+      barCount: 24,
+      state: state === "recording" ? "listening" : state === "transcribing" ? "thinking" : state === "requesting" ? "connecting" : "disconnected",
+      volumeBands: state === "recording" ? bands : void 0,
+      className: "h-9 w-full text-foreground"
+    }
+  );
+}
+function useRecordingTime(state) {
+  const [elapsed, setElapsed] = _react.useState.call(void 0, 0);
+  const startedAt = _react.useRef.call(void 0, null);
+  _react.useEffect.call(void 0, () => {
+    if (state !== "recording") {
+      if (state === "idle" || state === "requesting") setElapsed(0);
+      else if (startedAt.current !== null) setElapsed(Math.floor((performance.now() - startedAt.current) / 1e3));
+      startedAt.current = null;
+      return;
+    }
+    startedAt.current = performance.now();
+    const update = () => setElapsed(Math.floor((performance.now() - startedAt.current) / 1e3));
+    update();
+    const timer = setInterval(update, 1e3);
+    return () => {
+      clearInterval(timer);
+    };
+  }, [state]);
+  return elapsed;
+}
+
+
+
+exports.VoiceDictationButton = VoiceDictationButton;

package/dist/{chunk-JN6JOSZG.js → chunk-LQPJGZIE.js}

@@ -7,16 +7,16 @@ import {
 } from "./chunk-EEHIMPD7.js";
 import {
   FilterBar
-} from "./chunk-KNKV25WS.js";
-import {
-  Heading
-} from "./chunk-H2O6NMLZ.js";
+} from "./chunk-UFFHGKI7.js";
 import {
   Tooltip,
   TooltipContent,
   TooltipProvider,
   TooltipTrigger
 } from "./chunk-ZRLUUZHK.js";
+import {
+  Heading
+} from "./chunk-H2O6NMLZ.js";
 import {
   BoardColumnComponent,
   MobileBoardView
@@ -30,12 +30,12 @@ import {
 import {
   Button
 } from "./chunk-W326GKML.js";
-import {
-  useIsMobile
-} from "./chunk-PIU5SSUV.js";
 import {
   cn
 } from "./chunk-G6SRSWXB.js";
+import {
+  useIsMobile
+} from "./chunk-PIU5SSUV.js";
 
 // src/primitives/resource-list.tsx
 import { ChevronLeft, ChevronRight, Grid3X3, Kanban, List, Search, X } from "lucide-react";