@opengeni/react 6.5.2-canary.41607687019001 → 6.7.0

package/dist/chunk-SODC7T6L.js

@@ -0,0 +1,1583 @@
+"use client";
+import {
+  useOpenGeniText
+} from "./chunk-7T2ZE3VT.js";
+
+// src/hooks/use-transcription.ts
+import {
+  authorizeTranscriptionAdapter,
+  createTranscriptionSessionRequest
+} from "@opengeni/sdk";
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+var INITIAL_TRANSCRIPTION_CONTROL_STATE = {
+  status: "idle",
+  generation: 0,
+  localSessionId: null,
+  providerSessionId: null,
+  lastSequence: 0,
+  partial: "",
+  error: null,
+  acceptedFinalIds: [],
+  audioMilliseconds: 0,
+  costUsd: null
+};
+function transitionTranscriptionControl(state, action) {
+  if (action.type === "reset") {
+    return {
+      state: { ...INITIAL_TRANSCRIPTION_CONTROL_STATE, generation: state.generation },
+      commit: null
+    };
+  }
+  if (action.type === "start") {
+    if (action.generation <= state.generation) return { state, commit: null };
+    return {
+      state: {
+        ...INITIAL_TRANSCRIPTION_CONTROL_STATE,
+        status: "requesting-permission",
+        generation: action.generation,
+        localSessionId: action.localSessionId
+      },
+      commit: null
+    };
+  }
+  if (action.generation !== state.generation) return { state, commit: null };
+  if (action.type === "start.failed") {
+    if (state.status === "closed" || state.status === "error") return { state, commit: null };
+    return {
+      state: {
+        ...state,
+        status: "error",
+        partial: "",
+        error: { code: normalizeTranscriptionErrorCode(action.code), recoverable: false }
+      },
+      commit: null
+    };
+  }
+  if (action.type === "cancel") {
+    if (!isActiveTranscriptionStatus(state.status)) return { state, commit: null };
+    return {
+      state: { ...state, status: "cancelling", partial: "", error: null },
+      commit: null
+    };
+  }
+  if (action.type === "cancel.settled") {
+    if (state.status !== "cancelling") return { state, commit: null };
+    return { state: { ...state, status: "closed", partial: "" }, commit: null };
+  }
+  const event = action.event;
+  if (event.localSessionId !== state.localSessionId) return { state, commit: null };
+  if (!Number.isSafeInteger(event.sequence) || event.sequence <= state.lastSequence) {
+    return { state, commit: null };
+  }
+  if (state.status === "closed" || state.status === "error") return { state, commit: null };
+  if (state.status === "cancelling" && event.type !== "session.closed") {
+    return { state: { ...state, lastSequence: event.sequence }, commit: null };
+  }
+  const sequenced = { ...state, lastSequence: event.sequence };
+  switch (event.type) {
+    case "permission.requested":
+      return {
+        state: { ...sequenced, status: "requesting-permission", partial: "", error: null },
+        commit: null
+      };
+    case "session.opened":
+      return {
+        state: {
+          ...sequenced,
+          status: "listening",
+          providerSessionId: event.providerSessionId,
+          error: null
+        },
+        commit: null
+      };
+    case "transcript.partial":
+      return {
+        state: { ...sequenced, status: "listening", partial: event.text, error: null },
+        commit: null
+      };
+    case "transcript.final": {
+      const text = event.text.trim();
+      const duplicate = state.acceptedFinalIds.includes(event.providerAcceptanceId);
+      const acceptedFinalIds = duplicate || text.length === 0 ? state.acceptedFinalIds : [...state.acceptedFinalIds, event.providerAcceptanceId];
+      return {
+        state: {
+          ...sequenced,
+          status: "listening",
+          partial: "",
+          error: null,
+          acceptedFinalIds
+        },
+        commit: duplicate || text.length === 0 ? null : text
+      };
+    }
+    case "usage":
+      return {
+        state: {
+          ...sequenced,
+          audioMilliseconds: Math.max(state.audioMilliseconds, event.audioMilliseconds),
+          costUsd: event.costUsd
+        },
+        commit: null
+      };
+    case "session.reconnecting":
+      return {
+        state: { ...sequenced, status: "reconnecting", partial: "", error: null },
+        commit: null
+      };
+    case "session.error":
+      return {
+        state: {
+          ...sequenced,
+          status: event.recoverable ? "reconnecting" : "error",
+          partial: "",
+          error: {
+            code: normalizeTranscriptionErrorCode(event.code),
+            recoverable: event.recoverable
+          }
+        },
+        commit: null
+      };
+    case "session.closed":
+      return {
+        state: {
+          ...sequenced,
+          status: event.reason === "error" ? "error" : "closed",
+          partial: ""
+        },
+        commit: null
+      };
+  }
+}
+function appendFinalTranscript(draft, transcript) {
+  const final = transcript.trim();
+  if (!final) return draft;
+  if (!draft) return final;
+  return /\s$/u.test(draft) ? `${draft}${final}` : `${draft} ${final}`;
+}
+var DEFAULT_TRANSCRIPTION_LIFECYCLE_TIMEOUTS = {
+  startMs: 15e3,
+  cleanupMs: 2e3
+};
+function useTranscription({
+  adapter,
+  policy,
+  selection = { kind: "primary" },
+  value,
+  setValue,
+  focusInput,
+  disabled = false,
+  createLocalSessionId = defaultLocalSessionId,
+  lifecycleTimeouts,
+  onDiagnostic
+}) {
+  const t = useOpenGeniText();
+  const [state, setState] = useState(INITIAL_TRANSCRIPTION_CONTROL_STATE);
+  const stateRef = useRef(state);
+  const valueRef = useRef(value);
+  const sessionRef = useRef(null);
+  const pendingStartRef = useRef(null);
+  const activePolicyRef = useRef(null);
+  valueRef.current = value;
+  const startTimeoutMs = normalizeTimeout(
+    lifecycleTimeouts?.startMs,
+    DEFAULT_TRANSCRIPTION_LIFECYCLE_TIMEOUTS.startMs
+  );
+  const cleanupTimeoutMs = normalizeTimeout(
+    lifecycleTimeouts?.cleanupMs,
+    DEFAULT_TRANSCRIPTION_LIFECYCLE_TIMEOUTS.cleanupMs
+  );
+  const reportDiagnostic = useCallback(
+    (diagnostic) => {
+      if (!onDiagnostic) return;
+      try {
+        onDiagnostic(normalizeTranscriptionDiagnostic(t, diagnostic));
+      } catch {
+      }
+    },
+    [onDiagnostic, t]
+  );
+  const cleanupRuntimeRef = useRef({ cleanupTimeoutMs, reportDiagnostic });
+  useEffect(() => {
+    cleanupRuntimeRef.current = { cleanupTimeoutMs, reportDiagnostic };
+  }, [cleanupTimeoutMs, reportDiagnostic]);
+  const policyRevision = useMemo(
+    () => transcriptionPolicyRevision(policy, selection),
+    [policy, selection]
+  );
+  const authorization = useMemo(
+    () => adapter ? authorizeTranscriptionAdapter(policy, adapter.descriptor, selection) : null,
+    [adapter, policy, selection]
+  );
+  const unavailableReason = disabled ? "composer_disabled" : !policy.enabled ? "disabled" : !policy.acceptanceId ? "unaccepted" : !policy.primary ? "target_missing" : !adapter ? "adapter_missing" : authorization?.authorized ? null : authorization?.reason ?? "unaccepted";
+  const apply = useCallback(
+    (action) => {
+      const transition = transitionTranscriptionControl(stateRef.current, action);
+      if (transition.state !== stateRef.current) {
+        stateRef.current = transition.state;
+        setState(transition.state);
+      }
+      if (transition.commit !== null) {
+        const next = appendFinalTranscript(valueRef.current, transition.commit);
+        valueRef.current = next;
+        setValue(next);
+        focusInput();
+      }
+      return transition.state;
+    },
+    [focusInput, setValue]
+  );
+  const releaseTerminalSession = useCallback(
+    (generation) => {
+      const active = sessionRef.current;
+      if (!active || active.generation !== generation) return;
+      sessionRef.current = null;
+      if (activePolicyRef.current?.generation === generation) activePolicyRef.current = null;
+      detachSessionCleanup(t, active.session, {
+        cleanupTimeoutMs,
+        reportDiagnostic
+      });
+    },
+    [cleanupTimeoutMs, reportDiagnostic, t]
+  );
+  const start = useCallback(async () => {
+    if (!adapter || unavailableReason !== null || isActiveTranscriptionStatus(stateRef.current.status)) {
+      return false;
+    }
+    const generation = stateRef.current.generation + 1;
+    const localSessionId = createLocalSessionId();
+    apply({ type: "start", generation, localSessionId });
+    const request = createTranscriptionSessionRequest({
+      policy,
+      adapter,
+      localSessionId,
+      selection,
+      sequenceFloor: 0
+    });
+    if (!request) {
+      apply({
+        type: "start.failed",
+        generation,
+        code: "policy_blocked"
+      });
+      return false;
+    }
+    activePolicyRef.current = { generation, revision: policyRevision };
+    const controller = new AbortController();
+    pendingStartRef.current = { generation, controller };
+    let boundarySettled = false;
+    let accepted = false;
+    const observedStart = Promise.resolve().then(
+      () => adapter.start(
+        request,
+        (event) => {
+          apply({ type: "event", generation, event });
+          if (event.type === "session.error" && !event.recoverable) {
+            releaseTerminalSession(generation);
+          } else if (event.type === "session.closed") {
+            releaseTerminalSession(generation);
+          }
+        },
+        {
+          signal: controller.signal,
+          reportDiagnostic
+        }
+      )
+    ).then(
+      (session) => {
+        if (boundarySettled && !accepted) {
+          detachSessionCleanup(t, session, {
+            cancelReason: "stale-generation",
+            cleanupTimeoutMs,
+            reportDiagnostic
+          });
+        }
+        return { kind: "session", session };
+      },
+      (error) => {
+        if (boundarySettled) {
+          reportDiagnostic({
+            operation: "start",
+            code: classifyStartError(error),
+            detail: diagnosticDetail(t, error)
+          });
+        }
+        return { kind: "error", error };
+      }
+    );
+    let abortListener = null;
+    const aborted = new Promise((resolve) => {
+      if (controller.signal.aborted) {
+        resolve({ kind: "aborted" });
+        return;
+      }
+      abortListener = () => resolve({ kind: "aborted" });
+      controller.signal.addEventListener("abort", abortListener, { once: true });
+    });
+    let timeoutId = null;
+    const timedOut = new Promise((resolve) => {
+      timeoutId = setTimeout(() => resolve({ kind: "timeout" }), startTimeoutMs);
+    });
+    const outcome = await Promise.race([observedStart, aborted, timedOut]);
+    boundarySettled = true;
+    if (timeoutId !== null) clearTimeout(timeoutId);
+    if (abortListener) controller.signal.removeEventListener("abort", abortListener);
+    if (pendingStartRef.current?.generation === generation) pendingStartRef.current = null;
+    if (outcome.kind === "aborted") return false;
+    if (outcome.kind === "timeout") {
+      controller.abort("transcription-start-timeout");
+      if (activePolicyRef.current?.generation === generation) activePolicyRef.current = null;
+      reportDiagnostic({
+        operation: "start",
+        code: "timeout",
+        detail: t("hooks.useTranscription.transcriptionAdapterStartExceededStarttimeoutms", {
+          startTimeoutMs
+        })
+      });
+      apply({ type: "start.failed", generation, code: "timeout" });
+      return false;
+    }
+    if (outcome.kind === "error") {
+      if (activePolicyRef.current?.generation === generation) activePolicyRef.current = null;
+      const code = classifyStartError(outcome.error);
+      reportDiagnostic({
+        operation: "start",
+        code,
+        detail: diagnosticDetail(t, outcome.error)
+      });
+      if (!controller.signal.aborted) {
+        apply({ type: "start.failed", generation, code });
+      }
+      return false;
+    }
+    const current = stateRef.current;
+    if (current.generation !== generation || current.localSessionId !== localSessionId || current.status === "cancelling" || !isActiveTranscriptionStatus(current.status)) {
+      if (activePolicyRef.current?.generation === generation) activePolicyRef.current = null;
+      detachSessionCleanup(t, outcome.session, {
+        ...current.status === "error" ? {} : { cancelReason: "stale-generation" },
+        cleanupTimeoutMs,
+        reportDiagnostic
+      });
+      return false;
+    }
+    accepted = true;
+    sessionRef.current = { generation, session: outcome.session };
+    return true;
+  }, [
+    adapter,
+    apply,
+    createLocalSessionId,
+    cleanupTimeoutMs,
+    policy,
+    policyRevision,
+    releaseTerminalSession,
+    reportDiagnostic,
+    selection,
+    startTimeoutMs,
+    unavailableReason,
+    t
+  ]);
+  const cancel = useCallback(async () => {
+    const current = stateRef.current;
+    if (!isActiveTranscriptionStatus(current.status)) return false;
+    const generation = current.generation;
+    apply({ type: "cancel", generation });
+    const pending = pendingStartRef.current;
+    if (pending?.generation === generation) {
+      pendingStartRef.current = null;
+      pending.controller.abort("transcription-locally-cancelled");
+    }
+    const active = sessionRef.current;
+    sessionRef.current = null;
+    if (activePolicyRef.current?.generation === generation) activePolicyRef.current = null;
+    apply({ type: "cancel.settled", generation });
+    focusInput();
+    if (active?.generation === generation) {
+      detachSessionCleanup(t, active.session, {
+        cancelReason: "user-cancelled",
+        cleanupTimeoutMs,
+        reportDiagnostic
+      });
+    }
+    return true;
+  }, [apply, cleanupTimeoutMs, focusInput, reportDiagnostic, t]);
+  const reset = useCallback(() => apply({ type: "reset" }), [apply]);
+  useEffect(() => {
+    if (!isActiveTranscriptionStatus(state.status)) return;
+    const onKeyDown = (event) => {
+      if (event.key !== "Escape") return;
+      event.preventDefault();
+      void cancel();
+    };
+    document.addEventListener("keydown", onKeyDown);
+    return () => document.removeEventListener("keydown", onKeyDown);
+  }, [cancel, state.status]);
+  useEffect(() => {
+    if (!isActiveTranscriptionStatus(state.status)) return;
+    const activePolicy = activePolicyRef.current;
+    if (unavailableReason === null && activePolicy?.generation === state.generation && activePolicy.revision === policyRevision) {
+      return;
+    }
+    void cancel();
+  }, [cancel, policyRevision, state.generation, state.status, unavailableReason]);
+  useEffect(
+    () => () => {
+      const pending = pendingStartRef.current;
+      pendingStartRef.current = null;
+      pending?.controller.abort("transcription-component-unmounted");
+      const active = sessionRef.current;
+      sessionRef.current = null;
+      activePolicyRef.current = null;
+      stateRef.current = {
+        ...stateRef.current,
+        generation: stateRef.current.generation + 1,
+        status: "closed",
+        partial: ""
+      };
+      if (active) {
+        const runtime = cleanupRuntimeRef.current;
+        detachSessionCleanup(t, active.session, {
+          cancelReason: "component-unmounted",
+          cleanupTimeoutMs: runtime.cleanupTimeoutMs,
+          reportDiagnostic: runtime.reportDiagnostic
+        });
+      }
+    },
+    [t]
+  );
+  return {
+    state,
+    available: unavailableReason === null,
+    unavailableReason,
+    start,
+    cancel,
+    reset
+  };
+}
+function isActiveTranscriptionStatus(status) {
+  return status === "requesting-permission" || status === "listening" || status === "reconnecting" || status === "cancelling";
+}
+function defaultLocalSessionId() {
+  return globalThis.crypto.randomUUID();
+}
+function classifyStartError(error) {
+  if (isRecord(error)) {
+    const normalized = normalizeTranscriptionErrorCode(error.code);
+    if (normalized !== "unknown") return normalized;
+  }
+  if (typeof DOMException !== "undefined" && error instanceof DOMException) {
+    if (error.name === "NotAllowedError") return "permission_denied";
+    if (error.name === "NotSupportedError") return "not_supported";
+    if (error.name === "TimeoutError") return "timeout";
+    if (error.name === "AbortError") return "cancelled";
+  }
+  return "unknown";
+}
+function normalizeTranscriptionErrorCode(code) {
+  switch (code) {
+    case "insufficient_credits":
+    case "allowance_exhausted":
+    case "monthly_model_cost_limit":
+    case "unavailable":
+    case "too_large":
+    case "invalid_audio":
+    case "permission_denied":
+    case "not_supported":
+    case "network":
+    case "provider":
+    case "policy_blocked":
+    case "timeout":
+    case "cancelled":
+    case "unknown":
+      return code;
+    default:
+      return "unknown";
+  }
+}
+function normalizeTranscriptionDiagnostic(t, diagnostic) {
+  const source = isRecord(diagnostic) ? diagnostic : {};
+  const operation = source.operation === "start" || source.operation === "session" || source.operation === "cancel" || source.operation === "close" ? source.operation : "session";
+  const rawDetail = typeof source.detail === "string" ? source.detail : t("hooks.useTranscription.noDiagnosticDetail");
+  return {
+    operation,
+    code: normalizeTranscriptionErrorCode(source.code),
+    detail: rawDetail
+  };
+}
+function detachSessionCleanup(t, session, options) {
+  if (options.cancelReason) {
+    void runBoundedCleanup(
+      t,
+      "cancel",
+      () => session.cancel(options.cancelReason),
+      options.cleanupTimeoutMs,
+      options.reportDiagnostic
+    );
+  }
+  void runBoundedCleanup(
+    t,
+    "close",
+    () => session.close(),
+    options.cleanupTimeoutMs,
+    options.reportDiagnostic
+  );
+}
+async function runBoundedCleanup(t, operation, invoke, timeoutMs, reportDiagnostic) {
+  let timeoutId = null;
+  const result = Promise.resolve().then(invoke).then(
+    () => ({ kind: "settled" }),
+    (error) => ({ kind: "rejected", error })
+  );
+  const timeout = new Promise((resolve) => {
+    timeoutId = setTimeout(() => resolve({ kind: "timeout" }), timeoutMs);
+  });
+  const outcome = await Promise.race([result, timeout]);
+  if (timeoutId !== null) clearTimeout(timeoutId);
+  if (outcome.kind === "settled") return;
+  reportDiagnostic({
+    operation,
+    code: outcome.kind === "timeout" ? "timeout" : "provider",
+    detail: outcome.kind === "timeout" ? t("hooks.useTranscription.transcriptionOperationExceededTimeoutmsMs", {
+      operation,
+      timeoutMs
+    }) : diagnosticDetail(t, outcome.error)
+  });
+}
+function diagnosticDetail(t, error) {
+  if (error instanceof Error) return error.message;
+  return typeof error === "string" ? error : t("hooks.useTranscription.unknownTranscriptionAdapterFailure");
+}
+function normalizeTimeout(value, fallback) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 1 ? Math.min(Math.floor(value), 6e4) : fallback;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function transcriptionPolicyRevision(policy, selection) {
+  const targetKey = (target) => target ? [
+    target.provider,
+    target.model ?? "",
+    target.credentialMode,
+    target.credentialConnectionId ?? "",
+    target.region ?? ""
+  ].join("\0") : "";
+  return [
+    policy.enabled ? "1" : "0",
+    policy.acceptanceId ?? "",
+    targetKey(policy.primary),
+    policy.language ?? "",
+    policy.autoDetectLanguage ? "1" : "0",
+    policy.diarization.enabled ? "1" : "0",
+    policy.diarization.maxSpeakers?.toString() ?? "",
+    policy.retention.mode,
+    policy.retention.maxDays?.toString() ?? "",
+    policy.privacy.allowProviderLogging ? "1" : "0",
+    policy.privacy.allowProviderTraining ? "1" : "0",
+    policy.fallback.mode,
+    policy.fallback.targets.map(targetKey).join("
"),
+    policy.cost.currency,
+    policy.cost.maxPerHour?.toString() ?? "",
+    policy.cost.maxPerMonth?.toString() ?? "",
+    selection.kind,
+    selection.kind === "fallback" ? selection.index.toString() : ""
+  ].join("");
+}
+
+// src/hooks/use-voice-input.ts
+import {
+  OpenGeniRecordingsClient,
+  RecordingUploader,
+  browserRecorderPlatform,
+  uploadRecordingAudio
+} from "@opengeni/sdk/recordings";
+import { useCallback as useCallback2, useEffect as useEffect2, useMemo as useMemo2, useRef as useRef2, useState as useState2 } from "react";
+var VOICE_RECORDING_TIMESLICE_MILLISECONDS = 1e3;
+var VOICE_RECORDING_OWNER_HEARTBEAT_MILLISECONDS = 5e3;
+var VOICE_RECORDING_OWNER_STALE_MILLISECONDS = 3e4;
+var VOICE_RECORDING_CLIENT_MAX_DURATION_SECONDS = 600;
+var VOICE_RECORDING_RESUMABLE_CLIENT_MAX_DURATION_SECONDS = 8 * 60 * 60;
+var ACCIDENTAL_START_MAX_MILLISECONDS = 3e3;
+var DEFAULT_POLL_MILLISECONDS = 1e3;
+var MAX_POLL_MILLISECONDS = 15e3;
+var TAKEN_STORAGE_KEY = "opengeni.voice-input.taken.v1";
+var MIME_PREFERENCES = ["audio/webm;codecs=opus", "audio/mp4", "audio/ogg;codecs=opus"];
+var currentDate = () => /* @__PURE__ */ new Date();
+var recordingClients = /* @__PURE__ */ new WeakMap();
+function dictationClient(explicit, client) {
+  let candidate = explicit;
+  if (!candidate && client && typeof client.requestJson === "function") {
+    candidate = recordingClients.get(client);
+    if (!candidate) {
+      const created = new OpenGeniRecordingsClient(client);
+      recordingClients.set(client, created);
+      candidate = created;
+    }
+  }
+  if (!candidate) return null;
+  const methods = candidate;
+  const required = [
+    "createRecording",
+    "createRecordingUploads",
+    "completeRecordingChunks",
+    "finalizeRecording",
+    "deleteRecording",
+    "listRecordings",
+    "listRecordingTranscriptVersions",
+    "getRecordingTranscript",
+    "createRecordingTranscript"
+  ];
+  return required.every((method) => typeof methods[method] === "function") ? candidate : null;
+}
+function useVoiceInput(options) {
+  const { workspaceId, capability, enabled, value, focusInput, disabled = false } = options;
+  const sdkClient = options.client;
+  const recordings = useMemo2(
+    () => dictationClient(options.recordings, sdkClient),
+    [options.recordings, sdkClient]
+  );
+  const defaultPlatform = useMemo2(() => browserRecorderPlatform(), []);
+  const platform = options.platform ?? defaultPlatform;
+  const durable = Boolean(recordings && capability?.resumable && platform.supported);
+  const [status, setStatus] = useState2("idle");
+  const [error, setError] = useState2(null);
+  const [stream, setStream] = useState2(null);
+  const [recordingId, setRecordingId] = useState2(null);
+  const [durationSeconds, setDurationSeconds] = useState2(0);
+  const [recordingStartedAt, setRecordingStartedAt] = useState2(null);
+  const [savedTranscript, setSavedTranscript] = useState2(null);
+  const [held, setHeld] = useState2(false);
+  const errorRef = useRef2(null);
+  errorRef.current = error;
+  const latest = useRef2({
+    ...options,
+    recordings,
+    platform,
+    durable,
+    disabled,
+    value
+  });
+  latest.current = { ...options, recordings, platform, durable, disabled, value };
+  const statusRef = useRef2(status);
+  statusRef.current = status;
+  const generationRef = useRef2(0);
+  const dictationRef = useRef2(null);
+  const recorderRef = useRef2(null);
+  const oneShotRef = useRef2(null);
+  const oneShotLanguage = useRef2(null);
+  const gatingRef = useRef2(false);
+  const stopTimerRef = useRef2(null);
+  const uploaderRef = useRef2(null);
+  const audioCopies = useRef2(/* @__PURE__ */ new Map());
+  const handed = useRef2(null);
+  const startedAtRef = useRef2(0);
+  const oneShotText = useRef2(null);
+  const watchRef = useRef2(async () => void 0);
+  const loadSavedRef = useRef2(async () => void 0);
+  const now = useCallback2(() => (latest.current.now ?? currentDate)(), []);
+  const maxRecordingSeconds = capability ? durable && capability.resumable ? Math.min(
+    capability.resumable.maxDurationSeconds,
+    VOICE_RECORDING_RESUMABLE_CLIENT_MAX_DURATION_SECONDS
+  ) : Math.min(capability.maxDurationSeconds, VOICE_RECORDING_CLIENT_MAX_DURATION_SECONDS) : null;
+  const maxRecordingSecondsRef = useRef2(maxRecordingSeconds);
+  maxRecordingSecondsRef.current = maxRecordingSeconds;
+  const transport = useMemo2(() => {
+    const current = () => {
+      const found = latest.current.recordings;
+      if (!found) throw new Error("Dictation needs a recordings client.");
+      return found;
+    };
+    return {
+      createRecording: (...args) => current().createRecording(...args),
+      createRecordingUploads: (...args) => current().createRecordingUploads(...args),
+      completeRecordingChunks: (...args) => current().completeRecordingChunks(...args),
+      finalizeRecording: (...args) => current().finalizeRecording(...args),
+      deleteRecording: (...args) => current().deleteRecording(...args)
+    };
+  }, []);
+  const uploader = useCallback2(() => {
+    if (!uploaderRef.current) {
+      const current = latest.current.platform;
+      const isCaptureActive = current.isCaptureActive;
+      uploaderRef.current = new RecordingUploader({
+        client: transport,
+        store: copyingStore(current.createStore(), audioCopies.current),
+        ...current.fetch ? { fetch: current.fetch } : {},
+        ...isCaptureActive ? { isCaptureActive: (id) => isCaptureActive(id) } : {}
+      });
+    }
+    return uploaderRef.current;
+  }, [transport]);
+  const clearStopTimer = () => {
+    if (stopTimerRef.current) clearTimeout(stopTimerRef.current);
+    stopTimerRef.current = null;
+  };
+  const settleIdle = useCallback2(() => {
+    dictationRef.current = null;
+    recorderRef.current = null;
+    oneShotRef.current = null;
+    handed.current = null;
+    clearStopTimer();
+    setStatus("idle");
+    setError(null);
+    setStream(null);
+    setRecordingId(null);
+    setDurationSeconds(0);
+    setRecordingStartedAt(null);
+    setSavedTranscript(null);
+    setHeld(false);
+  }, []);
+  const hold = useCallback2(
+    (dictation, next, code = null, autoInsert = false) => {
+      dictationRef.current = { ...dictation, autoInsert };
+      setRecordingId(dictation.recordingId);
+      setSavedTranscript(dictation.text);
+      setHeld(true);
+      setStatus(next);
+      setError(code);
+      setStream(null);
+      setRecordingStartedAt(null);
+    },
+    []
+  );
+  const insertText = useCallback2((text) => {
+    const { setValue: write, focusInput: focus } = latest.current;
+    write(appendFinalTranscript(latest.current.value, text));
+    focus();
+  }, []);
+  const giveAudio = useCallback2((audio) => {
+    try {
+      latest.current.onAudio?.(audio);
+    } catch {
+    }
+  }, []);
+  const loadSaved = useCallback2(
+    async (generation) => {
+      const client = latest.current.recordings;
+      const workspace = latest.current.workspaceId;
+      if (!client || !latest.current.durable || latest.current.recover === false) return;
+      const resumed = await uploader().resume({
+        only: (stored) => stored.create.purpose === "dictation" && stored.workspaceId === workspace
+      }).catch(() => []);
+      let listed;
+      try {
+        listed = await client.listRecordings(workspace, { purpose: "dictation", limit: 10 });
+      } catch {
+        return;
+      }
+      if (generation !== generationRef.current || dictationRef.current) return;
+      const taken = readTaken();
+      const listedIds = new Set(listed.recordings.map((recording) => recording.id));
+      for (const recording of listed.recordings) {
+        if (taken.has(recording.id)) {
+          void client.deleteRecording(workspace, recording.id).then(
+            () => forgetTaken(recording.id),
+            (cause) => {
+              if (httpStatus(cause) === 404) forgetTaken(recording.id);
+            }
+          );
+          continue;
+        }
+        const dictation = {
+          recordingId: recording.id,
+          autoInsert: false,
+          fresh: false,
+          text: null
+        };
+        if (recording.state === "capturing") {
+          if (!resumed.includes(recording.id)) continue;
+          hold(dictation, "retrying");
+          void uploader().finish(recording.id).then(
+            (upload) => {
+              if (generation !== generationRef.current) return;
+              if (upload.discarded) settleIdle();
+              else if (upload.failed)
+                hold(dictation, "error", voiceInputCode(upload.failed.code));
+              else void watchRef.current(dictation, null, generation);
+            },
+            () => void 0
+          );
+          return;
+        }
+        if (recording.state === "failed") {
+          hold(
+            dictation,
+            "error",
+            voiceInputCode(recording.transcript?.errorCode ?? recording.errorCode)
+          );
+          return;
+        }
+        hold(dictation, recording.state === "ready" ? "transcribing" : "retrying");
+        void watchRef.current(dictation, null, generation);
+        return;
+      }
+      const unlisted = resumed.filter((id) => !listedIds.has(id));
+      if (unlisted.length > 0) {
+        void Promise.any(unlisted.map((id) => uploader().finish(id))).then(
+          () => {
+            if (generation === generationRef.current && !dictationRef.current) {
+              void loadSavedRef.current(generation);
+            }
+          },
+          () => void 0
+        );
+      }
+    },
+    [hold, settleIdle, uploader]
+  );
+  loadSavedRef.current = loadSaved;
+  const take = useCallback2(
+    async (dictation, text, generation) => {
+      const client = latest.current.recordings;
+      const workspace = latest.current.workspaceId;
+      let insert = true;
+      if (client) {
+        try {
+          await client.deleteRecording(workspace, dictation.recordingId);
+        } catch (cause) {
+          if (httpStatus(cause) === 404) {
+            insert = false;
+          } else {
+            rememberTaken(dictation.recordingId);
+          }
+        }
+      }
+      if (generation !== generationRef.current) {
+        if (insert && text.trim()) rememberTaken(dictation.recordingId);
+        return;
+      }
+      if (insert && text.trim()) insertText(text);
+      settleIdle();
+      void loadSaved(generation);
+    },
+    [insertText, loadSaved, settleIdle]
+  );
+  const watch = useCallback2(
+    async (dictation, versionId, generation) => {
+      const client = latest.current.recordings;
+      const workspace = latest.current.workspaceId;
+      if (!client) return;
+      let delay = latest.current.pollIntervalMilliseconds ?? DEFAULT_POLL_MILLISECONDS;
+      for (; ; ) {
+        if (generation !== generationRef.current) return;
+        let version;
+        try {
+          const versions = await client.listRecordingTranscriptVersions(
+            workspace,
+            dictation.recordingId
+          );
+          version = versionId ? versions.find((item) => item.id === versionId) : [...versions].sort((left, right) => right.createdAt.localeCompare(left.createdAt))[0];
+        } catch (cause) {
+          if (httpStatus(cause) === 404) {
+            if (generation === generationRef.current) settleIdle();
+            return;
+          }
+          delay = Math.min(MAX_POLL_MILLISECONDS, delay * 2);
+        }
+        if (generation !== generationRef.current) return;
+        if (version?.state === "failed") {
+          hold(dictation, "error", voiceInputCode(version.errorCode));
+          return;
+        }
+        if (version?.state === "complete") {
+          const text = await transcriptText(client, workspace, dictation.recordingId, version.id);
+          if (generation !== generationRef.current) return;
+          if (text === null) {
+            delay = Math.min(MAX_POLL_MILLISECONDS, delay * 2);
+          } else {
+            const current = dictationRef.current;
+            const automatic = current?.recordingId === dictation.recordingId && current.autoInsert && !latest.current.disabled;
+            if (automatic) {
+              await take(dictation, text, generation);
+            } else {
+              const waitingForSend = current?.recordingId === dictation.recordingId && current.autoInsert;
+              hold({ ...dictation, text }, "transcript-ready", null, waitingForSend);
+            }
+            return;
+          }
+        }
+        await sleep(delay);
+      }
+    },
+    [hold, settleIdle, take]
+  );
+  watchRef.current = watch;
+  const finishOneShot = useCallback2(
+    async (capture, generation, autoInsert) => {
+      const audio = await capture.stop();
+      oneShotRef.current = null;
+      if (generation !== generationRef.current) return;
+      if (!audio || audio.size === 0) {
+        settleIdle();
+        return;
+      }
+      const copy = {
+        recordingId: null,
+        audio,
+        durationMilliseconds: Math.round(capture.durationSeconds() * 1e3)
+      };
+      giveAudio(copy);
+      handed.current = copy;
+      const maxBytes = latest.current.capability?.maxSizeBytes;
+      if (maxBytes !== void 0 && audio.size > maxBytes) {
+        settleIdle();
+        setStatus("error");
+        setError("too_large");
+        return;
+      }
+      const client = latest.current.client;
+      if (!client) return;
+      setStatus("transcribing");
+      try {
+        const response = await client.transcribeAudio(latest.current.workspaceId, {
+          audio,
+          mimeType: audio.type || capture.mimeType,
+          durationSeconds: capture.durationSeconds(),
+          ...oneShotLanguage.current ? { language: oneShotLanguage.current } : {}
+        });
+        if (generation !== generationRef.current) return;
+        if (autoInsert && !latest.current.disabled) {
+          insertText(response.text);
+          settleIdle();
+        } else {
+          oneShotText.current = response.text;
+          setSavedTranscript(response.text);
+          setHeld(true);
+          setStatus("transcript-ready");
+        }
+      } catch (cause) {
+        if (generation !== generationRef.current) return;
+        settleIdle();
+        setStatus("error");
+        setError(errorCode(cause));
+      }
+    },
+    [giveAudio, insertText, settleIdle]
+  );
+  const finishCapture = useCallback2(
+    async (autoInsert) => {
+      const generation = generationRef.current;
+      clearStopTimer();
+      const oneShot = oneShotRef.current;
+      if (oneShot) {
+        setStatus("saving");
+        setStream(null);
+        await finishOneShot(oneShot, generation, autoInsert);
+        return;
+      }
+      const recorder = recorderRef.current;
+      if (!recorder) return;
+      const id = recorder.snapshot.recordingId;
+      const elapsed = recorder.snapshot.elapsedMilliseconds;
+      setStatus(autoInsert ? "saving" : "recovered");
+      setStream(null);
+      setRecordingStartedAt(null);
+      if (dictationRef.current) dictationRef.current.autoInsert = autoInsert;
+      let upload;
+      try {
+        upload = await recorder.stop();
+      } catch {
+        upload = null;
+      }
+      recorderRef.current = null;
+      const audio = id ? takeCopy(audioCopies.current, id) : null;
+      if (generation !== generationRef.current || !id) return;
+      if (!upload || upload.discarded) {
+        settleIdle();
+        return;
+      }
+      if (audio && latest.current.onAudio && !upload.failed) {
+        const copy = { recordingId: id, audio, durationMilliseconds: elapsed };
+        giveAudio(copy);
+        handed.current = copy;
+      }
+      const dictation = dictationRef.current ?? {
+        recordingId: id,
+        autoInsert,
+        fresh: true,
+        text: null
+      };
+      if (upload.failed) {
+        await uploader().discard(id).catch(() => void 0);
+        settleIdle();
+        setStatus("error");
+        setError(voiceInputCode(upload.failed.code));
+        return;
+      }
+      const versionId = uploader().finalized.get(id)?.transcript.id ?? null;
+      if (dictation.autoInsert) setStatus("transcribing");
+      else hold(dictation, "recovered");
+      await watch(dictation, versionId, generation);
+    },
+    [finishOneShot, giveAudio, hold, settleIdle, uploader, watch]
+  );
+  const stop = useCallback2(() => {
+    if (statusRef.current !== "recording") return;
+    void finishCapture(true);
+  }, [finishCapture]);
+  const beginCapture = useCallback2(
+    (input, id) => {
+      startedAtRef.current = now().getTime();
+      setStream(input);
+      setRecordingId(id);
+      setDurationSeconds(0);
+      setRecordingStartedAt(startedAtRef.current);
+      setStatus("recording");
+      const limit = maxRecordingSecondsRef.current;
+      if (limit) {
+        stopTimerRef.current = setTimeout(() => {
+          if (statusRef.current === "recording") void finishCapture(true);
+        }, limit * 1e3);
+      }
+    },
+    [finishCapture, now]
+  );
+  const start = useCallback2(async () => {
+    const startable = () => {
+      const current2 = latest.current;
+      return !(!current2.durable && !current2.client || !current2.capability?.available || !current2.enabled || current2.disabled || statusRef.current === "requesting-permission" || statusRef.current === "recording" || statusRef.current === "saving" || statusRef.current === "transcribing" || dictationRef.current);
+    };
+    if (gatingRef.current || !startable()) return false;
+    const gate = latest.current.beforeStart;
+    if (gate) {
+      gatingRef.current = true;
+      let allowed = false;
+      try {
+        allowed = await gate();
+      } catch {
+        allowed = false;
+      } finally {
+        gatingRef.current = false;
+      }
+      if (!allowed || !startable()) return false;
+    }
+    const current = latest.current;
+    if (!current.capability) return false;
+    const generation = ++generationRef.current;
+    setStatus("requesting-permission");
+    setError(null);
+    const language = current.language || null;
+    if (!current.durable) {
+      oneShotLanguage.current = language;
+      const capture = await startOneShot(current.capability.acceptedMimeTypes);
+      if (generation !== generationRef.current) {
+        if (!(capture instanceof Error)) await capture.stop();
+        return false;
+      }
+      if (capture instanceof Error) {
+        setStatus("error");
+        setError(errorCode(capture));
+        return false;
+      }
+      oneShotRef.current = capture;
+      beginCapture(capture.stream, null);
+      return true;
+    }
+    const transcription = dictationTranscription(language, current.keyterms, current.model);
+    audioCopies.current.clear();
+    const copying = Boolean(current.onAudio);
+    const recorder = current.platform.createRecorder({
+      client: transport,
+      workspaceId: current.workspaceId,
+      purpose: "dictation",
+      microphone: true,
+      ...transcription ? { transcription } : {},
+      uploader: uploader(),
+      timesliceMilliseconds: VOICE_RECORDING_TIMESLICE_MILLISECONDS,
+      keepAwake: false,
+      onChange: (snapshot2) => {
+        if (recorderRef.current !== recorder) return;
+        if (copying && snapshot2.recordingId && !audioCopies.current.has(snapshot2.recordingId)) {
+          audioCopies.current.set(snapshot2.recordingId, { mimeType: null, parts: [] });
+        }
+        setDurationSeconds(snapshot2.elapsedMilliseconds / 1e3);
+        if (snapshot2.state === "recording" && snapshot2.upload?.failed) {
+          const code = voiceInputCode(snapshot2.upload.failed.code);
+          recorderRef.current = null;
+          dictationRef.current = null;
+          void recorder.discard().catch(() => void 0);
+          settleIdle();
+          setStatus("error");
+          setError(code);
+        }
+      }
+    });
+    recorderRef.current = recorder;
+    await recorder.start();
+    if (generation !== generationRef.current) {
+      await recorder.discard().catch(() => void 0);
+      return false;
+    }
+    const snapshot = recorder.snapshot;
+    if (snapshot.state !== "recording" || !snapshot.recordingId) {
+      recorderRef.current = null;
+      setStatus("error");
+      setError(captureCode(snapshot.error?.code ?? null));
+      return false;
+    }
+    dictationRef.current = {
+      recordingId: snapshot.recordingId,
+      autoInsert: true,
+      fresh: true,
+      text: null
+    };
+    beginCapture(recorder.inputStream?.(0) ?? null, snapshot.recordingId);
+    return true;
+  }, [beginCapture, settleIdle, transport, uploader]);
+  const discard = useCallback2(async () => {
+    const generation = ++generationRef.current;
+    const recorder = recorderRef.current;
+    const oneShot = oneShotRef.current;
+    const dictation = dictationRef.current;
+    settleIdle();
+    oneShotText.current = null;
+    audioCopies.current.clear();
+    if (oneShot) await oneShot.stop().catch(() => void 0);
+    if (recorder) {
+      await recorder.discard().catch(() => void 0);
+    } else if (dictation) {
+      await uploader().discard(dictation.recordingId).catch(() => void 0);
+      await latest.current.recordings?.deleteRecording(latest.current.workspaceId, dictation.recordingId).catch(() => void 0);
+    }
+    focusInput();
+    if (generation === generationRef.current) void loadSaved(generation);
+  }, [focusInput, loadSaved, settleIdle, uploader]);
+  const cancel = useCallback2(() => {
+    const current = statusRef.current;
+    if (current === "requesting-permission") {
+      generationRef.current += 1;
+      settleIdle();
+      return;
+    }
+    const dictation = dictationRef.current;
+    const keep = (copy) => {
+      if (copy && copy.durationMilliseconds >= ACCIDENTAL_START_MAX_MILLISECONDS) {
+        giveAudio({ ...copy, cancelled: true });
+      }
+    };
+    if (current === "recording") {
+      const recorder = recorderRef.current;
+      const id = recorder?.snapshot.recordingId ?? null;
+      if (recorder && id && latest.current.onAudio) {
+        const audio = takeCopy(audioCopies.current, id);
+        const spoken = Math.max(
+          recorder.snapshot.elapsedMilliseconds,
+          now().getTime() - startedAtRef.current
+        );
+        if (audio) keep({ recordingId: id, audio, durationMilliseconds: spoken });
+      }
+      void discard();
+      return;
+    }
+    if (current !== "saving" && current !== "transcribing" && current !== "retrying") return;
+    if (dictation && !dictation.fresh) {
+      dictation.autoInsert = false;
+      setHeld(true);
+      setStatus("recovered");
+      return;
+    }
+    if (handed.current) {
+      keep(handed.current);
+    } else if (dictation && latest.current.onAudio) {
+      const audio = takeCopy(audioCopies.current, dictation.recordingId);
+      const recorder = recorderRef.current;
+      if (audio) {
+        keep({
+          recordingId: dictation.recordingId,
+          audio,
+          durationMilliseconds: recorder?.snapshot.elapsedMilliseconds ?? 0
+        });
+      }
+    }
+    void discard();
+  }, [discard, giveAudio, now, settleIdle]);
+  const setAside = useCallback2(() => {
+    const current = statusRef.current;
+    if (current === "requesting-permission") {
+      generationRef.current += 1;
+      settleIdle();
+      return;
+    }
+    if (current === "recording") {
+      const elapsed = now().getTime() - startedAtRef.current;
+      if (elapsed < ACCIDENTAL_START_MAX_MILLISECONDS) {
+        void discard();
+        return;
+      }
+      void finishCapture(false);
+      return;
+    }
+    if (current === "saving" || current === "transcribing" || current === "retrying") {
+      const dictation = dictationRef.current;
+      if (!dictation) return;
+      dictation.autoInsert = false;
+      setHeld(true);
+      setStatus("recovered");
+    }
+  }, [discard, finishCapture, now, settleIdle]);
+  const retry = useCallback2(() => {
+    const dictation = dictationRef.current;
+    const client = latest.current.recordings;
+    if (!dictation || dictation.text !== null || !client || latest.current.disabled) return;
+    const generation = ++generationRef.current;
+    const failed = statusRef.current === "error" || errorRef.current !== null;
+    dictation.autoInsert = true;
+    setHeld(false);
+    setError(null);
+    setStatus("transcribing");
+    void (async () => {
+      let versionId = null;
+      if (failed) {
+        try {
+          versionId = (await client.createRecordingTranscript(
+            latest.current.workspaceId,
+            dictation.recordingId
+          )).id;
+        } catch (cause) {
+          if (generation !== generationRef.current) return;
+          if (httpStatus(cause) === 404) {
+            settleIdle();
+            return;
+          }
+          hold(dictation, "error", errorCode(cause));
+          return;
+        }
+      }
+      await watch(dictation, versionId, generation);
+    })();
+  }, [hold, settleIdle, watch]);
+  const insertSavedTranscript = useCallback2(async () => {
+    if (latest.current.disabled) return;
+    const generation = ++generationRef.current;
+    const dictation = dictationRef.current;
+    if (oneShotText.current !== null) {
+      insertText(oneShotText.current);
+      oneShotText.current = null;
+      settleIdle();
+      return;
+    }
+    if (!dictation || dictation.text === null) return;
+    await take(dictation, dictation.text, generation);
+  }, [insertText, settleIdle, take]);
+  const release = useCallback2(() => {
+    generationRef.current += 1;
+    void recorderRef.current?.stop().catch(() => void 0);
+    void oneShotRef.current?.stop().catch(() => void 0);
+    oneShotText.current = null;
+    audioCopies.current.clear();
+    settleIdle();
+  }, [settleIdle]);
+  const transcribe = useCallback2(
+    async (audio, timing = {}) => {
+      const current = latest.current;
+      const client = current.recordings;
+      if (!client || !current.durable || current.disabled || !current.enabled || !current.capability?.available || statusRef.current !== "idle" || audio.size === 0) {
+        return false;
+      }
+      const generation = ++generationRef.current;
+      const newId = crypto.randomUUID();
+      const transcription = dictationTranscription(
+        current.language || null,
+        current.keyterms,
+        current.model
+      );
+      const dictation = {
+        recordingId: newId,
+        autoInsert: true,
+        fresh: true,
+        text: null
+      };
+      dictationRef.current = dictation;
+      setRecordingId(newId);
+      setError(null);
+      setStatus("saving");
+      let upload;
+      try {
+        upload = await uploadRecordingAudio({
+          uploader: uploader(),
+          workspaceId: current.workspaceId,
+          recordingId: newId,
+          audio,
+          durationMilliseconds: timing.durationMilliseconds ?? 0,
+          create: { purpose: "dictation", ...transcription ? { transcription } : {} }
+        });
+      } catch (cause) {
+        if (generation !== generationRef.current) return false;
+        settleIdle();
+        setStatus("error");
+        setError(errorCode(cause));
+        return false;
+      }
+      if (generation !== generationRef.current) return true;
+      if (upload.discarded || upload.failed) {
+        await uploader().discard(newId).catch(() => void 0);
+        settleIdle();
+        setStatus("error");
+        setError(upload.failed ? voiceInputCode(upload.failed.code) : "invalid_audio");
+        return false;
+      }
+      if (dictation.autoInsert) setStatus("transcribing");
+      else hold(dictation, "recovered");
+      void watch(dictation, uploader().finalized.get(newId)?.transcript.id ?? null, generation);
+      return true;
+    },
+    [hold, settleIdle, uploader, watch]
+  );
+  useEffect2(() => {
+    const dictation = dictationRef.current;
+    if (disabled || status !== "transcript-ready" || !dictation?.autoInsert || !dictation.text)
+      return;
+    void take(dictation, dictation.text, ++generationRef.current);
+  }, [disabled, status, take]);
+  useEffect2(() => {
+    const generation = ++generationRef.current;
+    const recorder = recorderRef.current;
+    if (recorder) {
+      void recorder.stop().catch(() => void 0);
+    }
+    void oneShotRef.current?.stop().catch(() => void 0);
+    settleIdle();
+    oneShotText.current = null;
+    if (durable) void loadSaved(generation);
+  }, [workspaceId, durable, loadSaved, settleIdle]);
+  const level = useCallback2(() => {
+    const levels = recorderRef.current?.levels();
+    const first = levels?.[0];
+    return typeof first === "number" ? first : null;
+  }, []);
+  useEffect2(
+    () => () => {
+      generationRef.current += 1;
+      clearStopTimer();
+      void recorderRef.current?.stop().catch(() => void 0);
+      recorderRef.current = null;
+      void oneShotRef.current?.stop().catch(() => void 0);
+      oneShotRef.current = null;
+      uploaderRef.current = null;
+    },
+    []
+  );
+  return {
+    status,
+    error,
+    available: Boolean(
+      capability?.available && enabled && !disabled && (durable || canRecordInMemory())
+    ),
+    stream,
+    recordingId,
+    durationSeconds,
+    recordingStartedAt: status === "recording" ? recordingStartedAt : null,
+    maxRecordingSeconds,
+    locallySaved: durable && recordingId !== null,
+    hasRecoverableRecording: held && status !== "recording",
+    savedTranscript,
+    level,
+    start,
+    stop,
+    retry,
+    insertSavedTranscript,
+    cancel,
+    setAside,
+    discard,
+    release,
+    transcribe
+  };
+}
+function takeCopy(copies, recordingId) {
+  const copy = copies.get(recordingId);
+  copies.delete(recordingId);
+  const parts = copy?.parts.filter((part) => part !== void 0) ?? [];
+  if (!copy || parts.length === 0) return null;
+  return new Blob(parts, copy.mimeType ? { type: copy.mimeType } : {});
+}
+function dictationTranscription(language, keyterms, model) {
+  const terms = (keyterms ?? []).map((term) => term.trim()).filter(Boolean);
+  if (!model && !language && terms.length === 0) return null;
+  return {
+    ...model ? { providerId: model.providerId, model: model.model } : {},
+    ...language ? { language } : {},
+    ...terms.length > 0 ? { keyterms: terms.slice(0, 100) } : {}
+  };
+}
+function copyingStore(store, copies) {
+  return {
+    putRecording: async (recording) => {
+      const copy = copies.get(recording.recordingId);
+      if (copy && !copy.mimeType) {
+        copy.mimeType = recording.create.tracks.find((track) => track.trackNumber === 0)?.mimeType ?? null;
+      }
+      await store.putRecording(recording);
+    },
+    getRecording: (recordingId) => store.getRecording(recordingId),
+    listRecordings: () => store.listRecordings(),
+    deleteRecording: (recordingId) => store.deleteRecording(recordingId),
+    putChunk: async (chunk) => {
+      await store.putChunk(chunk);
+      const copy = copies.get(chunk.recordingId);
+      if (copy && chunk.trackNumber === 0) copy.parts[chunk.chunkNumber] = chunk.bytes;
+    },
+    listChunks: (recordingId) => store.listChunks(recordingId),
+    readChunk: (recordingId, trackNumber, chunkNumber) => store.readChunk(recordingId, trackNumber, chunkNumber),
+    deleteChunks: (recordingId, trackNumber, chunkNumbers) => store.deleteChunks(recordingId, trackNumber, chunkNumbers)
+  };
+}
+async function transcriptText(client, workspaceId, recordingId, versionId) {
+  const parts = [];
+  let after;
+  try {
+    for (; ; ) {
+      const page = await client.getRecordingTranscript(workspaceId, recordingId, {
+        versionId,
+        ...after !== void 0 ? { after } : {},
+        limit: 500
+      });
+      for (const segment of page.segments) parts.push(segment.text.trim());
+      if (page.nextAfter === null) break;
+      after = page.nextAfter;
+    }
+  } catch {
+    return null;
+  }
+  return parts.filter(Boolean).join(" ");
+}
+function canRecordInMemory() {
+  return typeof MediaRecorder !== "undefined" && typeof navigator !== "undefined" && typeof navigator.mediaDevices?.getUserMedia === "function";
+}
+async function startOneShot(accepted) {
+  let stream;
+  try {
+    stream = await navigator.mediaDevices.getUserMedia({ audio: true });
+  } catch (cause) {
+    return cause instanceof Error ? cause : new Error(String(cause));
+  }
+  try {
+    const preferred = chooseMimeType(accepted);
+    const recorder = new MediaRecorder(stream, preferred ? { mimeType: preferred } : void 0);
+    const parts = [];
+    recorder.ondataavailable = (event) => {
+      if (event.data.size > 0) parts.push(event.data);
+    };
+    const startedAt = performance.now();
+    recorder.start(VOICE_RECORDING_TIMESLICE_MILLISECONDS);
+    let stopped = null;
+    return {
+      stream,
+      mimeType: recorder.mimeType || preferred || "audio/webm",
+      durationSeconds: () => (performance.now() - startedAt) / 1e3,
+      stop: () => stopped ??= new Promise((resolve) => {
+        const done = () => {
+          for (const track of stream.getTracks()) track.stop();
+          resolve(
+            parts.length > 0 ? new Blob(parts, { type: recorder.mimeType || preferred || "audio/webm" }) : null
+          );
+        };
+        if (recorder.state === "inactive") return done();
+        recorder.addEventListener("stop", done, { once: true });
+        recorder.stop();
+      })
+    };
+  } catch (cause) {
+    for (const track of stream.getTracks()) track.stop();
+    return cause instanceof Error ? cause : new Error(String(cause));
+  }
+}
+function chooseMimeType(accepted) {
+  const normalized = accepted.map((value) => value.trim().toLowerCase());
+  return MIME_PREFERENCES.find((mimeType) => {
+    const bare = mimeType.split(";")[0] ?? mimeType;
+    const allowed = normalized.includes(mimeType) || normalized.includes(bare) || normalized.some((candidate) => candidate.split(";")[0] === bare);
+    return allowed && (typeof MediaRecorder.isTypeSupported !== "function" || MediaRecorder.isTypeSupported(mimeType));
+  });
+}
+function voiceInputCode(code) {
+  if (!code) return "unknown";
+  if (code.startsWith("voice_")) return voiceInputCode(code.slice("voice_".length));
+  if (code.startsWith("provider_")) return "provider";
+  switch (code) {
+    case "insufficient_credits":
+    case "allowance_exhausted":
+    case "monthly_model_cost_limit":
+    case "policy_blocked":
+    case "region_restricted":
+    case "not_supported":
+    case "unavailable":
+    case "too_large":
+    case "invalid_audio":
+    case "network":
+    case "provider":
+    case "timeout":
+      return code;
+    case "upstream_unavailable":
+    case "storage_unavailable":
+      return "unavailable";
+    default:
+      return "unknown";
+  }
+}
+function captureCode(code) {
+  switch (code) {
+    case "microphone_denied":
+      return "permission_denied";
+    case "unsupported":
+    case "microphone_unavailable":
+      return "not_supported";
+    case "upload_failed":
+      return "unavailable";
+    default:
+      return "unknown";
+  }
+}
+function errorCode(error) {
+  const details = error.details;
+  if (typeof details?.transcriptionCode === "string") return details.transcriptionCode;
+  if (typeof details?.code === "string") return voiceInputCode(details.code);
+  if (error && typeof error === "object" && "code" in error && typeof error.code === "string") {
+    return voiceInputCode(error.code);
+  }
+  if (error instanceof DOMException && error.name === "NotAllowedError") return "permission_denied";
+  if (error instanceof DOMException && error.name === "NotSupportedError") return "not_supported";
+  if (error instanceof TypeError) return "network";
+  return "unknown";
+}
+function httpStatus(error) {
+  const status = error?.status;
+  return typeof status === "number" ? status : null;
+}
+function sleep(milliseconds) {
+  return new Promise((resolve) => setTimeout(resolve, milliseconds));
+}
+function readTaken() {
+  try {
+    const raw = globalThis.localStorage?.getItem(TAKEN_STORAGE_KEY);
+    const parsed = raw ? JSON.parse(raw) : [];
+    return new Set(Array.isArray(parsed) ? parsed.filter((id) => typeof id === "string") : []);
+  } catch {
+    return /* @__PURE__ */ new Set();
+  }
+}
+function writeTaken(ids) {
+  try {
+    globalThis.localStorage?.setItem(TAKEN_STORAGE_KEY, JSON.stringify([...ids].slice(-50)));
+  } catch {
+  }
+}
+function rememberTaken(recordingId) {
+  const ids = readTaken();
+  ids.add(recordingId);
+  writeTaken(ids);
+}
+function forgetTaken(recordingId) {
+  const ids = readTaken();
+  if (ids.delete(recordingId)) writeTaken(ids);
+}
+
+export {
+  INITIAL_TRANSCRIPTION_CONTROL_STATE,
+  transitionTranscriptionControl,
+  appendFinalTranscript,
+  useTranscription,
+  VOICE_RECORDING_TIMESLICE_MILLISECONDS,
+  VOICE_RECORDING_OWNER_HEARTBEAT_MILLISECONDS,
+  VOICE_RECORDING_OWNER_STALE_MILLISECONDS,
+  VOICE_RECORDING_CLIENT_MAX_DURATION_SECONDS,
+  useVoiceInput
+};
+//# sourceMappingURL=chunk-SODC7T6L.js.map