@opengeni/react 6.5.2-canary.41607687019001 → 6.7.0

package/dist/chunk-YDCUBUWH.js

@@ -1,1583 +0,0 @@
-"use client";
-import {
-  useOpenGeniText
-} from "./chunk-TNUSPXPW.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-YDCUBUWH.js.map