tempest-react-sdk 0.34.0 → 0.36.0

package/dist/tempest-react-sdk.d.ts

@@ -56,6 +56,7 @@ import { ReactEventHandler } from 'react';
 import { ReactNode } from 'react';
 import { ReactPortal } from 'react';
 import { redirect } from 'react-router';
+import { Ref } from 'react';
 import { RefAttributes } from 'react';
 import { RefObject } from 'react';
 import { Route } from 'react-router';
@@ -187,7 +188,7 @@ export declare interface AccordionProps {
  *     suggestions={["Resuma o último relatório", "Quais pedidos atrasaram?"]}
  * />
  */
-export declare function AIChat({ messages, onSend, onStop, onRegenerate, onEditSubmit, onFeedback, onRetry, pending, suggestions, renderAvatar, renderContent, votes, header, emptyState, showSystem, defaultReasoningOpen, showLineNumbers, locale, placeholder, composerActions, composerFooter, composerDisabled, maxRows, onSendError, className, ...rest }: AIChatProps): JSX.Element;
+export declare function AIChat({ messages, onSend, onStop, onRegenerate, onEditSubmit, onFeedback, onRetry, pending, suggestions, renderAvatar, renderContent, votes, header, emptyState, showSystem, defaultReasoningOpen, showLineNumbers, locale, placeholder, composerActions, composerRef, composerFooter, composerDisabled, maxRows, onSendError, className, ...rest }: AIChatProps): JSX.Element;
 
 /** A file carried by a turn — an upload on the way in, a document on the way out. */
 export declare interface AIChatAttachment {
@@ -224,14 +225,23 @@ export declare interface AIChatAttachment {
  */
 export declare const AIChatComposer: ForwardRefExoticComponent<AIChatComposerProps & RefAttributes<AIChatComposerHandle>>;
 
-/** Imperative handle, so a thread can focus or refill the field. */
+/** Imperative handle, so a thread can focus, read or refill the field. */
 export declare interface AIChatComposerHandle {
     focus: () => void;
     /** Replace the draft — used to put a prompt back in the field. */
     setValue: (text: string) => void;
+    /**
+     * The current draft.
+     *
+     * The counterpart `setValue` needs to be usable for anything **additive**. The
+     * field is uncontrolled, so without this the only way to append to a draft — a
+     * dictated phrase, a picked slash-command, a pasted citation — is to shadow the
+     * whole value in app state through `onChange` and hope the two never drift.
+     */
+    getValue: () => string;
 }
 
-export declare interface AIChatComposerProps extends Omit<TextareaHTMLAttributes<HTMLTextAreaElement>, OverriddenDomProps_5> {
+export declare interface AIChatComposerProps extends Omit<TextareaHTMLAttributes<HTMLTextAreaElement>, OverriddenDomProps_8> {
     /** Called with the trimmed prompt. The field clears only when this does not throw. */
     onSend: (text: string) => void | Promise<void>;
     /**
@@ -302,7 +312,7 @@ export declare interface AIChatMessage {
     data?: Record<string, unknown>;
 }
 
-export declare interface AIChatProps extends Omit<HTMLAttributes<HTMLDivElement>, OverriddenDomProps_4> {
+export declare interface AIChatProps extends Omit<HTMLAttributes<HTMLDivElement>, OverriddenDomProps_7> {
     /** The transcript, **oldest first**. Never reordered by the component. */
     messages: readonly AIChatMessage[];
     /** Renders the composer when given. Receives the trimmed prompt. */
@@ -349,6 +359,16 @@ export declare interface AIChatProps extends Omit<HTMLAttributes<HTMLDivElement>
     placeholder?: string;
     /** Extra controls inside the composer, before the send button. */
     composerActions?: ReactNode;
+    /**
+     * Reach the composer imperatively — `focus()`, `getValue()`, `setValue()`.
+     *
+     * What makes dictation (or a slash-command menu, or "edit and resend") possible
+     * without this component knowing anything about them: pair it with
+     * `composerActions` and the button you put in the composer can write into the
+     * field. Speech recognition is **not** wired in here on purpose — it would make
+     * every consumer of `AIChat` pay for an API that streams audio to a third party.
+     */
+    composerRef?: Ref<AIChatComposerHandle>;
     /** Under the composer field — token count, model name, a disclaimer. */
     composerFooter?: ReactNode;
     /** Disable the composer — no credits, conversation archived, offline. */
@@ -483,6 +503,41 @@ export declare interface AlertProps extends Omit<HTMLAttributes<HTMLDivElement>,
 
 export declare type AlertVariant = "neutral" | "info" | "success" | "warning" | "danger";
 
+/** Every symbology in the spec, used to validate what a detector reports back. */
+export declare const ALL_BARCODE_FORMATS: readonly BarcodeFormat[];
+
+/**
+ * Announce a message to screen readers, from anywhere — a hook, an event handler,
+ * a plain function outside React.
+ *
+ * ## Why the same string announces twice
+ *
+ * Screen readers announce a live region when its **content changes**. Writing the
+ * same text again is not a change, so "Item removido" twice in a row is read once —
+ * the classic reason these announcers are quietly broken. Instead of mutating text,
+ * every call replaces the region's child with a **new element**. The DOM mutation is
+ * real even when the string is identical, so the second announcement happens, and
+ * the reader hears the exact message with no padding characters bolted on.
+ *
+ * @param message - Text to read out. Empty strings are ignored.
+ * @param politeness - `"polite"` (default) or `"assertive"`.
+ *
+ * @example
+ * announce(`${count} pedidos encontrados`);
+ * announce("Falha ao salvar", "assertive");
+ */
+export declare function announce(message: string, politeness?: AnnouncePoliteness): void;
+
+/**
+ * How urgently a screen reader should interrupt.
+ *
+ * `"polite"` waits for a pause in what is being read. `"assertive"` cuts in
+ * immediately, which is right for an error the user must act on and wrong for
+ * everything else — an assertive announcement can truncate the sentence the user
+ * was in the middle of.
+ */
+export declare type AnnouncePoliteness = "polite" | "assertive";
+
 declare type AnyEventTarget = EventTarget | {
     current: EventTarget | null;
 } | null | undefined;
@@ -823,7 +878,50 @@ export declare function assertNever(value: never, message?: string): never;
 
 export declare type AsyncStatus = "idle" | "pending" | "success" | "error";
 
-export declare interface AudioPlayer {
+/**
+ * Container/codec candidates, best first.
+ *
+ * No browser supports all of these, and none supports MP3 or WAV from
+ * `MediaRecorder` — see the note on {@link pickAudioMimeType}. Opus in WebM is the
+ * first choice because it is the smallest at speech bitrates and is what Chromium
+ * and Firefox produce natively; `audio/mp4` is here for Safari, which produces AAC
+ * and nothing else.
+ *
+ * Ported from the intersection of what `MediaRecorder.isTypeSupported` accepts in
+ * Chrome 120+, Firefox 115+ and Safari 17. Re-check against
+ * <https://developer.mozilla.org/docs/Web/API/MediaRecorder/isTypeSupported> before
+ * adding to the list.
+ */
+export declare const AUDIO_MIME_CANDIDATES: readonly string[];
+
+/**
+ * Playback transport for one clip: play/pause, a seek bar, elapsed and total time.
+ *
+ * Built around a real `<audio>` element rather than the SDK's `createAudioPlayer`,
+ * which is a fire-and-forget handle for notification chimes and has no transport to
+ * expose. Accepts a `Blob` directly, because the thing an app most often plays is the
+ * recording it just made.
+ *
+ * The seek bar is a bare `<input type="range">` rather than the SDK's `Slider`: that
+ * component is a form field, with a label row and a value badge, and a transport wants
+ * neither. The native input keeps the keyboard and screen-reader behaviour that
+ * matters here for free.
+ *
+ * @example
+ * const rec = useAudioRecorder(mic.stream);
+ * {rec.recording && (
+ *     <AudioPlayer src={rec.recording.blob} durationMs={rec.recording.durationMs} />
+ * )}
+ */
+export declare function AudioPlayer({ src, durationMs, sinkId, autoPlay, loop, locale, actions, onEnded, onError, disabled, className, ...rest }: AudioPlayerProps): JSX.Element;
+
+/**
+ * Imperative handle over one "current" clip.
+ *
+ * Named `*Handle` like the SDK's other imperative handles (`ChatComposerHandle`,
+ * `SignaturePadHandle`) — it is a control surface, not the `<AudioPlayer>` component.
+ */
+export declare interface AudioPlayerHandle {
     /** Play `src`. Returns the underlying element, or `null` when the browser blocked autoplay. */
     play: (src: string, options?: PlayAudioOptions) => Promise<HTMLAudioElement | null>;
     /** Stop the currently-playing clip and rewind it. */
@@ -832,6 +930,157 @@ export declare interface AudioPlayer {
     current: () => HTMLAudioElement | null;
 }
 
+export declare interface AudioPlayerProps extends Omit<HTMLAttributes<HTMLDivElement>, OverriddenDomProps_4> {
+    /**
+     * What to play — a URL, or a `Blob`/`File` straight from a recorder.
+     *
+     * A `Blob` is wrapped in an object URL that is revoked when it changes or the
+     * component unmounts, so a page that records twenty notes does not leak twenty
+     * URLs for the lifetime of the tab.
+     */
+    src: string | Blob | null;
+    /**
+     * Known length in milliseconds.
+     *
+     * Pass it whenever you have it — a recording from `useAudioRecorder` always does.
+     * See the note on the seek bar for why the element's own `duration` is not
+     * trustworthy for a fresh recording.
+     */
+    durationMs?: number;
+    /** Output device, from `useMediaDevices().audioOutputs`. Chromium only. */
+    sinkId?: string;
+    /** Start playing as soon as `src` is ready. Default `false`. */
+    autoPlay?: boolean;
+    /** Loop. Default `false`. */
+    loop?: boolean;
+    /** Locale for the labels. Default `"pt-BR"`. */
+    locale?: "pt-BR" | "en";
+    /** Rendered to the right of the times — a download button, a delete button. */
+    actions?: React.ReactNode;
+    /** Fired when playback reaches the end. */
+    onEnded?: () => void;
+    /** Fired when the element reports a decode/network error. */
+    onError?: (error: unknown) => void;
+    /** No `src` yet, or playback not allowed. */
+    disabled?: boolean;
+}
+
+/**
+ * Record a voice note: one button to start, a live level meter, a clock, and a
+ * playback review before the audio leaves the component.
+ *
+ * The permission flow is the part worth reading. The microphone is **not** opened on
+ * mount — the prompt fires on the first press of Record, because a prompt the user did
+ * not provoke is the most reliable way to earn a permanent block, after which
+ * `getUserMedia` rejects without ever asking again. When the permission is already
+ * `"denied"`, the component says so and how to fix it instead of offering a button
+ * that cannot work.
+ *
+ * The level meter is not decoration either: a muted OS input or a headset with its mic
+ * arm folded up produces a perfectly successful recording of silence, and without a
+ * visible level the user only finds out after they finish talking.
+ *
+ * @example
+ * <AudioRecorder
+ *     maxDurationMs={120_000}
+ *     format="wav"
+ *     wavOptions={{ mono: true, sampleRate: 16000 }}
+ *     onRecorded={({ blob }) => upload(blob)}
+ * />
+ */
+export declare function AudioRecorder({ onRecorded, maxDurationMs, deviceId, format, wavOptions, audioBitsPerSecond, review, locale, footer, onError, disabled, className, ...rest }: AudioRecorderProps): JSX.Element;
+
+/** Imperative recorder. */
+export declare interface AudioRecorderHandle {
+    /** Begin recording. No-op when already recording or paused. */
+    start: () => void;
+    /** Pause. The clock stops; `durationMs` freezes. */
+    pause: () => void;
+    /** Resume after `pause()`. */
+    resume: () => void;
+    /** Stop and resolve with the assembled recording. */
+    stop: () => Promise<AudioRecording>;
+    /** Stop and throw the audio away. */
+    cancel: () => void;
+    status: () => AudioRecorderStatus;
+    /** Recorded length so far, excluding paused time. */
+    durationMs: () => number;
+    /** The negotiated container. */
+    mimeType: string;
+}
+
+/** Options for {@link createAudioRecorder}. */
+export declare interface AudioRecorderOptions {
+    /**
+     * Force a container. Throws when the browser cannot produce it.
+     *
+     * Leave it out. The default negotiates from {@link AUDIO_MIME_CANDIDATES}, which
+     * is the only way one call site works on both Chromium and Safari.
+     */
+    mimeType?: string;
+    /** Target bitrate. 32000–64000 is plenty for speech in Opus. */
+    audioBitsPerSecond?: number;
+    /**
+     * Emit a chunk every N ms through `onChunk`, for streaming upload.
+     *
+     * Without it the whole recording is buffered in memory until `stop()` — fine for
+     * a voice note, not fine for an hour-long meeting.
+     */
+    timesliceMs?: number;
+    /** Receives each chunk when `timesliceMs` is set. Chunks are **not** independently playable. */
+    onChunk?: (chunk: Blob) => void;
+    /** Recorder-level failure (device unplugged mid-recording, encoder error). */
+    onError?: (error: unknown) => void;
+}
+
+export declare interface AudioRecorderProps extends Omit<HTMLAttributes<HTMLDivElement>, OverriddenDomProps_5> {
+    /**
+     * Called once a recording is finished and (when asked) converted.
+     *
+     * Fires on stop and on hitting `maxDurationMs`, never on cancel.
+     */
+    onRecorded?: (recording: AudioRecording) => void;
+    /** Stop automatically after this long. Strongly recommended on anything public. */
+    maxDurationMs?: number;
+    /** Specific microphone, from `useMediaDevices().audioInputs`. */
+    deviceId?: string;
+    /**
+     * Output container.
+     *
+     * `"native"` (default) keeps what the browser produced — Opus on Chromium and
+     * Firefox, AAC on Safari — which is the smallest and needs no work. `"wav"`
+     * converts on stop, for a backend that only accepts WAV; see `wavOptions`, and
+     * expect roughly ten times the bytes.
+     */
+    format?: "native" | "wav";
+    /** Passed to `blobToWav` when `format="wav"`. `{ mono: true, sampleRate: 16000 }` suits speech. */
+    wavOptions?: WavOptions;
+    /** Target bitrate. 32000–64000 is plenty for speech in Opus. */
+    audioBitsPerSecond?: number;
+    /** Offer playback of the recording before handing it over. Default `true`. */
+    review?: boolean;
+    /** Locale for the labels. Default `"pt-BR"`. */
+    locale?: "pt-BR" | "en";
+    /** Rendered under the controls — a hint, a character count, a legal notice. */
+    footer?: ReactNode;
+    /** Recorder-level failure, or a failed WAV conversion. */
+    onError?: (error: unknown) => void;
+    disabled?: boolean;
+}
+
+/** Lifecycle of a recording. Shared with the video recorder — the states are the same. */
+export declare type AudioRecorderStatus = MediaRecorderStatus;
+
+/** A finished recording. */
+export declare interface AudioRecording {
+    /** The audio. Wrap with `useObjectUrl` to play it, or POST it as-is. */
+    blob: Blob;
+    /** What the browser actually produced — not necessarily what you asked for. */
+    mimeType: string;
+    /** Recorded length, excluding time spent paused. */
+    durationMs: number;
+}
+
 /**
  * Router-agnostic auth gate. The caller decides what to render in either
  * branch — typically `<Outlet />` for protected layouts and `<Navigate />` for
@@ -996,6 +1245,129 @@ export declare interface BannerProps extends Omit<HTMLAttributes<HTMLDivElement>
 
 export declare type BannerVariant = "info" | "success" | "warning" | "danger";
 
+/**
+ * The slice of `BarcodeDetector` this SDK uses.
+ *
+ * Exported so a consumer can **inject a polyfill** where the native API is missing —
+ * see {@link isBarcodeDetectionSupported} for why that matters — and so tests can hand
+ * in a decoder without a camera. Anything with a `detect()` that resolves to objects
+ * carrying a `rawValue` will do.
+ */
+export declare interface BarcodeDetectorLike {
+    /**
+     * Decode every symbol visible in the source.
+     *
+     * @param source - A `<video>`, a `<canvas>`, an `ImageBitmap`, a `Blob`…
+     * @returns Every symbol found, or an empty array — finding nothing is not an error.
+     */
+    detect: (source: ImageBitmapSource) => Promise<readonly DetectedBarcodeLike[]>;
+}
+
+/**
+ * Symbologies the `BarcodeDetector` API names.
+ *
+ * Three of them carry the weight in Brazil: `ean_13` is the retail barcode on every
+ * packaged product, `qr_code` is what a Pix "copia e cola" payload travels in, and
+ * `code_128` is the label on a shipment. The rest are here because the spec has them
+ * and asking for one costs nothing.
+ */
+export declare type BarcodeFormat = "aztec" | "codabar" | "code_128" | "code_39" | "code_93" | "data_matrix" | "ean_13" | "ean_8" | "itf" | "pdf417" | "qr_code" | "upc_a" | "upc_e" | "unknown";
+
+/** A corner of a detected symbol, in the source's pixel coordinates. */
+export declare interface BarcodePoint {
+    x: number;
+    y: number;
+}
+
+/**
+ * Point the camera at a barcode and get its value.
+ *
+ * The counterpart to {@link QRCode}, which only encodes. Under it are
+ * `useBarcodeScanner` (the detect loop and repeat suppression), `useCameraStream` (the
+ * stream and its classified errors) and `useTorch`.
+ *
+ * **Mounting this opens the camera**, so mount it when the user asks to scan rather
+ * than on a page that happens to contain a scanner: a permission prompt nobody
+ * provoked is the surest way to earn a permanent block, and after that `getUserMedia`
+ * rejects without ever prompting again. The usual shape is a button that reveals it.
+ *
+ * The `unsupported` slot is not a nicety. `BarcodeDetector` is Chromium-only — absent
+ * on Firefox, on every browser on iOS, and on Chromium for Windows and Linux — so on a
+ * large share of real devices the fallback *is* the feature. Give it a text field, or
+ * inject a polyfill through `detector`.
+ *
+ * The preview itself is `aria-hidden`: a live camera frame has nothing to announce and
+ * no audio to caption, so what a screen reader gets is the `role="status"` line, which
+ * says whether scanning is running and reads out each accepted code.
+ *
+ * @example
+ * <BarcodeScanner
+ *     formats={["ean_13"]}
+ *     onScan={({ rawValue }) => addToCart(rawValue)}
+ *     footer={<small>Aponte para o código de barras da embalagem.</small>}
+ *     unsupported={<ManualCodeInput onSubmit={addToCart} />}
+ * />
+ */
+export declare function BarcodeScanner({ onScan, formats, paused, detector, intervalMs, repeatDelayMs, torch, aspectRatio, locale, footer, unsupported, onError, className, ...rest }: BarcodeScannerProps): JSX.Element;
+
+export declare interface BarcodeScannerProps extends Omit<HTMLAttributes<HTMLDivElement>, OverriddenDomProps_6> {
+    /** Called for every accepted read — repeats of the same value are suppressed. */
+    onScan: (result: BarcodeScanResult) => void;
+    /** Symbologies to look for. Defaults to QR + EAN-13 + Code 128. */
+    formats?: readonly BarcodeFormat[];
+    /** Stop looking without releasing the camera — set it while a confirmation is open. */
+    paused?: boolean;
+    /** A decoder to use instead of the native one, for Safari and Firefox. */
+    detector?: BarcodeDetectorLike;
+    /** How often a frame is examined, in ms. Default 200. */
+    intervalMs?: number;
+    /** Ignore the same value again for this long, in ms. Default 2500. */
+    repeatDelayMs?: number;
+    /** Offer the torch toggle when the camera has a lamp. Default `true`. */
+    torch?: boolean;
+    /** Viewport aspect ratio, `width / height`. Default `4 / 3`. */
+    aspectRatio?: number;
+    /** Locale for the labels. Default `"pt-BR"`. */
+    locale?: "pt-BR" | "en";
+    /** Under the viewport — an instruction, the code just read, a manual-entry link. */
+    footer?: ReactNode;
+    /**
+     * Rendered instead of the camera when there is no decoder.
+     *
+     * Worth filling in: on iOS and Firefox this is the **only** thing the user sees, so
+     * the fallback is usually a plain text field for typing the code.
+     */
+    unsupported?: ReactNode;
+    /** A frame the engine refused to decode. Routine and usually transient. */
+    onError?: (error: unknown) => void;
+}
+
+/** One decoded symbol, normalised. */
+export declare interface BarcodeScanResult {
+    /** The decoded payload — a GTIN, a URL, a Pix BR Code. */
+    rawValue: string;
+    /** Which symbology it was read as. `"unknown"` when the engine does not say. */
+    format: BarcodeFormat;
+    /** Box in source pixels, or `null` when the engine reports none. */
+    boundingBox: DOMRectReadOnly | null;
+    /** Corners in source pixels, clockwise from top-left. Empty when unreported. */
+    cornerPoints: readonly BarcodePoint[];
+}
+
+/**
+ * Decode a base64url string into bytes.
+ *
+ * WebAuthn transports every binary field as base64url (`-`/`_`, no padding)
+ * because that is what survives JSON, while the DOM API insists on
+ * `ArrayBuffer`. Getting this pair wrong — usually by feeding plain base64 to
+ * `atob` and losing the last byte — is the classic broken-WebAuthn bug, which is
+ * why the SDK owns it instead of leaving it to each app.
+ *
+ * @param value - Base64url text, with or without `=` padding.
+ * @returns The decoded bytes.
+ */
+export declare function base64UrlToBytes(value: string): Uint8Array;
+
 /**
  * Initial bearing (forward azimuth) from `origin` to `destination`, in degrees
  * clockwise from true north, normalized to `[0, 360)`. Useful for orienting a
@@ -1025,6 +1397,30 @@ export declare interface BeforeInstallPromptEvent extends Event {
     prompt: () => Promise<void>;
 }
 
+/**
+ * Convert a recording to 16-bit WAV, with no dependency.
+ *
+ * `MediaRecorder` cannot produce WAV — it emits Opus on Chromium and Firefox and AAC
+ * on Safari — so a backend that insists on WAV has to be served either by a
+ * server-side transcode or by this. It decodes through `AudioContext.decodeAudioData`,
+ * which is the browser's own decoder for whatever container the recorder chose, then
+ * re-encodes the PCM.
+ *
+ * !!! The cost is real: WAV is uncompressed, so the same voice note that is 40 KB in
+ * Opus is roughly 500 KB here at 48 kHz stereo. `{ mono: true, sampleRate: 16000 }`
+ * takes that to about 80 KB and is what a speech-to-text endpoint wants anyway.
+ *
+ * Resampling uses `OfflineAudioContext`, i.e. the browser's own resampler, rather
+ * than a hand-rolled one — this is exactly the "we want the underlying call, not a
+ * wrapper" case.
+ *
+ * @param blob - A recording from {@link createAudioRecorder}, or any decodable audio.
+ * @param options - See {@link WavOptions}.
+ * @returns A `Blob` of type `audio/wav`.
+ * @throws When the environment has no Web Audio, or the blob cannot be decoded.
+ */
+export declare function blobToWav(blob: Blob, options?: WavOptions): Promise<Blob>;
+
 /**
  * Fixed-bottom mobile tab bar. 3–5 items recommended. Pair with
  * `<Show below="md">` to render only on mobile.
@@ -1207,6 +1603,14 @@ export declare type ButtonSize = "xs" | "sm" | "md" | "lg" | "xl";
 
 export declare type ButtonVariant = "primary" | "secondary" | "danger" | "success" | "ghost" | "soft" | "outline" | "link";
 
+/**
+ * Encode bytes as an unpadded base64url string.
+ *
+ * @param value - Bytes to encode, as a view or a raw buffer.
+ * @returns Base64url text, safe to put in JSON and in a URL.
+ */
+export declare function bytesToBase64Url(value: ArrayBuffer | Uint8Array): string;
+
 /** Recommended `gcTime` presets (milliseconds). */
 export declare const CACHE_TIME: {
     readonly SHORT: number;
@@ -1214,6 +1618,30 @@ export declare const CACHE_TIME: {
     readonly LONG: number;
 };
 
+/**
+ * How large the assets a page precached actually are.
+ *
+ * Reads the `Content-Length` of a stored response instead of its body:
+ * materializing a cached ONNX model or WASM binary to learn its length would
+ * pull tens of megabytes into memory on every measurement.
+ */
+/**
+ * Byte size of a response sitting in a Cache Storage bucket.
+ *
+ * @param cacheName The cache bucket to look in.
+ * @param url The request URL the response was stored under.
+ * @returns The size in bytes, or `null` when Cache Storage is unavailable,
+ *   the entry is absent, or the stored response carries no usable
+ *   `Content-Length` (a chunked transfer, typically).
+ *
+ * @example
+ * ```typescript
+ * const bytes = await cachedResponseBytes("app-models", "/models/detect.onnx");
+ * console.log(bytes === null ? "—" : formatBytes(bytes)); // "12.0 MB"
+ * ```
+ */
+export declare function cachedResponseBytes(cacheName: string, url: string): Promise<number | null>;
+
 /** A cache-name matcher: a prefix string, a `RegExp`, or a predicate. */
 export declare type CacheFilter = string | RegExp | ((name: string) => boolean);
 
@@ -1276,6 +1704,18 @@ export declare interface CalendarProps extends Omit<HTMLAttributes<HTMLDivElemen
  */
 export declare function camelCase(value: string): string;
 
+/** A classified camera error with a human-readable, English message. */
+declare interface CameraStreamError {
+    kind: CameraStreamErrorKind;
+    message: string;
+}
+
+/** Classified reason a camera stream could not be acquired. */
+declare type CameraStreamErrorKind = "unsupported" | "permission-denied" | "no-camera" | "in-use" | "insecure" | "unknown";
+
+/** Lifecycle status of the camera stream. */
+declare type CameraStreamStatus = "idle" | "loading" | "ready" | "error";
+
 /**
  * Conditionally render based on an access check. Renders `children` when the
  * action is allowed, otherwise `fallback` (or nothing). While an async check is
@@ -1663,8 +2103,52 @@ export declare function clamp(value: number, min: number, max: number): number;
 /** Clamp a latitude into the valid `[-90, 90]` range. */
 export declare function clampLatitude(latitude: number): number;
 
+/**
+ * Map an unknown `getUserMedia` failure into a {@link MediaAccessError}.
+ *
+ * The order matters. A missing `navigator.mediaDevices` is almost never "this
+ * browser cannot do audio" — it is a page served over plain HTTP, where the whole
+ * API is simply absent. Reporting `unsupported` there sends the developer looking
+ * for a polyfill for a problem an `https://` URL fixes, so the secure-context check
+ * runs first and wins.
+ *
+ * The `DOMException.name` values are then collapsed into kinds an app can actually
+ * branch on, because the raw names do not group the way a UI needs them:
+ * `NotFoundError` and `OverconstrainedError` both mean "you will not get a device
+ * with these constraints", and `NotReadableError` and `AbortError` both mean "the
+ * hardware is busy" — most often another tab of the same app.
+ *
+ * @param err - Whatever `getUserMedia` (or a device query) rejected with.
+ * @param device - Which device was being opened, for the message.
+ * @returns A stable kind plus a message safe to show a user.
+ */
+export declare function classifyMediaError(err: unknown, device?: MediaDeviceKindLabel): MediaAccessError;
+
+/**
+ * Map a thrown WebAuthn failure onto a {@link PasskeyError}.
+ *
+ * The secure-context check runs first for the same reason it does in the media
+ * classifier: over plain HTTP the whole API is absent or refuses, and reporting
+ * "not supported" sends a developer hunting for a polyfill for something an
+ * `https://` URL fixes.
+ *
+ * @param error - Whatever `navigator.credentials` rejected with.
+ * @param ceremony - Which ceremony was running, for the message.
+ * @returns The classified error, ready to throw or to show.
+ */
+export declare function classifyPasskeyError(error: unknown, ceremony: PasskeyCeremony): PasskeyError;
+
 declare type ClassValue = string | number | bigint | boolean | null | undefined | ClassValue[];
 
+/**
+ * Remove the shared regions and cancel pending cleanups.
+ *
+ * For test teardown and for a micro-frontend being unmounted from a page it does
+ * not own. Regular apps never need it — two empty hidden `div`s cost nothing, and
+ * tearing them down while another component still announces would lose messages.
+ */
+export declare function clearAnnouncer(): void;
+
 /**
  * Delete Cache Storage buckets whose name passes `filter` (all of them when no
  * filter is given).
@@ -2070,7 +2554,29 @@ export declare function createApiClient(config: ApiClientConfig): ApiClient;
  * Multiple players coexist independently; use this when several layers of UI
  * need their own playback state.
  */
-export declare function createAudioPlayer(): AudioPlayer;
+export declare function createAudioPlayer(): AudioPlayerHandle;
+
+/**
+ * Wrap a `MediaStream` in a recorder with a real state machine and an honest clock.
+ *
+ * The engine is shared with the video recorder (`createMediaRecorder`), because the
+ * subtle parts are not audio-specific: `MediaRecorder` reports **no duration** (WebM
+ * it writes carries none in its header, which is why `<audio>` shows `Infinity` for a
+ * fresh recording) so the clock is kept by hand and subtracts paused time; and
+ * `stop()` returns *before* the last `dataavailable` event, so the blob can only be
+ * assembled in `onstop`. What stays here is the part that genuinely differs — the
+ * container list.
+ *
+ * The stream is **not** owned here: `stop()` leaves the microphone open so a retake
+ * does not need a second permission round-trip. Release it with the owning
+ * `useMicrophone().stop()`.
+ *
+ * @param stream - A live audio stream, usually from {@link useMicrophone}.
+ * @param options - See {@link AudioRecorderOptions}.
+ * @returns The imperative recorder.
+ * @throws When `MediaRecorder` is unavailable, or an explicit `mimeType` is unsupported.
+ */
+export declare function createAudioRecorder(stream: MediaStream, options?: AudioRecorderOptions): AudioRecorderHandle;
 
 /**
  * Build a typed Zustand auth store with `persist` middleware. Each app passes
@@ -2105,6 +2611,14 @@ export declare interface CreateAuthStoreOptions<TUser> {
     initialToken?: string | null;
 }
 
+/**
+ * Build a native detector for the given formats.
+ *
+ * @param formats - Symbologies to look for. Must be ones the engine supports.
+ * @returns The detector, or `null` when the API is missing or refused the formats.
+ */
+export declare function createBarcodeDetector(formats?: readonly BarcodeFormat[]): BarcodeDetectorLike | null;
+
 /**
  * Build a ten-step tint scale from a single color.
  *
@@ -2237,6 +2751,46 @@ export declare interface CreateI18nOptions {
     messages: Catalog;
 }
 
+/**
+ * Timing and cost accounting for a pipeline that runs on the user's device.
+ */
+/**
+ * Create a profiler for one run of a pipeline.
+ *
+ * Wrap each step in {@link InferenceProfiler.stage}, fold in durations you
+ * already have (an SDK `speed` breakdown, say) with
+ * {@link InferenceProfiler.mark}, then call `report()` once the run finishes.
+ *
+ * Stages are timed independently rather than as a tiling of the run, so
+ * concurrent work is charged its real wall-clock span to each stage and the
+ * timings can sum to more than `totalMs`. Surface that to users when you
+ * render the breakdown — a bar chart implying a partition of the total would
+ * be wrong for a pipeline that overlaps stages.
+ *
+ * @returns A profiler bound to the moment it was created.
+ *
+ * @example
+ * ```typescript
+ * import { createInferenceProfiler } from "tempest-react-sdk";
+ * import { Detector } from "tempest-react-sdk/vision";
+ *
+ * const profiler = createInferenceProfiler();
+ * const detector = await profiler.stage("load-model", () =>
+ *     Detector.create("/models/detect.onnx"),
+ * );
+ * const results = await profiler.stage("detect", () => detector.predict(blob));
+ * profiler.mark("forward-pass", results[0].speed.inference);
+ *
+ * const report = await profiler.report({
+ *     models: [
+ *         { name: "detector", cacheName: "app-models", url: "/models/detect.onnx" },
+ *     ],
+ * });
+ * console.log(report.timings, report.totalMs, report.device, report.models);
+ * ```
+ */
+export declare function createInferenceProfiler(): InferenceProfiler;
+
 /**
  * Trivial in-memory adapter. Suitable for tests, local development, or as a
  * fallback wrapping the real provider while it loads.
@@ -2272,6 +2826,48 @@ export declare interface CreateLaunchDarklyFeatureFlagsAdapterOptions {
     client: LDClientLike;
 }
 
+/**
+ * Sample the loudness of a live stream, 0–1.
+ *
+ * This exists because a recorder with no visible level is indistinguishable from a
+ * broken one. A muted OS input, a headset whose mic arm is switched off, the wrong
+ * device selected — all three produce a perfectly successful recording of silence,
+ * and the user only finds out after they finish talking.
+ *
+ * The value is RMS, not peak: peak reacts to a single sample and flickers, RMS tracks
+ * perceived loudness. It is deliberately **not** React state — updating state per
+ * frame would re-render the tree 60 times a second. Poll `level()` from a
+ * `requestAnimationFrame` loop and write to the DOM, or read it inside an existing
+ * animation.
+ *
+ * The `AudioContext` is created here and closed by `stop()`. Browsers cap the number
+ * of live contexts (Chrome allows around six), so a meter left running on unmount
+ * eventually breaks every later one on the page.
+ *
+ * @param stream - A live audio stream.
+ * @param options - See {@link LevelMeterOptions}.
+ * @returns A `level()` reader and a `stop()`.
+ *
+ * @example
+ * const meter = createLevelMeter(stream);
+ * const tick = () => { bar.style.transform = `scaleX(${meter.level()})`; raf = requestAnimationFrame(tick); };
+ */
+export declare function createLevelMeter(stream: MediaStream, { fftSize, decay }?: LevelMeterOptions): LevelMeter;
+
+/**
+ * `localStorage`-backed resume storage — the default.
+ *
+ * `localStorage` and not IndexedDB on purpose. The record is four fields and a
+ * URL; the requirement is only that it survives a reload, and pulling Dexie in for
+ * that would put an IndexedDB dependency in the bundle of every app that uploads a
+ * file. Apps that already have `createOfflineStore` open can pass their own
+ * {@link ResumableUploadStorage} instead.
+ *
+ * @param prefix - Key prefix. Default `"tempest-upload:"`.
+ * @returns A storage that no-ops when `localStorage` is unavailable.
+ */
+export declare function createLocalUploadStorage(prefix?: string): ResumableUploadStorage;
+
 /**
  * Create a structured leveled logger. Plug arbitrary sinks (Sentry, Datadog,
  * remote ingestion) by implementing the `LoggerSink` interface.
@@ -2287,6 +2883,34 @@ export declare interface CreateLoggerOptions {
     namespace?: string;
 }
 
+/**
+ * Wrap a `MediaStream` in a recorder with a real state machine and an honest clock.
+ *
+ * This is the engine behind both `createAudioRecorder` and `createVideoRecorder`; the
+ * only thing it does not decide is which containers to try, because that is the one
+ * part that genuinely differs between the two.
+ *
+ * Two things `MediaRecorder` does not give you:
+ *
+ * - **A duration.** It reports none, and the `Blob` has no reliable one either —
+ *   WebM written by `MediaRecorder` carries no duration in its header, which is why
+ *   `<audio>`/`<video>` shows `Infinity` for a fresh recording. So the clock is kept
+ *   here, and it subtracts paused time: a recorder that counts wall-clock through a
+ *   pause reports a 30-second note as two minutes.
+ * - **A promise from `stop()`.** The last chunk arrives *after* `stop()` returns, in
+ *   a `dataavailable` event that fires before `onstop`. Assembling the blob in
+ *   `onstop` is the only point where every chunk is in hand.
+ *
+ * The stream is **not** owned here: `stop()` leaves the device open so a retake does
+ * not need a second permission round-trip. Release it with the owning hook's `stop()`.
+ *
+ * @param stream - A live stream, from `getUserMedia` or `getDisplayMedia`.
+ * @param options - See {@link MediaRecordingOptions}.
+ * @returns The imperative recorder.
+ * @throws When `MediaRecorder` is unavailable, or an explicit `mimeType` is unsupported.
+ */
+export declare function createMediaRecorder(stream: MediaStream, options: MediaRecordingOptions): MediaRecorderHandle;
+
 /**
  * Build a typed IndexedDB-backed store using Dexie. Optionally scope every
  * operation by an `ownerField` (useful for multi-user SSE history, drafts,
@@ -2378,6 +3002,55 @@ export declare function createOSRMBackend(options: OSRMBackendOptions): RoutingB
  */
 export declare function createPartialResponse(request: Request, response: Response): Promise<Response>;
 
+/**
+ * Build a WebAuthn client: the base64url ↔ `ArrayBuffer` plumbing, the two
+ * ceremonies, and one classified error type.
+ *
+ * ## What your backend must do
+ *
+ * This is the **client half only**, and a WebAuthn client that documents only its
+ * own half is unusable. Four routes are yours to implement:
+ *
+ * 1. `POST /webauthn/register/begin` → a {@link PasskeyCreationOptionsJSON}. Mint a
+ *    random `challenge` (≥16 bytes), store it against the session, and list the
+ *    user's existing credentials in `excludeCredentials`.
+ * 2. `POST /webauthn/register/finish` ← a {@link PasskeyRegistrationJSON}. Verify
+ *    the challenge, `origin` and `type` inside `clientDataJSON`, parse the
+ *    attestation object, then store the credential id, public key and signature
+ *    counter.
+ * 3. `POST /webauthn/signin/begin` → a {@link PasskeyRequestOptionsJSON}. New
+ *    challenge. Omit `allowCredentials` for a usernameless or autofill flow.
+ * 4. `POST /webauthn/signin/finish` ← a {@link PasskeyAuthenticationJSON}. Look the
+ *    credential up by `id`, verify the signature over
+ *    `authenticatorData || sha256(clientDataJSON)`, and reject a signature counter
+ *    that did not grow (a clone). Only then issue your session token.
+ *
+ * @param options - Defaults applied when the server options omit them.
+ * @returns A client usable from anywhere — React, a plain form, a worker.
+ *
+ * @example
+ * const passkeys = createPasskeyClient({ rpId: "acme.com" });
+ *
+ * const options = await api.post("/webauthn/register/begin");
+ * const credential = await passkeys.register(options);
+ * await api.post("/webauthn/register/finish", { body: credential });
+ */
+export declare function createPasskeyClient(options?: CreatePasskeyClientOptions): PasskeyClient;
+
+/** Options for {@link createPasskeyClient}. */
+export declare interface CreatePasskeyClientOptions {
+    /**
+     * Default relying-party id, applied when the server options omit one. Must be
+     * the page's domain or a registrable parent of it (`app.acme.com` may use
+     * `acme.com`, never the other way round).
+     */
+    rpId?: string;
+    /** Default ceremony timeout in ms. Default `60_000`. */
+    timeoutMs?: number;
+    /** `navigator.credentials` replacement, for tests. */
+    credentials?: CredentialsContainerLike;
+}
+
 /**
  * Record a live GPS trajectory from `navigator.geolocation.watchPosition`.
  * Framework-free — the {@link usePositionTracker} hook wraps this for React.
@@ -2488,6 +3161,61 @@ export declare function createQueryKeys<TKey extends string, TEntries extends Re
  */
 export declare function createRefreshQueue(refresh: () => Promise<void>): () => Promise<void>;
 
+/**
+ * Chunked, resumable upload speaking the **tus 1.0.0** protocol (core plus the
+ * *creation* and *termination* extensions).
+ *
+ * ## Why tus and not a bespoke scheme
+ *
+ * A resumable client whose wire format is undocumented cannot be integrated, and
+ * inventing one means the backend is ours forever. tus is a published spec with
+ * off-the-shelf servers (`tusd`, `tuspy`, `tus-node-server`), so a caller can point
+ * this at something they did not write.
+ *
+ * ## What the backend must implement
+ *
+ * Every request carries `Tus-Resumable: 1.0.0`.
+ *
+ * | Step | Request | Expected response |
+ * | --- | --- | --- |
+ * | Create | `POST {endpoint}` + `Upload-Length`, `Upload-Metadata`, `Idempotency-Key` | `201` + `Location` (the upload URL, absolute or endpoint-relative) |
+ * | Probe | `HEAD {uploadUrl}` | `200`/`204` + `Upload-Offset` |
+ * | Write | `PATCH {uploadUrl}` + `Upload-Offset`, `Content-Type: application/offset+octet-stream`, chunk body | `204` + the new `Upload-Offset`; `409` when the offset does not match |
+ * | Discard | `DELETE {uploadUrl}` | `204` |
+ *
+ * ## The failure that actually happens
+ *
+ * A chunk that the server stored but whose response never arrived. The client
+ * cannot tell that from a chunk that was lost, and re-sending it blindly would
+ * duplicate bytes. Two things prevent that:
+ *
+ * - **Writes are addressed, not appended.** Every `PATCH` states the offset it
+ *   writes at, so a retry after a lost response is asked to write bytes the server
+ *   already has and answers `409`. On any retry the client re-reads the truth with
+ *   `HEAD` first and continues from there.
+ * - **Creation carries an `Idempotency-Key`** (from `generateIdempotencyKey`),
+ *   persisted before the first attempt and reused on retry. tus has no idempotent
+ *   creation of its own, so without this a lost `201` leaves an orphan upload on
+ *   the server. A backend that honours the header returns the same `Location`; one
+ *   that ignores it still works, it just keeps the orphan.
+ *
+ * @param options - Endpoint, file, and the knobs above.
+ * @returns A handle with `start`/`pause`/`resume`/`abort` and live `state`/`offset`.
+ *
+ * @example
+ * const upload = createResumableUpload({
+ *     endpoint: "/api/uploads",
+ *     file: recording,
+ *     metadata: { filename: "nota.webm", ticket: ticketId },
+ *     getToken: () => auth.getToken(),
+ *     onProgress: ({ fraction }) => setPercent(Math.round(fraction * 100)),
+ * });
+ *
+ * const done = await upload.start();
+ * if (done) await api.post("/api/tickets/1/audio", { body: { url: done.url } });
+ */
+export declare function createResumableUpload(options: ResumableUploadOptions): ResumableUpload;
+
 /**
  * Build a simple RBAC {@link AccessControl} from a static permission set.
  *
@@ -2735,6 +3463,30 @@ export declare interface CreateThemeOptions {
     darkSelector?: string;
 }
 
+/**
+ * Record a video stream — a camera, a screen share, or a `canvas.captureStream()`.
+ *
+ * The state machine, the clock that subtracts paused time and the `stop()` that
+ * resolves in `onstop` with every chunk in hand are shared with the audio recorder
+ * (see `createMediaRecorder`); what this adds is the container list and
+ * `videoBitsPerSecond`.
+ *
+ * The stream is **not** owned here. For a screen share in particular, stopping the
+ * recorder must not stop the sharing: a support flow usually records, stops, lets the
+ * user look at the result and then records again.
+ *
+ * @param stream - A live stream carrying at least one video track.
+ * @param options - See {@link VideoRecorderOptions}.
+ * @returns The imperative recorder.
+ * @throws When `MediaRecorder` is unavailable, or an explicit `mimeType` is unsupported.
+ *
+ * @example
+ * const recorder = createVideoRecorder(stream, { videoBitsPerSecond: 2_500_000 });
+ * recorder.start();
+ * const { blob, durationMs } = await recorder.stop();
+ */
+export declare function createVideoRecorder(stream: MediaStream, options?: VideoRecorderOptions): VideoRecorderHandle;
+
 /**
  * Open a WebSocket with automatic exponential-backoff reconnect, optional
  * heartbeat pings, and typed JSON parsing.
@@ -2796,6 +3548,28 @@ export declare interface CreateWebSocketOptions<T> {
     onStatusChange?: (status: WebSocketStatus) => void;
 }
 
+/**
+ * Minimal subset of `navigator.credentials` the passkey client touches.
+ *
+ * Declared here — the `<X>Like` pattern the SDK's adapters use — for two reasons:
+ * jsdom has no `navigator.credentials` at all, so tests must inject a double; and
+ * `mediation: "conditional"` is newer than some TypeScript DOM libs, which would
+ * otherwise reject the call that makes autofill work.
+ */
+export declare interface CredentialsContainerLike {
+    /** Runs the registration ceremony. */
+    create(options: {
+        publicKey: PublicKeyCredentialCreationOptions;
+        signal?: AbortSignal;
+    }): Promise<Credential | null>;
+    /** Runs the authentication ceremony. */
+    get(options: {
+        publicKey: PublicKeyCredentialRequestOptions;
+        signal?: AbortSignal;
+        mediation?: string;
+    }): Promise<Credential | null>;
+}
+
 /** Cursor-paginated response envelope (`CursorPaginationSchema[T]`). */
 export declare interface CursorPage<T> {
     /** The rows for this batch. */
@@ -2927,25 +3701,53 @@ export declare interface DataProviderOptions {
 
 /**
  * Stateful, headless data table built on top of {@link Table}. Adds
- * client-side searching, click-to-sort columns, and pagination while
- * delegating all table markup to the underlying Table component.
+ * client-side searching, click-to-sort columns, pagination and opt-in inline
+ * editing while delegating all table markup to the underlying Table component.
  *
  * - Clicking a sortable header cycles asc → desc → unsorted.
  * - Search matches a case-insensitive substring across `searchKeys`
  *   (or every string/number column when not provided).
  * - Pagination is hidden when the result fits on a single page.
+ * - A column with `editable` renders a button that opens an inline editor;
+ *   `Enter` commits, `Escape` discards, `Tab` walks to the next editable cell.
+ *
+ * Editing is strictly opt-in: with no `editable` column (or no `onCellChange`) the
+ * rendered markup is byte-for-byte what it was before the feature existed, which
+ * matters because the component is published.
+ *
+ * ## Optimistic, with a visible rollback
  *
- * The header memo depends on `columns` and `sort` only: `toggleSort` is
- * recreated each render but always closes over the same setter, so including it
- * would rebuild every header on every render without changing behaviour. That
- * is why `exhaustive-deps` is silenced on that dependency array.
+ * An accepted edit is shown immediately and `onCellChange` runs in the background.
+ * If it rejects, the cell returns to the old value **and** shows the reason as a
+ * `role="alert"` tied to the cell. A silent revert is worse than no optimistic
+ * update at all: the user watched their edit appear and has no reason to doubt it.
+ *
+ * The header memo depends on `columns`, `sort` and the editing state only:
+ * `toggleSort` and the commit callbacks are recreated each render but always close
+ * over the same setters, so including them would rebuild every header on every
+ * render without changing behaviour. That is why `exhaustive-deps` is silenced on
+ * that dependency array.
  */
-export declare function DataTable<T>({ data, columns, pageSize, searchable, searchKeys, initialSort, rowKey, emptyMessage, className, ...rest }: DataTableProps<T>): JSX.Element;
+export declare function DataTable<T>({ data, columns, pageSize, searchable, searchKeys, initialSort, rowKey, emptyMessage, onCellChange, editLabels, className, ...rest }: DataTableProps<T>): JSX.Element;
+
+/** One accepted cell edit, handed to `onCellChange`. */
+export declare interface DataTableCellChange<T> {
+    /** The row as it was before the edit. */
+    row: T;
+    /** Which column changed. */
+    key: keyof T;
+    /** The parsed new value. */
+    value: unknown;
+    /** The value that was displayed before the edit. */
+    previous: unknown;
+    /** Index of the row in the full `data` array. */
+    rowIndex: number;
+}
 
 /**
  * Column definition for {@link DataTable}. Extends the headless {@link Table}
- * column shape with a typed `key`, opt-in sorting, and the visual options that
- * are forwarded to the underlying Table cell.
+ * column shape with a typed `key`, opt-in sorting, opt-in inline editing, and the
+ * visual options that are forwarded to the underlying Table cell.
  */
 export declare interface DataTableColumn<T> {
     /** Property of the row this column reads from. Doubles as the cell key. */
@@ -2962,8 +3764,49 @@ export declare interface DataTableColumn<T> {
     priority?: TablePriority;
     /** Fixed column width forwarded to the Table cell. */
     width?: string | number;
+    /**
+     * Let cells in this column be edited in place. Requires `onCellChange` on the
+     * table; without it the column stays read-only.
+     */
+    editable?: boolean;
+    /** Editor input type. Default `"text"`. */
+    editorType?: DataTableEditorType;
+    /** Text the editor opens with. Defaults to `String(value ?? "")`. */
+    formatEdit?: (row: T) => string;
+    /**
+     * Turn the typed string into the stored value. Defaults to the trimmed string,
+     * or `Number(raw)` when `editorType` is `"number"`.
+     */
+    parse?: (raw: string, row: T) => unknown;
+    /** Return a message to reject the edit, or `null` to accept it. */
+    validate?: (value: unknown, row: T) => string | null;
+}
+
+/** Copy for the inline-editing affordances. Every entry has a PT-BR default. */
+export declare interface DataTableEditLabels {
+    /**
+     * Visually hidden prefix that turns a cell's own content into the button's name.
+     *
+     * A prefix and not a whole label: the accessible name has to *contain* the visible
+     * text (WCAG 2.5.3, Label in Name), and a label built from the raw value would say
+     * "850000" over a cell that reads `R$ 8.500,00` — which breaks voice control and
+     * makes the screen reader disagree with the screen.
+     *
+     * A single space is appended when it is rendered, so the name reads
+     * `"Editar Salário: R$ 8.500,00"`. Do not add one yourself.
+     */
+    editCell: (column: string) => string;
+    /** Accessible name of the editor input. */
+    editor: (column: string, rowNumber: number) => string;
+    /** Announced (politely) once a cell saved. */
+    saved: (column: string) => string;
+    /** Shown in the cell when the save was rejected and no reason was thrown. */
+    saveFailed: (column: string) => string;
 }
 
+/** Input types an editable column can use. */
+export declare type DataTableEditorType = "text" | "number" | "date" | "email" | "tel" | "url";
+
 export declare interface DataTableProps<T> extends HTMLAttributes<HTMLDivElement> {
     /** Full, unfiltered dataset. Sorting/filtering/pagination happen client-side. */
     data: T[];
@@ -2984,6 +3827,14 @@ export declare interface DataTableProps<T> extends HTMLAttributes<HTMLDivElement
     rowKey?: (row: T, index: number) => string | number;
     /** Content shown when no rows match. */
     emptyMessage?: ReactNode;
+    /**
+     * Persist an accepted cell edit. Return a promise: while it is pending the cell
+     * already shows the new value, and a rejection rolls that back and surfaces the
+     * error in the cell. Without this prop no column is editable.
+     */
+    onCellChange?: (change: DataTableCellChange<T>) => void | Promise<void>;
+    /** Override the PT-BR copy of the editing affordances. */
+    editLabels?: Partial<DataTableEditLabels>;
 }
 
 export declare interface DataTableSort<T> {
@@ -3118,12 +3969,24 @@ export declare function decodeJWT(token: string): DecodedJWT;
  */
 export declare function deepMerge<T>(target: T, source: Partial<T>): T;
 
+/**
+ * What a scanner looks for when you do not say.
+ *
+ * Deliberately three formats, not all fourteen. Every extra symbology is more work
+ * per frame, and on a mid-range phone the difference between three and fourteen is the
+ * difference between a scanner that locks on instantly and one that feels broken.
+ */
+export declare const DEFAULT_BARCODE_FORMATS: readonly BarcodeFormat[];
+
 /**
  * Default average car speed in km/h used to derive duration from distance.
  * Mirrors `DEFAULT_CAR_SPEED_KMH` from `tempest-fastapi-sdk`.
  */
 export declare const DEFAULT_CAR_SPEED_KMH = 50;
 
+/** Default chunk size: 5 MiB, the size most tus servers are tuned for. */
+export declare const DEFAULT_CHUNK_SIZE: number;
+
 /**
  * Multiplier applied to the great-circle distance to approximate real road
  * distance. Mirrors `DEFAULT_CIRCUITY_FACTOR` from `tempest-fastapi-sdk`.
@@ -3137,6 +4000,21 @@ export declare const DEFAULT_CIRCUITY_FACTOR = 1.3;
  */
 export declare const DEFAULT_MODE_DURATION_FACTORS: Record<TravelMode, number>;
 
+/**
+ * COSE algorithms offered when the server sends no `pubKeyCredParams`, in
+ * preference order.
+ *
+ * `-8` is Ed25519, which modern authenticators prefer and which produces the
+ * smallest signatures. `-7` is ES256, the one algorithm every WebAuthn
+ * authenticator supports. `-257` is RS256, needed for TPM-backed Windows Hello.
+ * Offering all three is what avoids a `NotSupportedError` on some device you do
+ * not own; a server that cannot verify one of them should send its own list.
+ */
+export declare const DEFAULT_PUB_KEY_CRED_PARAMS: {
+    type: "public-key";
+    alg: number;
+}[];
+
 /**
  * Identity helper that types a declarative route tree. Use it so editors give
  * autocomplete and type-checking on every node; the array is returned as-is.
@@ -3182,12 +4060,53 @@ export declare interface DescriptionListProps extends HTMLAttributes<HTMLDListEl
     items: DescriptionListItem[];
 }
 
+/**
+ * The shape a detector resolves with, before normalisation.
+ *
+ * Every field is optional because a polyfill is allowed to report the value and no
+ * geometry at all, and the native engines differ on `cornerPoints`.
+ */
+export declare interface DetectedBarcodeLike {
+    rawValue?: string;
+    format?: string;
+    boundingBox?: DOMRectReadOnly;
+    cornerPoints?: readonly BarcodePoint[];
+}
+
+/**
+ * Shapes describing what an on-device inference run cost.
+ *
+ * The browser exposes no energy counter and no FLOP counter, so "cost" here
+ * is assembled from what a page can actually observe: how long each stage
+ * took, how much parallelism and memory the device reports, and how large the
+ * cached model weights are. Anything the platform does not expose stays
+ * `null` — a UI can then render "—" instead of a fabricated number.
+ */
+/**
+ * Device capabilities as reported by the browser.
+ *
+ * Every field is best-effort. `deviceMemoryGb` and `jsHeapUsedMb` come from
+ * Chromium-only APIs (`navigator.deviceMemory`, `performance.memory`) and are
+ * `null` everywhere else, including Firefox and Safari.
+ */
+export declare interface DeviceProfile {
+    /** Logical cores available to workers, or `null` when unreported. */
+    hardwareConcurrency: number | null;
+    /** Approximate device RAM in GiB (coarse, Chromium-only), or `null`. */
+    deviceMemoryGb: number | null;
+    /** Used JS heap in MiB (Chromium-only), or `null`. */
+    jsHeapUsedMb: number | null;
+}
+
 export declare interface DisclosureHandlers {
     open: () => void;
     close: () => void;
     toggle: () => void;
 }
 
+/** Which surface to put first in the picker. */
+export declare type DisplaySurfaceHint = "monitor" | "window" | "browser";
+
 /** How many steps the diverging token scale has, midpoint included. */
 export declare const DIVERGING_STEP_COUNT = 9;
 
@@ -3404,6 +4323,23 @@ export declare interface EmptyStateProps {
  */
 export declare function encodeQR(text: string, options?: QREncodeOptions): QRMatrix;
 
+/**
+ * Wrap PCM in a 16-bit RIFF/WAVE container.
+ *
+ * The header is the 44-byte canonical form: `RIFF` size, `WAVE`, a 16-byte `fmt `
+ * chunk declaring format 1 (uncompressed PCM), then `data`. Samples are interleaved
+ * and clamped before scaling, because a value even slightly past ±1 wraps around when
+ * truncated to 16 bits and turns a loud passage into a burst of noise.
+ *
+ * Implemented here rather than pulled from a package: it is a fixed header and a
+ * scaling loop, roughly forty lines, and a dependency for it would put its own
+ * version bounds on every consumer of this SDK to save writing them.
+ *
+ * @param audio - Channels and sample rate.
+ * @returns A `Blob` of type `audio/wav`.
+ */
+export declare function encodeWav({ channels, sampleRate }: PcmAudio): Blob;
+
 /**
  * Class-based React error boundary with a render-prop or static fallback.
  * Auto-resets when any value in `resetKeys` changes.
@@ -3643,7 +4579,7 @@ export declare interface Filter {
  */
 export declare function FilterBar({ fields, value, onChange, locale, actions, className, ...rest }: FilterBarProps): JSX.Element;
 
-export declare interface FilterBarProps extends Omit<HTMLAttributes<HTMLDivElement>, OverriddenDomProps_9> {
+export declare interface FilterBarProps extends Omit<HTMLAttributes<HTMLDivElement>, OverriddenDomProps_12> {
     /** Fields the user may filter by. */
     fields: readonly FilterField[];
     /** Applied filters. Controlled. */
@@ -3901,6 +4837,31 @@ export declare function formatDate(value: string | Date): string;
  */
 export declare function formatDateTime(value: string | Date): string;
 
+/**
+ * Rendering helpers for the numbers a profiler produces.
+ */
+/**
+ * Format a millisecond duration for display.
+ *
+ * Sub-second values keep millisecond resolution — the interesting range for a
+ * single forward pass — and anything longer switches to seconds so a cold
+ * start that pays a model download does not read as a five-digit number.
+ * Durations under `1 ms` render as `"<1 ms"` rather than `"0 ms"`, which
+ * would read as "not measured".
+ *
+ * @param value Duration in milliseconds.
+ * @returns The formatted string, or `"—"` for a non-finite or negative input.
+ *
+ * @example
+ * ```typescript
+ * formatDurationMs(0.04);   // "<1 ms"
+ * formatDurationMs(142.6);  // "143 ms"
+ * formatDurationMs(4321);   // "4.32 s"
+ * formatDurationMs(NaN);    // "—"
+ * ```
+ */
+export declare function formatDurationMs(value: number): string;
+
 /**
  * Format a fraction (0-1) as a percentage with one decimal.
  *
@@ -4110,6 +5071,18 @@ export declare interface GetListParams {
     filters?: DataFilters;
 }
 
+/**
+ * Which symbologies this engine will actually decode.
+ *
+ * Worth asking rather than assuming: the format list belongs to the platform decoder,
+ * not to the browser, so two Chromium builds on two operating systems answer
+ * differently — and asking for a format the engine does not have makes the constructor
+ * throw `NotSupportedError`, which reads like a bug in your code.
+ *
+ * @returns The supported formats, or an empty array when there is no detector.
+ */
+export declare function getSupportedBarcodeFormats(): Promise<readonly BarcodeFormat[]>;
+
 /**
  * Look up a preset by name.
  *
@@ -4467,15 +5440,79 @@ export declare interface ImageCropperProps extends Omit<HTMLAttributes<HTMLDivEl
     ref?: React.Ref<ImageCropperHandle>;
 }
 
-export declare interface ImageProps extends Omit<ImgHTMLAttributes<HTMLImageElement>, "src"> {
-    /** Primary image source URL. */
-    src: string;
-    /** Fallback source swapped in once if the primary `src` fails to load. */
-    fallback?: string;
-    /** Alternative text describing the image (required for accessibility). */
-    alt: string;
-    /** When true (default) uses native lazy loading; otherwise loads eagerly. */
-    lazy?: boolean;
+export declare interface ImageProps extends Omit<ImgHTMLAttributes<HTMLImageElement>, "src"> {
+    /** Primary image source URL. */
+    src: string;
+    /** Fallback source swapped in once if the primary `src` fails to load. */
+    fallback?: string;
+    /** Alternative text describing the image (required for accessibility). */
+    alt: string;
+    /** When true (default) uses native lazy loading; otherwise loads eagerly. */
+    lazy?: boolean;
+}
+
+/**
+ * Records how long each stage of a pipeline took.
+ *
+ * Stages are measured **independently**, not as a tiling of the whole run:
+ * two stages started concurrently are each charged their full wall-clock
+ * span, so the sum can exceed {@link InferenceReport.totalMs}. That is the
+ * honest reading for a pipeline that decodes an image while the model
+ * sessions are still loading.
+ */
+export declare interface InferenceProfiler {
+    /**
+     * Run an async stage and record its duration.
+     *
+     * @param name Stage label used as the key in the report.
+     * @param run The work to time.
+     * @returns Whatever `run` resolved to.
+     */
+    stage<T>(name: string, run: () => Promise<T>): Promise<T>;
+    /**
+     * Run a synchronous stage and record its duration.
+     *
+     * @param name Stage label used as the key in the report.
+     * @param run The work to time.
+     * @returns Whatever `run` returned.
+     */
+    stageSync<T>(name: string, run: () => T): T;
+    /**
+     * Record a duration measured elsewhere — a `speed` breakdown returned by
+     * `tempest-react-sdk/vision`, for instance.
+     *
+     * Repeated names accumulate, so folding two passes of the same kind into
+     * one row is a matter of calling `mark` twice.
+     *
+     * @param name Stage label used as the key in the report.
+     * @param durationMs How long it took, in milliseconds.
+     */
+    mark(name: string, durationMs: number): void;
+    /**
+     * Assemble the report for everything recorded so far.
+     *
+     * @param options Which models to size up in Cache Storage.
+     * @returns The finished report.
+     */
+    report(options?: InferenceReportOptions): Promise<InferenceReport>;
+}
+
+/** What one profiled run cost. */
+export declare interface InferenceReport {
+    /** Duration in milliseconds per stage name, in the order first recorded. */
+    timings: Readonly<Record<string, number>>;
+    /** Milliseconds from profiler creation to the `report()` call. */
+    totalMs: number;
+    device: DeviceProfile;
+    models: readonly ProfiledModelSize[];
+    /** Epoch millis at which the report was assembled. */
+    measuredAt: number;
+}
+
+/** Options for {@link InferenceProfiler.report}. */
+export declare interface InferenceReportOptions {
+    /** Models to measure in Cache Storage. Omit to report none. */
+    models?: readonly ProfiledModel[];
 }
 
 export declare interface InMemoryFlagsOptions {
@@ -4741,6 +5778,46 @@ export declare function isAndroidWithoutPromptApi(): boolean;
  */
 export declare function isApiError(error: unknown): error is ApiError;
 
+/**
+ * Whether this browser can route audio to a chosen output device.
+ *
+ * Chromium-only at the time of writing: Firefox has `setSinkId` behind a preference
+ * that is off by default, and Safari does not implement it at all. Check this before
+ * rendering an output picker, or the control is a lie on two of three engines.
+ */
+export declare function isAudioOutputSelectionSupported(): boolean;
+
+/** Whether `MediaRecorder` exists and can produce at least one audio container. */
+export declare function isAudioRecordingSupported(): boolean;
+
+/**
+ * Whether this browser can decode barcodes on its own.
+ *
+ * **Expect `false` on a lot of real devices, and design for it.** `BarcodeDetector` is
+ * a Chromium-only API backed by a platform decoder, so it is there on Android and
+ * ChromeOS, usually there on macOS, and **absent** on Chromium for Windows and Linux,
+ * in Firefox, and in every browser on iOS (all of which are WebKit underneath,
+ * including Chrome for iOS).
+ *
+ * This SDK ships **no** decoder of its own and no bundled fallback: a QR reader is
+ * Reed–Solomon error correction plus perspective correction plus a finder-pattern
+ * search, and the honest options are a WASM build every consumer of this SDK would pay
+ * for, or nothing. So the escape hatch is injection instead — pass any
+ * {@link BarcodeDetectorLike} (the `barcode-detector` polyfill, your own `zxing-wasm`
+ * wrapper) as `detector` to `useBarcodeScanner`, and the SDK drives it exactly like
+ * the native one.
+ *
+ * @returns `true` when `new BarcodeDetector()` will work.
+ */
+export declare function isBarcodeDetectionSupported(): boolean;
+
+/**
+ * Whether autofill-driven passkeys (`mediation: "conditional"`) are available.
+ *
+ * @returns `false` when the API is missing or throws.
+ */
+export declare function isConditionalMediationAvailable(): Promise<boolean>;
+
 /**
  * Type guard for {@link Coordinate}: an object with finite, in-range
  * `latitude` and `longitude`.
@@ -4805,6 +5882,14 @@ export declare function isIOS(): boolean;
  */
 export declare function isJWTExpired(token: string, leewaySeconds?: number): boolean;
 
+/**
+ * Whether `getUserMedia` is reachable at all.
+ *
+ * Separate from the classifier because a page often wants to hide a "record" button
+ * entirely rather than render it and fail on click.
+ */
+export declare function isMediaCaptureSupported(): boolean;
+
 /**
  * Type guard asserting a value is a number, excluding `NaN`.
  *
@@ -4823,6 +5908,15 @@ export declare function isNumber(value: unknown): value is number;
  */
 export declare function isOffsetPage<T = unknown>(value: unknown): value is OffsetPage<T>;
 
+/**
+ * Whether this browser exposes WebAuthn at all.
+ *
+ * Note that "supported" is not "usable": WebAuthn also requires a secure context,
+ * and a device may have no authenticator. Use
+ * {@link isPlatformAuthenticatorAvailable} before offering a passkey button.
+ */
+export declare function isPasskeySupported(): boolean;
+
 /**
  * Type guard asserting a value is a plain object literal.
  *
@@ -4837,15 +5931,36 @@ export declare function isOffsetPage<T = unknown>(value: unknown): value is Offs
  */
 export declare function isPlainObject(value: unknown): value is Record<string, unknown>;
 
+/**
+ * Whether the device has a **built-in** authenticator — Face ID, Touch ID,
+ * Windows Hello, an Android screen lock.
+ *
+ * This is the check that decides whether "Entrar com passkey" may be shown at
+ * all. `isPasskeySupported()` is true on a desktop with no biometrics and no
+ * security key, and offering a passkey there sends the user into a sheet that can
+ * only be cancelled. A `false` here does not forbid passkeys — a phone can still
+ * be used over hybrid/QR — it means the flow needs a second step, so present it
+ * as "usar meu celular", not as one tap.
+ *
+ * @returns `false` when the API is missing, so a caller never has to null-check.
+ */
+export declare function isPlatformAuthenticatorAvailable(): Promise<boolean>;
+
 /**
  * Convenience check for environments where the Push API is unavailable
  * (Safari iOS without PWA install, older browsers, SSR, etc.).
  */
 export declare function isPushSupported(): boolean;
 
+/** Whether `getDisplayMedia` is reachable at all. */
+export declare function isScreenCaptureSupported(): boolean;
+
 /** True when the Web Share API is available in this environment. */
 export declare function isShareSupported(): boolean;
 
+/** Whether this browser exposes the Web Speech recognition API at all. */
+export declare function isSpeechRecognitionSupported(): boolean;
+
 /**
  * Reports whether the app is running as an installed PWA (Android Chrome, iOS,
  * or desktop). Use it to suppress install CTAs once the user is already in the
@@ -4870,6 +5985,9 @@ export declare function isValidLatitude(value: number): boolean;
 /** True when `value` is a finite longitude in `[-180, 180]`. */
 export declare function isValidLongitude(value: number): boolean;
 
+/** Whether `MediaRecorder` exists and can produce at least one video container. */
+export declare function isVideoRecordingSupported(): boolean;
+
 /**
  * Kanban board: columns of cards, reorderable within a column and movable across
  * columns, by pointer **or** keyboard.
@@ -5104,6 +6222,31 @@ export declare interface LDClientLike {
     off?: (event: string, handler: () => void) => void;
 }
 
+/** A running level meter. */
+export declare interface LevelMeter {
+    /** Latest level, 0–1. Read it on your own frame loop. */
+    level: () => number;
+    /** Stop sampling and release the Web Audio graph. */
+    stop: () => void;
+}
+
+/** Options for {@link createLevelMeter}. */
+export declare interface LevelMeterOptions {
+    /**
+     * FFT window. 1024 is a good default: ~21 ms at 48 kHz, long enough to be stable
+     * and short enough to react to a syllable.
+     */
+    fftSize?: number;
+    /**
+     * Extra smoothing on the way down, 0–1. Default `0.7`.
+     *
+     * A raw RMS reading is jittery enough to make a meter look broken. Attack is left
+     * instant — a meter that lags the voice going *up* reads as "not recording" —
+     * while the decay is eased, which is how every hardware meter behaves.
+     */
+    decay?: number;
+}
+
 /**
  * Full-screen image viewer with keyboard navigation.
  *
@@ -5363,7 +6506,7 @@ export declare type MarkdownInline = {
     type: "break";
 };
 
-export declare interface MarkdownProps extends Omit<HTMLAttributes<HTMLDivElement>, OverriddenDomProps_8> {
+export declare interface MarkdownProps extends Omit<HTMLAttributes<HTMLDivElement>, OverriddenDomProps_11> {
     /** The Markdown source. */
     source: string;
     /**
@@ -5401,7 +6544,7 @@ export declare interface MarkdownProps extends Omit<HTMLAttributes<HTMLDivElemen
  */
 export declare function Masonry<T>({ items, children, itemKey, columns, gap, className, style, ...rest }: MasonryProps<T>): JSX.Element;
 
-export declare interface MasonryProps<T> extends Omit<HTMLAttributes<HTMLDivElement>, OverriddenDomProps_7> {
+export declare interface MasonryProps<T> extends Omit<HTMLAttributes<HTMLDivElement>, OverriddenDomProps_10> {
     /** What to lay out. */
     items: readonly T[];
     /** Render one card. */
@@ -5430,6 +6573,115 @@ export declare interface MasonryProps<T> extends Omit<HTMLAttributes<HTMLDivElem
  */
 export declare function matrixToPath(matrix: QRMatrix, margin?: number): string;
 
+/** A classified capture error with a human-readable, English message. */
+export declare interface MediaAccessError {
+    kind: MediaAccessErrorKind;
+    message: string;
+}
+
+/** Classified reason a capture device could not be acquired. */
+export declare type MediaAccessErrorKind = "unsupported" | "insecure" | "permission-denied" | "not-found" | "in-use" | "unknown";
+
+/**
+ * What a media error is about.
+ *
+ * `"screen"` is not a device in the `getUserMedia` sense — it is what
+ * `getDisplayMedia` captures — but it fails through the same `DOMException` names, so
+ * it is classified by the same function rather than by a second copy of the table.
+ */
+export declare type MediaDeviceKindLabel = "microphone" | "camera" | "screen";
+
+/** One device the browser is willing to tell us about. */
+export declare interface MediaDeviceOption {
+    deviceId: string;
+    /**
+     * Human label, or `""` until permission has been granted.
+     *
+     * See {@link UseMediaDevicesResult.labelsAvailable} — an empty label is not a
+     * bug, it is the browser refusing to fingerprint the machine.
+     */
+    label: string;
+    kind: MediaDeviceKind;
+    groupId: string;
+}
+
+/** Which capture permission to observe. */
+export declare type MediaPermissionName = "microphone" | "camera";
+
+/**
+ * Permission state, including the two cases the browser prompt cannot tell you
+ * apart on its own.
+ *
+ * - `"unknown"` — the Permissions API is unavailable (Safari does not report
+ *   `microphone`), so the only way to learn the answer is to ask for the device.
+ * - `"prompt"` — never asked. Asking now shows the browser prompt.
+ * - `"granted"` / `"denied"` — settled. `"denied"` is **sticky**: calling
+ *   `getUserMedia` again does not re-prompt, it rejects immediately.
+ */
+export declare type MediaPermissionState = "unknown" | "prompt" | "granted" | "denied";
+
+/** Imperative recorder over one `MediaStream`. */
+export declare interface MediaRecorderHandle {
+    /** Begin recording. No-op when already recording or paused. */
+    start: () => void;
+    /** Pause. The clock stops; `durationMs` freezes. */
+    pause: () => void;
+    /** Resume after `pause()`. */
+    resume: () => void;
+    /** Stop and resolve with the assembled recording. */
+    stop: () => Promise<MediaRecording>;
+    /** Stop and throw the bytes away. */
+    cancel: () => void;
+    status: () => MediaRecorderStatus;
+    /** Recorded length so far, excluding paused time. */
+    durationMs: () => number;
+    /** The negotiated container. */
+    mimeType: string;
+}
+
+/** Lifecycle of a recording. */
+export declare type MediaRecorderStatus = "idle" | "recording" | "paused" | "stopped";
+
+/** A finished recording, whatever it was made of. */
+export declare interface MediaRecording {
+    /** The bytes. Wrap with `useObjectUrl` to play it, or POST it as-is. */
+    blob: Blob;
+    /** What the browser actually produced — not necessarily what you asked for. */
+    mimeType: string;
+    /** Recorded length, excluding time spent paused. */
+    durationMs: number;
+}
+
+/** What a track carries — used only to word the errors this engine throws. */
+export declare type MediaRecordingKind = "audio" | "video";
+
+/** Options for {@link createMediaRecorder}. */
+export declare interface MediaRecordingOptions {
+    /**
+     * Container candidates, best first. Required: this engine has no opinion about
+     * codecs — the audio and video wrappers own that list.
+     */
+    candidates: readonly string[];
+    /** Wording for the thrown messages ("cannot record any supported *video* container"). */
+    kind: MediaRecordingKind;
+    /** Force a container, bypassing the negotiation. Throws when unsupported. */
+    mimeType?: string;
+    /** Target audio bitrate. */
+    audioBitsPerSecond?: number;
+    /** Target video bitrate. Ignored by the browser on an audio-only stream. */
+    videoBitsPerSecond?: number;
+    /**
+     * Emit a chunk every N ms through `onChunk`, for streaming upload.
+     *
+     * Without it the whole recording is buffered in memory until `stop()`.
+     */
+    timesliceMs?: number;
+    /** Receives each chunk when `timesliceMs` is set. Chunks are **not** independently playable. */
+    onChunk?: (chunk: Blob) => void;
+    /** Recorder-level failure (device unplugged mid-recording, encoder error). */
+    onError?: (error: unknown) => void;
+}
+
 /**
  * Memoize only the most recent call of `fn`, keyed by shallow-equal arguments.
  *
@@ -5513,6 +6765,23 @@ export declare interface MercatorPoint {
 
 export declare type Messages = Record<string, string>;
 
+/** Lifecycle of a microphone stream. */
+export declare type MicrophoneStatus = "idle" | "requesting" | "ready" | "error";
+
+/**
+ * The error for "the API is not here at all", which is a different question from
+ * "the API rejected".
+ *
+ * `classifyMediaError` takes a thrown value; a missing `navigator.mediaDevices` never
+ * threw one, and handing it `null` would come back `unknown` — the least actionable
+ * kind there is. The two real causes are an insecure page (the fix is a URL) and an
+ * engine that genuinely cannot capture (the fix is another browser), and telling them
+ * apart is the whole point.
+ *
+ * @param device - Which device was being opened, for the message.
+ */
+export declare function missingCaptureApiError(device?: MediaDeviceKindLabel): MediaAccessError;
+
 /**
  * Portal-rendered modal dialog with backdrop, Esc handler, and slots for
  * header/body/footer. Locks body scroll while open.
@@ -5782,6 +7051,19 @@ export declare interface NavigationRailProps extends Omit<HTMLAttributes<HTMLEle
 
 export { NavLink }
 
+/**
+ * Turn one raw detection into a {@link BarcodeScanResult}.
+ *
+ * An unrecognised `format` string becomes `"unknown"` rather than being passed through
+ * as a lie about the union, and missing geometry becomes `null`/`[]` rather than
+ * `undefined`, so a consumer never has to branch on three kinds of absence.
+ *
+ * @param raw - What the detector resolved with.
+ * @param known - The formats considered valid. Defaults to the whole spec list.
+ * @returns The normalised result.
+ */
+export declare function normalizeBarcode(raw: DetectedBarcodeLike, known?: readonly BarcodeFormat[]): BarcodeScanResult;
+
 /**
  * Normalize a longitude into the `[-180, 180]` range, wrapping values that
  * cross the antimeridian (e.g. `190` → `-170`).
@@ -6353,6 +7635,15 @@ export { Outlet }
  */
 declare type OverriddenDomProps = "children" | "title" | "onSelect";
 
+/** DOM attributes this component redefines. */
+declare type OverriddenDomProps_10 = "children";
+
+/** DOM attributes this component redefines. */
+declare type OverriddenDomProps_11 = "children";
+
+/** DOM attributes this component redefines. */
+declare type OverriddenDomProps_12 = "children" | "onChange";
+
 /** DOM attributes this component redefines. */
 declare type OverriddenDomProps_2 = "children" | "onSubmit";
 
@@ -6360,22 +7651,22 @@ declare type OverriddenDomProps_2 = "children" | "onSubmit";
 declare type OverriddenDomProps_3 = "onSubmit" | "value" | "defaultValue" | "rows";
 
 /** DOM attributes this component redefines. */
-declare type OverriddenDomProps_4 = "children" | "onSubmit";
-
-/** DOM attributes the composer redefines. */
-declare type OverriddenDomProps_5 = "onSubmit" | "value" | "defaultValue" | "rows";
+declare type OverriddenDomProps_4 = "children";
 
 /** DOM attributes this component redefines. */
-declare type OverriddenDomProps_6 = "children" | "onChange" | "defaultValue";
+declare type OverriddenDomProps_5 = "children" | "onError";
 
 /** DOM attributes this component redefines. */
-declare type OverriddenDomProps_7 = "children";
+declare type OverriddenDomProps_6 = "children" | "onError";
 
 /** DOM attributes this component redefines. */
-declare type OverriddenDomProps_8 = "children";
+declare type OverriddenDomProps_7 = "children" | "onSubmit";
+
+/** DOM attributes the composer redefines. */
+declare type OverriddenDomProps_8 = "onSubmit" | "value" | "defaultValue" | "rows";
 
 /** DOM attributes this component redefines. */
-declare type OverriddenDomProps_9 = "children" | "onChange";
+declare type OverriddenDomProps_9 = "children" | "onChange" | "defaultValue";
 
 /**
  * Page wrapper with header + (optional) toolbar + content + footer. Pairs
@@ -6451,6 +7742,221 @@ export declare function parseMarkdown(source: string): MarkdownBlock[];
  */
 export declare function parseResponse<TSchema extends z.ZodTypeAny>(schema: TSchema, raw: unknown, context: string): z.infer<TSchema>;
 
+/** Per-call knobs for {@link PasskeyClient.authenticate}. */
+export declare interface PasskeyAuthenticateInit extends PasskeyRegisterInit {
+    /**
+     * `"conditional"` is the autofill flow: no modal, the browser offers passkeys
+     * inside a field marked `autocomplete="webauthn"`. Requires a `signal`, and
+     * only one conditional request may be live per page.
+     */
+    mediation?: PasskeyMediation;
+}
+
+/** What the client sends to the backend to finish authentication. */
+export declare interface PasskeyAuthenticationJSON {
+    /** Base64url credential id — the server looks up the stored public key by it. */
+    id: string;
+    /** Same bytes as `id`. */
+    rawId: string;
+    type: "public-key";
+    /** `"platform"` or `"cross-platform"`. */
+    authenticatorAttachment: string | null;
+    response: {
+        /** Base64url client data. */
+        clientDataJSON: string;
+        /** Base64url authenticator data, carrying the signature counter. */
+        authenticatorData: string;
+        /** Base64url signature over `authenticatorData || sha256(clientDataJSON)`. */
+        signature: string;
+        /** Base64url user handle — present on discoverable credentials, else null. */
+        userHandle: string | null;
+    };
+    /** Extension outputs. */
+    clientExtensionResults: AuthenticationExtensionsClientOutputs;
+}
+
+/** Capability probes shared by both passkey hooks. */
+export declare interface PasskeyCapabilities {
+    /** WebAuthn exists in this browser. Known synchronously. */
+    supported: boolean;
+    /**
+     * This device has a built-in authenticator. `null` until the async probe
+     * settles — render nothing passkey-related while it is `null`.
+     */
+    platformAvailable: boolean | null;
+    /** Autofill-driven sign-in is available. `null` until the probe settles. */
+    conditionalAvailable: boolean | null;
+}
+
+/** Which ceremony was running, so the message can name it. */
+export declare type PasskeyCeremony = "register" | "authenticate";
+
+/** Framework-free WebAuthn client. Build one with {@link createPasskeyClient}. */
+export declare interface PasskeyClient {
+    /** Run the registration ceremony and return the JSON your backend verifies. */
+    register(options: PasskeyCreationOptionsJSON, init?: PasskeyRegisterInit): Promise<PasskeyRegistrationJSON>;
+    /** Run the authentication ceremony and return the JSON your backend verifies. */
+    authenticate(options: PasskeyRequestOptionsJSON, init?: PasskeyAuthenticateInit): Promise<PasskeyAuthenticationJSON>;
+    /**
+     * Whether this client can run a ceremony at all — the WebAuthn API exists, or a
+     * `credentials` container was injected.
+     */
+    isSupported(): boolean;
+    /** Whether this device has a built-in authenticator (Face ID, Hello, …). */
+    isPlatformAuthenticatorAvailable(): Promise<boolean>;
+    /** Whether autofill-driven (`"conditional"`) requests are available. */
+    isConditionalMediationAvailable(): Promise<boolean>;
+}
+
+/**
+ * Server-issued registration options, in the base64url JSON shape every WebAuthn
+ * backend speaks (`PublicKeyCredentialCreationOptionsJSON` in the spec).
+ *
+ * `challenge`, `user.id` and every `excludeCredentials[].id` are **base64url**
+ * strings here and `ArrayBuffer`s in the DOM API. Converting them is the plumbing
+ * this client owns.
+ */
+export declare interface PasskeyCreationOptionsJSON {
+    /** Base64url server challenge. Single-use; the server must remember it. */
+    challenge: string;
+    /** Relying party. `id` defaults to the client's `rpId`, then to the origin. */
+    rp: {
+        name: string;
+        id?: string;
+    };
+    /** The account. `id` is base64url of an opaque, stable user handle. */
+    user: {
+        id: string;
+        name: string;
+        displayName: string;
+    };
+    /** Allowed COSE algorithms. Defaults to {@link DEFAULT_PUB_KEY_CRED_PARAMS}. */
+    pubKeyCredParams?: {
+        type: "public-key";
+        alg: number;
+    }[];
+    /** Ceremony timeout in ms. Defaults to the client's `timeoutMs`. */
+    timeout?: number;
+    /** Credentials this user already has, so the authenticator refuses a duplicate. */
+    excludeCredentials?: {
+        id: string;
+        type: "public-key";
+        transports?: string[];
+    }[];
+    /** Resident-key / user-verification / attachment requirements. */
+    authenticatorSelection?: AuthenticatorSelectionCriteria;
+    /** Attestation conveyance. Leave unset (`"none"`) unless you verify it. */
+    attestation?: AttestationConveyancePreference;
+    /** Client extension inputs (`credProps`, `largeBlob`, …). */
+    extensions?: AuthenticationExtensionsClientInputs;
+}
+
+/**
+ * A passkey failure carrying a stable {@link PasskeyErrorKind} plus an English
+ * message safe to show a user.
+ *
+ * A class rather than the plain `{ kind, message }` object the media classifier
+ * returns, because these surface by rejecting a promise: an `Error` subclass keeps
+ * stack traces, `instanceof` checks and logging intact, and `kind` is what code
+ * branches on.
+ */
+export declare class PasskeyError extends Error {
+    /** Stable, branchable classification. */
+    readonly kind: PasskeyErrorKind;
+    /**
+     * Build a classified passkey error.
+     *
+     * @param kind - The classification a UI branches on.
+     * @param message - English, user-safe explanation.
+     * @param cause - The original thrown value, when there was one.
+     */
+    constructor(kind: PasskeyErrorKind, message: string, cause?: unknown);
+}
+
+/**
+ * Classified reason a passkey ceremony did not produce a credential.
+ *
+ * The kinds group the raw `DOMException.name` values the way a UI has to branch
+ * on them, which is *not* how the spec groups them:
+ *
+ * - `"cancelled"` covers `NotAllowedError`, which the browser raises both when
+ *   the user dismissed the sheet and when the ceremony timed out. They are
+ *   indistinguishable **by design** — telling a site "the user has no credential
+ *   for you" would leak account existence — so a UI must treat them as one thing.
+ * - `"already-registered"` (`InvalidStateError`) is not really a failure: this
+ *   device already holds a credential for this user. The correct reaction is
+ *   "you are already set up on this device", never a red error.
+ * - `"rp-mismatch"` (`SecurityError`) is the single most common integration bug:
+ *   `rp.id` must equal the page's domain or a registrable parent of it.
+ */
+export declare type PasskeyErrorKind = "unsupported" | "insecure" | "cancelled" | "already-registered" | "not-supported" | "rp-mismatch" | "invalid-options" | "aborted" | "unknown";
+
+/** How the browser should surface the authentication ceremony. */
+export declare type PasskeyMediation = "optional" | "conditional" | "required" | "silent";
+
+/** Per-call knobs for {@link PasskeyClient.register}. */
+export declare interface PasskeyRegisterInit {
+    /** Cancel the ceremony (closes the browser sheet). */
+    signal?: AbortSignal;
+}
+
+/** What the client sends to the backend to finish registration. */
+export declare interface PasskeyRegistrationJSON {
+    /** Base64url credential id. */
+    id: string;
+    /** Same bytes as `id`; both are sent because servers differ on which they read. */
+    rawId: string;
+    type: "public-key";
+    /** `"platform"` (this device) or `"cross-platform"` (a phone or key). */
+    authenticatorAttachment: string | null;
+    response: {
+        /** Base64url client data — the server re-checks challenge, origin and type. */
+        clientDataJSON: string;
+        /** Base64url attestation object, holding the new public key. */
+        attestationObject: string;
+        /** Transports the authenticator advertises, when the browser exposes them. */
+        transports?: string[];
+        /** COSE algorithm of the new key, when the browser exposes it. */
+        publicKeyAlgorithm?: number;
+        /** Base64url SPKI public key, when the browser exposes it. */
+        publicKey?: string;
+        /** Base64url authenticator data, when the browser exposes it. */
+        authenticatorData?: string;
+    };
+    /** Extension outputs — `credProps.rk` tells you whether it is discoverable. */
+    clientExtensionResults: AuthenticationExtensionsClientOutputs;
+}
+
+/** Server-issued authentication options, base64url JSON. */
+export declare interface PasskeyRequestOptionsJSON {
+    /** Base64url server challenge. */
+    challenge: string;
+    /** Relying party id. Defaults to the client's `rpId`, then to the origin. */
+    rpId?: string;
+    /** Ceremony timeout in ms. Defaults to the client's `timeoutMs`. */
+    timeout?: number;
+    /** Restrict to these credentials. **Omit it** for usernameless / autofill flows. */
+    allowCredentials?: {
+        id: string;
+        type: "public-key";
+        transports?: string[];
+    }[];
+    /** Whether the authenticator must verify the user (biometric / PIN). */
+    userVerification?: UserVerificationRequirement;
+    /** Client extension inputs. */
+    extensions?: AuthenticationExtensionsClientInputs;
+}
+
+/**
+ * Where a passkey ceremony is.
+ *
+ * `"prompting"` and `"verifying"` are split because they need different copy:
+ * while prompting, the browser sheet is up and the user must touch a sensor;
+ * while verifying, your backend is checking the signature and the user should
+ * just wait.
+ */
+export declare type PasskeyStatus = "idle" | "prompting" | "verifying" | "success" | "error";
+
 /**
  * Password field with toggle-visibility button and optional strength meter.
  *
@@ -6494,6 +8000,13 @@ export { Path }
  */
 export declare function pathLengthKm(points: readonly Coordinate[]): number;
 
+/** Raw PCM ready to be wrapped in a RIFF container. */
+export declare interface PcmAudio {
+    /** One `Float32Array` per channel, samples in −1…1. */
+    channels: readonly Float32Array[];
+    sampleRate: number;
+}
+
 /**
  * Extract a permission list from a JWT.
  *
@@ -6550,6 +8063,38 @@ export declare const PhoneInput: ForwardRefExoticComponent<Omit<InputProps, "val
  */
 export declare function pick<T extends object, K extends keyof T>(obj: T, keys: K[]): Pick<T, K>;
 
+/**
+ * First container in `preferred` the browser can actually produce, or `null`.
+ *
+ * **There is no MP3 or WAV here, and that is not an omission.** `MediaRecorder`
+ * emits Opus (in WebM or Ogg) on Chromium and Firefox and AAC (in MP4) on Safari —
+ * no engine implements an MP3 or WAV encoder for it. If a backend needs WAV,
+ * {@link blobToWav} converts one client-side with no dependency; if it needs MP3,
+ * transcode on the server. Shipping an MP3 encoder would mean a WASM build of the
+ * order of 150 KB in every consumer's bundle to serve one format, which is the
+ * trade this SDK does not make.
+ *
+ * @param preferred - Candidates, best first. Defaults to {@link AUDIO_MIME_CANDIDATES}.
+ * @returns A supported MIME type, or `null` when none is.
+ */
+export declare function pickAudioMimeType(preferred?: readonly string[]): string | null;
+
+/**
+ * First container in `preferred` the browser can actually produce, or `null`.
+ *
+ * @param preferred - Candidates, best first.
+ * @returns A supported MIME type, or `null` when none is.
+ */
+export declare function pickRecordingMimeType(preferred: readonly string[]): string | null;
+
+/**
+ * First video container in `preferred` the browser can actually produce, or `null`.
+ *
+ * @param preferred - Candidates, best first. Defaults to {@link VIDEO_MIME_CANDIDATES}.
+ * @returns A supported MIME type, or `null` when none is.
+ */
+export declare function pickVideoMimeType(preferred?: readonly string[]): string | null;
+
 /**
  * One-time-password style input — N independent cells, paste support, auto-
  * advance on input, backspace flows back, arrow keys navigate.
@@ -6617,7 +8162,7 @@ export declare interface PlacedEvent {
 }
 
 /**
- * Convenience wrapper around a shared {@link AudioPlayer}. Use this for
+ * Convenience wrapper around a shared {@link AudioPlayerHandle}. Use this for
  * one-off notification sounds. For more complex flows (e.g. several
  * simultaneous channels), build a dedicated player with {@link createAudioPlayer}.
  */
@@ -6632,6 +8177,14 @@ export declare interface PlayAudioOptions {
     autoplay?: boolean;
     /** Stop the previous clip managed by this player. Default: false. */
     stopPrevious?: boolean;
+    /**
+     * Output device to play on, from `useMediaDevices().audioOutputs`.
+     *
+     * Ignored where the browser has no output routing (everything but Chromium) —
+     * the clip still plays, on the system default. Useful for a chime that must land
+     * on a headset while the call audio stays on the speakers.
+     */
+    sinkId?: string;
     /** Fired when playback ends naturally. */
     onEnded?: () => void;
     /** Fired on playback error. */
@@ -6733,6 +8286,23 @@ export declare interface PostHogLike {
     reset?: () => void;
 }
 
+/** A model whose cached size should appear in the report. */
+export declare interface ProfiledModel {
+    /** Label for the report row, e.g. `"detector"`. */
+    name: string;
+    /** Cache Storage bucket holding the response, e.g. `"app-models"`. */
+    cacheName: string;
+    /** Request URL the model was cached under. */
+    url: string;
+}
+
+/** A model's size as found in the cache. */
+export declare interface ProfiledModelSize {
+    name: string;
+    /** Size in bytes, or `null` when uncached or the size is unreported. */
+    bytes: number | null;
+}
+
 /**
  * Linear progress bar with determinate / indeterminate modes.
  *
@@ -7050,6 +8620,22 @@ export declare interface RatingStarsProps {
  */
 export declare function readableForeground(background: string, light?: string, dark?: string): string;
 
+/**
+ * Sample the device capabilities the browser reports.
+ *
+ * Safe to call during SSR: without a `navigator` every field is `null`.
+ *
+ * @returns The profile, with `null` for anything this platform withholds.
+ *
+ * @example
+ * ```typescript
+ * const device = readDeviceProfile();
+ * console.log(device.hardwareConcurrency); // 8
+ * console.log(device.deviceMemoryGb);      // 8 on Chromium, null on Safari
+ * ```
+ */
+export declare function readDeviceProfile(): DeviceProfile;
+
 /**
  * Read a token's computed value from an element (default: `<html>`).
  *
@@ -7320,6 +8906,131 @@ export declare type ResponsiveValue<T> = T | {
     desktop?: T;
 };
 
+/** A resumable upload in progress. Build one with {@link createResumableUpload}. */
+export declare interface ResumableUpload {
+    /**
+     * Create (or re-attach to) the upload and push chunks until it is complete.
+     *
+     * Resolves `null` when the run stopped because of `pause()` or `abort()` —
+     * neither is a failure. Rejects with a `TempestApiError` when the server
+     * refused and the retries ran out.
+     */
+    start(): Promise<ResumableUploadResult | null>;
+    /** Stop after the in-flight chunk is dropped, keeping the resume point. */
+    pause(): void;
+    /** Continue from the server's offset. Same resolution contract as `start`. */
+    resume(): Promise<ResumableUploadResult | null>;
+    /**
+     * Stop for good.
+     *
+     * @param options - `discard: true` also sends `DELETE` (tus termination) and
+     *   forgets the persisted record, so the next `start()` uploads from zero.
+     */
+    abort(options?: {
+        discard?: boolean;
+    }): Promise<void>;
+    /** Current state. */
+    readonly state: ResumableUploadState;
+    /** Bytes the server has confirmed. */
+    readonly offset: number;
+    /** The upload URL, once creation succeeded. */
+    readonly url: string | null;
+    /** The resume key in use. */
+    readonly key: string;
+}
+
+/** Options for {@link createResumableUpload}. */
+export declare interface ResumableUploadOptions {
+    /** tus creation endpoint, e.g. `"/api/uploads"`. */
+    endpoint: string;
+    /** The bytes to upload. A `File` also supplies the default resume key. */
+    file: Blob | File;
+    /** Bytes per `PATCH`. Default {@link DEFAULT_CHUNK_SIZE}. */
+    chunkSize?: number;
+    /** Sent as `Upload-Metadata` (base64-encoded values), e.g. `{ filename }`. */
+    metadata?: Record<string, string>;
+    /** Extra headers on every request. */
+    headers?: Record<string, string>;
+    /** Returns the current bearer token, read before each request. */
+    getToken?: () => string | null | undefined;
+    /** Send cookies. Default `false`. */
+    withCredentials?: boolean;
+    /**
+     * Resume key. Defaults to a fingerprint of endpoint + file name/size/mtime, so
+     * picking the same file after a reload resumes instead of restarting.
+     */
+    key?: string;
+    /**
+     * Where to persist resume state. Defaults to `localStorage`. Pass `null` to
+     * disable persistence — resume then only survives a network blip, not a reload.
+     */
+    storage?: ResumableUploadStorage | null;
+    /** Backoff for a failed chunk. Forwarded to `retry`. Default 5 attempts. */
+    retry?: RetryOptions;
+    /** Called on every upload-progress tick and after every confirmed chunk. */
+    onProgress?: (progress: ResumableUploadProgress) => void;
+    /** Called whenever {@link ResumableUpload.state} changes. */
+    onStateChange?: (state: ResumableUploadState) => void;
+}
+
+/** Byte-level progress for a resumable upload. */
+export declare interface ResumableUploadProgress {
+    /** Bytes the server holds, including anything a resume skipped. */
+    loaded: number;
+    /** Total size of the file. */
+    total: number;
+    /** `loaded / total`, between 0 and 1. */
+    fraction: number;
+    /** Bytes already on the server when this run started. `0` on a fresh upload. */
+    resumedFrom: number;
+}
+
+/** What has to survive a page reload for a resume to be possible. */
+export declare interface ResumableUploadRecord {
+    /** Upload URL the creation POST returned, absolute. */
+    url: string;
+    /** Last offset the server confirmed. */
+    offset: number;
+    /** File size, so a different file under the same key is not resumed into. */
+    size: number;
+    /** Idempotency key of the creation request, reused if creation is retried. */
+    idempotencyKey: string;
+    /** Epoch ms of the last write, so an app can sweep stale records. */
+    updatedAt: number;
+}
+
+/** What a finished upload resolves with. */
+export declare interface ResumableUploadResult {
+    /** The tus upload URL — hand this to your API to link the stored file. */
+    url: string;
+    /** Total bytes uploaded. */
+    size: number;
+}
+
+/**
+ * Where a resumable upload is.
+ *
+ * `"paused"` and `"aborted"` are both "not running", but only `"paused"` keeps the
+ * persisted offset — `abort({ discard: true })` throws it away.
+ */
+export declare type ResumableUploadState = "idle" | "creating" | "uploading" | "paused" | "done" | "error" | "aborted";
+
+/**
+ * Persistence for resume state. Sync or async — both are awaited.
+ *
+ * Implement it over anything: the default is `localStorage`, and
+ * `createOfflineStore` from `@/offline` slots in when you already have a Dexie
+ * database open.
+ */
+export declare interface ResumableUploadStorage {
+    /** Read the record for `key`, or `null`. */
+    get(key: string): Promise<ResumableUploadRecord | null> | ResumableUploadRecord | null;
+    /** Write the record for `key`. */
+    set(key: string, record: ResumableUploadRecord): Promise<void> | void;
+    /** Forget the record for `key`. */
+    delete(key: string): Promise<void> | void;
+}
+
 /**
  * Run `factory()` with exponential backoff. Each attempt awaits an
  * increasing delay capped at `maxDelay`. Throws the last error if every
@@ -7594,6 +9305,9 @@ export declare interface SchedulerProps extends Omit<HTMLAttributes<HTMLDivEleme
     now?: Date;
 }
 
+/** Lifecycle of a screen share. */
+export declare type ScreenCaptureStatus = "idle" | "requesting" | "sharing" | "error";
+
 /**
  * A styled scroll container that overflows on the chosen axis and renders a
  * thin custom scrollbar (WebKit) while staying fully functional in browsers
@@ -7765,6 +9479,29 @@ export declare interface SequentialScaleOptions {
     ordinal?: boolean;
 }
 
+/**
+ * Send an element's audio to a specific output device.
+ *
+ * The `sinkId` comes from `useMediaDevices().audioOutputs` — and, like every device
+ * label, that list is anonymous until a capture permission has been granted, so an
+ * output picker realistically only works after the microphone has been allowed once.
+ *
+ * Returns `false` instead of throwing when the browser has no `setSinkId`, because
+ * "this engine cannot route audio" is the common case and not an error the caller can
+ * act on: the sound still plays, on the system default device. A rejected
+ * `setSinkId` — a device that was unplugged between enumeration and playback is the
+ * usual cause — also resolves `false`, and playback continues on the default.
+ *
+ * @param element - The `<audio>` or `<video>` element to route.
+ * @param sinkId - Device id, or `""` for the system default.
+ * @returns `true` when the route was applied.
+ *
+ * @example
+ * const ok = await setAudioOutput(audioRef.current, selectedSpeakerId);
+ * if (!ok) toast("Este navegador não permite escolher a saída de som.");
+ */
+export declare function setAudioOutput(element: HTMLMediaElement | null, sinkId: string): Promise<boolean>;
+
 /**
  * Wrap the Web Share API with a uniform result object. Falls through to
  * `unsupported: true` when the browser lacks `navigator.share`, leaving the
@@ -8124,6 +9861,69 @@ export declare interface SparklineProps extends Omit<HTMLAttributes<HTMLSpanElem
 
 export declare type SparklineVariant = "line" | "area" | "bar";
 
+/** One reading of what was heard. */
+export declare interface SpeechAlternativeLike {
+    transcript: string;
+    confidence?: number;
+}
+
+/** A classified speech error with a human-readable, English message. */
+export declare interface SpeechError {
+    kind: SpeechErrorKind;
+    message: string;
+}
+
+/** Classified reason recognition stopped or never started. */
+export declare type SpeechErrorKind = "unsupported" | "not-allowed" | "no-speech" | "audio-capture" | "network" | "aborted" | "language-not-supported" | "unknown";
+
+/** The `error` event, reduced to what this hook reads. */
+export declare interface SpeechRecognitionErrorEventLike {
+    error: string;
+    message?: string;
+}
+
+/** The `result` event, reduced to what this hook reads. */
+export declare interface SpeechRecognitionEventLike {
+    /** Index of the first result that changed — everything before it is settled. */
+    resultIndex: number;
+    results: SpeechResultListLike;
+}
+
+/**
+ * The slice of the Web Speech `SpeechRecognition` object this SDK uses.
+ *
+ * Declared here rather than imported: TypeScript's DOM lib ships the *event* types but
+ * not the constructor, because the API is still prefixed in Chromium and absent in
+ * Firefox. Exported so a test — or a consumer wrapping a different engine — can hand in
+ * something else.
+ */
+export declare interface SpeechRecognitionLike {
+    lang: string;
+    continuous: boolean;
+    interimResults: boolean;
+    maxAlternatives: number;
+    start: () => void;
+    stop: () => void;
+    abort: () => void;
+    onresult: ((event: SpeechRecognitionEventLike) => void) | null;
+    onerror: ((event: SpeechRecognitionErrorEventLike) => void) | null;
+    onend: (() => void) | null;
+    onstart: (() => void) | null;
+}
+
+/** One recognised phrase, settled (`isFinal`) or still being revised. */
+export declare interface SpeechResultLike {
+    isFinal: boolean;
+    length: number;
+    [index: number]: SpeechAlternativeLike | undefined;
+}
+
+/** The growing list of phrases in a session. */
+export declare interface SpeechResultListLike {
+    length: number;
+    [index: number]: SpeechResultLike | undefined;
+}
+
 /**
  * Loading spinner with preset sizes (xs..xl). Provide `label` for screen
  * readers, `caption` for a visible message, and `overlay` to center it inside a
@@ -9235,7 +11035,7 @@ export declare interface TransferItem {
     data?: Record<string, unknown>;
 }
 
-export declare interface TransferProps extends Omit<HTMLAttributes<HTMLDivElement>, OverriddenDomProps_6> {
+export declare interface TransferProps extends Omit<HTMLAttributes<HTMLDivElement>, OverriddenDomProps_9> {
     /** The whole catalogue. Both panes are derived from it. */
     items: readonly TransferItem[];
     /** Ids on the target side. Controlled. */
@@ -9393,6 +11193,9 @@ export declare interface TruncateTextProps extends HTMLAttributes<HTMLDivElement
  */
 export declare function turnTime(timestamp: number, locale?: "pt-BR" | "en"): string;
 
+/** The tus protocol version this client speaks. */
+export declare const TUS_VERSION = "1.0.0";
+
 /** Sentence for the typing indicator, or `null` when nobody is typing. */
 export declare function typingLabel(names: readonly string[], locale?: "pt-BR" | "en"): string | null;
 
@@ -9470,6 +11273,20 @@ export declare interface UpdateVariables {
     data: unknown;
 }
 
+/**
+ * A stable-enough identity for a file, used as the default resume key.
+ *
+ * Name + size + last-modified is what the tus reference clients fingerprint on:
+ * it is cheap (hashing the bytes of a 400 MB recording is not) and it changes
+ * whenever the file does, which is the property that matters — resuming into the
+ * wrong file would corrupt it silently.
+ *
+ * @param endpoint - Creation endpoint, so the same file to two servers is two uploads.
+ * @param file - The blob or file being uploaded.
+ * @returns A key safe to use in `localStorage`.
+ */
+export declare function uploadFingerprint(endpoint: string, file: Blob | File): string;
+
 export declare interface UploadProgressEvent {
     /** Bytes already uploaded. */
     loaded: number;
@@ -9561,6 +11378,38 @@ export declare function urlBase64ToUint8Array(base64String: string): Uint8Array<
  */
 export declare function useAccessControl(): AccessControl | null;
 
+/**
+ * Announce transient messages to screen readers through one shared live region
+ * pair.
+ *
+ * Reach for this when something happened that a sighted user can see and a screen
+ * reader user cannot: a filter narrowed a list, a row saved, a copy succeeded, an
+ * upload failed. It is **not** for content that is already on screen inside a
+ * region with a role — a status pill, a toast that renders as `role="status"`,
+ * a form error tied to its input — announcing those again reads them twice.
+ *
+ * !!! warning "Never wrap streaming text in a live region"
+ *     A live region over text that grows token by token makes the reader start the
+ *     whole answer again on every token. Announce the **edges** instead — "gerando
+ *     resposta" and "resposta concluída" — and leave the transcript in a plain
+ *     `role="log"` the user reads at their own pace. `AIChat` does exactly that.
+ *
+ * Mounting the hook creates the regions even before the first message. That is not
+ * tidiness: a live region inserted into the DOM in the same frame as its first
+ * content routinely loses that announcement, because the assistive technology has
+ * to have registered the region before it can notice a change inside it.
+ *
+ * @returns A stable `announce(message, politeness?)` function.
+ *
+ * @example
+ * const announce = useAnnounce();
+ *
+ * function onFilter(rows: Row[]) {
+ *     announce(`${rows.length} resultados`);
+ * }
+ */
+export declare function useAnnounce(): (message: string, politeness?: AnnouncePoliteness) => void;
+
 /**
  * Run an async function and track its `idle/pending/success/error` state.
  *
@@ -9596,11 +11445,73 @@ export declare interface UseAsyncResult<T> {
  * fine and the value is non-null from the first render.
  *
  * Hook-managed audio player. Each component instance gets its own
- * {@link AudioPlayer}, so unmounting cleanly stops playback. Useful for
+ * {@link AudioPlayerHandle}, so unmounting cleanly stops playback. Useful for
  * notification chimes, UI feedback sounds, and per-component soundtracks.
  */
 export declare function useAudio(): UseAudioResult;
 
+/**
+ * Record the given stream, with a clock, a level meter and a state machine.
+ *
+ * Pass the stream from {@link useMicrophone}; the hook stays `ready: false` until
+ * there is one, so a page can render the whole recorder UI before permission is
+ * granted and simply have it disabled.
+ *
+ * The clock and the level are published on an interval (`tickMs`, default 100 ms)
+ * rather than per animation frame. A hook that set state 60 times a second would
+ * re-render everything the recorder is inside; 10 Hz is smooth enough for a timer and
+ * a meter, and the underlying `createLevelMeter` is still available for anyone who
+ * wants a frame-accurate bar written straight to the DOM.
+ *
+ * @param stream - The stream to record, or `null` while permission is pending.
+ * @param options - See {@link UseAudioRecorderOptions}.
+ *
+ * @example
+ * const mic = useMicrophone();
+ * const rec = useAudioRecorder(mic.stream, { maxDurationMs: 120_000 });
+ * <button disabled={!rec.ready} onClick={rec.start}>Gravar</button>
+ */
+export declare function useAudioRecorder(stream: MediaStream | null, options?: UseAudioRecorderOptions): UseAudioRecorderResult;
+
+/** Options for {@link useAudioRecorder}. */
+export declare interface UseAudioRecorderOptions extends AudioRecorderOptions {
+    /**
+     * Stop automatically after this many milliseconds.
+     *
+     * Worth setting on anything user-facing: a recording left running by accident is
+     * a memory buffer that grows until the tab dies.
+     */
+    maxDurationMs?: number;
+    /** Called once the recording is assembled, whether by `stop()` or `maxDurationMs`. */
+    onRecorded?: (recording: AudioRecording) => void;
+    /** How often the clock and the level are published, in ms. Default 100. */
+    tickMs?: number;
+    /** Skip the level meter — it costs an `AudioContext`. Default `false`. */
+    disableLevelMeter?: boolean;
+}
+
+/** Value returned by {@link useAudioRecorder}. */
+export declare interface UseAudioRecorderResult {
+    status: AudioRecorderStatus;
+    /** Recorded length so far, excluding paused time. */
+    durationMs: number;
+    /** Loudness 0–1, or `0` when the meter is off or nothing is recording. */
+    level: number;
+    /** The finished recording, or `null` before the first `stop()`. */
+    recording: AudioRecording | null;
+    /** Recorder-level error (encoder failure, device pulled mid-recording). */
+    error: unknown;
+    /** `false` when there is no stream yet, or the browser cannot record. */
+    ready: boolean;
+    start: () => void;
+    pause: () => void;
+    resume: () => void;
+    /** Stop and resolve with the recording. Also published on `recording`. */
+    stop: () => Promise<AudioRecording | null>;
+    /** Stop and throw the audio away. */
+    cancel: () => void;
+}
+
 export declare interface UseAudioResult {
     /** Play `src` on the hook's private player. */
     play: (src: string, options?: PlayAudioOptions) => Promise<void>;
@@ -9613,6 +11524,105 @@ export declare interface UseAudioResult {
     unlocked: boolean;
 }
 
+/**
+ * Read barcodes and QR codes from the camera.
+ *
+ * The camera and its classified errors come from `useCameraStream`, so this hook is
+ * only the decoding half: it drives a `BarcodeDetector` over the preview on an
+ * interval, suppresses the same value repeating, and exposes the torch.
+ *
+ * **Mounting this opens the camera.** It inherits that from `useCameraStream`, which
+ * acquires on mount — so mount it *after* the user asks to scan (a button that reveals
+ * the scanner), never on a page that merely contains one. A permission prompt nobody
+ * provoked is the most reliable way to earn a permanent block, after which
+ * `getUserMedia` rejects without ever prompting again.
+ *
+ * `supported` deserves a branch in the UI, not an assertion: `BarcodeDetector` is
+ * Chromium-only and missing on Windows/Linux desktop, Firefox and everything on iOS.
+ * Inject a `detector` to cover those, or tell the user to type the code.
+ *
+ * @param options - See {@link UseBarcodeScannerOptions}.
+ * @returns The camera plumbing plus the scan state.
+ *
+ * @example
+ * const scanner = useBarcodeScanner({
+ *     formats: ["ean_13"],
+ *     onScan: ({ rawValue }) => addToCart(rawValue),
+ * });
+ * return <video ref={scanner.videoRef} muted playsInline />;
+ */
+export declare function useBarcodeScanner(options?: UseBarcodeScannerOptions): UseBarcodeScannerResult;
+
+/** Options for {@link useBarcodeScanner}. */
+export declare interface UseBarcodeScannerOptions {
+    /** Symbologies to look for. Defaults to {@link DEFAULT_BARCODE_FORMATS}. */
+    formats?: readonly BarcodeFormat[];
+    /** Called for every accepted read — that is, after repeat suppression. */
+    onScan?: (result: BarcodeScanResult) => void;
+    /**
+     * How often a frame is examined, in ms. Default 200.
+     *
+     * Not `requestAnimationFrame`: decoding is 10–40 ms of main-thread work on a
+     * phone, so running it per frame competes with the preview it is reading from and
+     * makes the video stutter. Five looks per second is faster than a human can aim.
+     */
+    intervalMs?: number;
+    /**
+     * Ignore the **same** value again for this long, in ms. Default 2500.
+     *
+     * A symbol stays in frame for as long as the user holds the camera there, so a
+     * scanner without this fires the same code five times a second — which, wired to
+     * "add item to cart", is a bug the user pays for. A *different* value is never
+     * suppressed.
+     */
+    repeatDelayMs?: number;
+    /** Stop looking without releasing the camera — a confirmation sheet is open. */
+    paused?: boolean;
+    /**
+     * A decoder to use instead of the native one.
+     *
+     * The way to support Safari and Firefox: hand in a polyfill and everything else
+     * here works unchanged. See {@link isBarcodeDetectionSupported} for why the SDK
+     * does not bundle one.
+     */
+    detector?: BarcodeDetectorLike;
+    /** Camera constraints, forwarded to `useCameraStream`. Defaults to the rear camera. */
+    constraints?: MediaStreamConstraints;
+    /**
+     * A frame the engine refused to decode.
+     *
+     * Not "nothing found" — that resolves to an empty list and is the normal case.
+     * This is the engine itself failing, which the loop survives because it is
+     * usually transient (a frame arriving between two resolutions).
+     */
+    onError?: (error: unknown) => void;
+}
+
+/** Value returned by {@link useBarcodeScanner}. */
+export declare interface UseBarcodeScannerResult {
+    /** Attach to a `<video ref={…} muted playsInline />`. */
+    videoRef: RefObject<HTMLVideoElement | null>;
+    /** Camera lifecycle. `"ready"` means the preview is running. */
+    status: CameraStreamStatus;
+    /** Classified camera error, or `null`. */
+    error: CameraStreamError | null;
+    /** `false` when there is no decoder — no native API and none injected. */
+    supported: boolean;
+    /**
+     * Formats actually in use: the requested ones intersected with what the engine
+     * reports. Empty while the probe is in flight, or when nothing matched.
+     */
+    formats: readonly BarcodeFormat[];
+    /** Whether the detect loop is running right now. */
+    scanning: boolean;
+    /** The most recent accepted read, or `null`. */
+    result: BarcodeScanResult | null;
+    /** The LED torch of this camera, when it has one. */
+    torch: UseTorchResult;
+    /** Re-open the camera after an error (the user changed the permission). */
+    retry: () => void;
+}
+
 /**
  * React hook for the PWA install prompt. Captures the `beforeinstallprompt`
  * event so you can defer the install UI to a moment that fits your UX.
@@ -10236,6 +12246,93 @@ export declare interface UseMapResult<K, V> {
 
 export { useMatch }
 
+/**
+ * List capture and playback devices, and keep the list fresh.
+ *
+ * Two things about `enumerateDevices` that decide how a picker must be built:
+ *
+ * 1. **Labels are gated behind permission.** Before the user grants a capture
+ *    permission, every `label` is `""` — the list length and ids are real, the names
+ *    are not. A device picker rendered at that point is a column of blanks, so
+ *    `labelsAvailable` is exposed to gate it. Ask for the microphone first, then
+ *    show the picker.
+ * 2. **The list changes while the page is open.** Plugging in a headset mid-recording
+ *    is the normal case, not an edge case, so the hook subscribes to `devicechange`
+ *    instead of enumerating once on mount.
+ *
+ * `audioOutputs` is empty on browsers with no output routing at all (Safari and
+ * Firefox do not implement `setSinkId`); an empty array there means "you cannot
+ * offer this choice", not "no speakers".
+ *
+ * @returns The device lists, whether labels are filled in, and a `refresh()`.
+ *
+ * @example
+ * const { audioInputs, labelsAvailable } = useMediaDevices();
+ * // ...after the mic permission is granted:
+ * {labelsAvailable && <Select options={audioInputs.map((d) => ({ value: d.deviceId, label: d.label }))} />}
+ */
+export declare function useMediaDevices(): UseMediaDevicesResult;
+
+/** Value returned by {@link useMediaDevices}. */
+export declare interface UseMediaDevicesResult {
+    /** Every device, in the order the browser listed them. */
+    devices: MediaDeviceOption[];
+    /** Microphones and other audio sources. */
+    audioInputs: MediaDeviceOption[];
+    /** Speakers and headsets. Empty on browsers with no output routing (Safari, Firefox). */
+    audioOutputs: MediaDeviceOption[];
+    /** Cameras. */
+    videoInputs: MediaDeviceOption[];
+    /**
+     * Whether labels are filled in.
+     *
+     * `false` means the list is real but anonymous — render a picker only after a
+     * capture permission has been granted, or the user sees "" repeated N times.
+     */
+    labelsAvailable: boolean;
+    /** `enumerateDevices` is unavailable in this browser. */
+    supported: boolean;
+    /** Re-enumerate. The hook already does this on `devicechange`. */
+    refresh: () => void;
+}
+
+/**
+ * Read a capture permission **without triggering the prompt**.
+ *
+ * This is the piece that makes a good permission flow possible. `getUserMedia` is
+ * the only way to *get* a device, but calling it is also the only way to *ask*, and
+ * a prompt fired on page load — before the user has pressed anything — is the
+ * single most reliable way to earn a permanent "Block". Reading the state first
+ * lets a page explain why it needs the microphone, and only then ask.
+ *
+ * It also separates "never asked" from "denied", which matters because they need
+ * opposite UI: `"prompt"` gets a button, `"denied"` gets instructions for the
+ * browser's site settings, since no amount of clicking will re-prompt.
+ *
+ * Safari does not expose `microphone` to the Permissions API and throws on the
+ * query, which surfaces as `state: "unknown"` and `supported: false` — treat that
+ * as "you will have to ask to find out", not as an error.
+ *
+ * @param name - Which permission to observe.
+ * @returns The live state, whether it could be read, and a manual `refresh()`.
+ *
+ * @example
+ * const { state } = useMediaPermission("microphone");
+ * if (state === "denied") return <p>Libere o microfone nas configurações do site.</p>;
+ * return <button onClick={start}>Gravar</button>;
+ */
+export declare function useMediaPermission(name: MediaPermissionName): UseMediaPermissionResult;
+
+/** Value returned by {@link useMediaPermission}. */
+export declare interface UseMediaPermissionResult {
+    /** Current state. Updates live when the user changes it in browser settings. */
+    state: MediaPermissionState;
+    /** Whether the Permissions API could answer at all. */
+    supported: boolean;
+    /** Re-read the permission. Rarely needed — the hook subscribes to changes. */
+    refresh: () => void;
+}
+
 /**
  * Subscribe to a CSS media query and re-render on match changes.
  *
@@ -10244,6 +12341,65 @@ export { useMatch }
  */
 export declare function useMediaQuery(query: string): boolean;
 
+/**
+ * Acquire a microphone `MediaStream`, classified errors included, and release it
+ * properly.
+ *
+ * Releasing matters more than it looks. Every track has to be stopped by hand:
+ * dropping the last reference to a `MediaStream` does **not** turn off the
+ * microphone, so the browser keeps showing its recording indicator and the OS keeps
+ * the device busy — which then makes the *next* `getUserMedia` fail with
+ * `NotReadableError` in another tab. The hook stops tracks on `stop()`, on unmount,
+ * and before re-opening.
+ *
+ * @param options - See {@link UseMicrophoneOptions}.
+ * @returns The stream, its status, a classified error, and `start`/`stop`.
+ *
+ * @example
+ * const mic = useMicrophone();
+ * const recorder = useAudioRecorder(mic.stream);
+ * <button onClick={mic.start}>Liberar microfone</button>
+ */
+export declare function useMicrophone(options?: UseMicrophoneOptions): UseMicrophoneResult;
+
+/** Options for {@link useMicrophone}. */
+export declare interface UseMicrophoneOptions {
+    /**
+     * Open the stream on mount instead of waiting for `start()`. Default `false`.
+     *
+     * Left off on purpose. Opening on mount means prompting on mount, and a
+     * permission prompt the user did not provoke is the most reliable way to earn a
+     * permanent "Block" — after which `getUserMedia` rejects without ever prompting
+     * again. Wire `start()` to the button that needs the microphone.
+     */
+    autoStart?: boolean;
+    /** Specific microphone, from `useMediaDevices().audioInputs`. */
+    deviceId?: string;
+    /**
+     * Browser voice processing. All three default to `true`, which is what speech
+     * wants; turn them off for music, where a gate chewing on a decaying note is
+     * worse than the room noise it removes.
+     */
+    echoCancellation?: boolean;
+    noiseSuppression?: boolean;
+    autoGainControl?: boolean;
+    /** Escape hatch: full constraints, replacing everything above. */
+    constraints?: MediaStreamConstraints;
+}
+
+/** Value returned by {@link useMicrophone}. */
+export declare interface UseMicrophoneResult {
+    status: MicrophoneStatus;
+    /** The live stream, or `null`. Feed it to {@link useAudioRecorder} or an analyser. */
+    stream: MediaStream | null;
+    /** Classified error, or `null` outside the `error` status. */
+    error: MediaAccessError | null;
+    /** Open the stream. Safe to call when already open — it is a no-op. */
+    start: () => void;
+    /** Release the microphone. The browser's recording indicator only clears here. */
+    stop: () => void;
+}
+
 /**
  * Access the imperative modals API. Must be used within a {@link ModalsProvider}.
  *
@@ -10643,6 +12799,142 @@ export declare interface UsePaginationResult {
 
 export { useParams }
 
+/**
+ * Probe what this device can do, once per mount.
+ *
+ * @param client - Client whose probes to call.
+ * @returns The three capability answers, two of them async.
+ */
+export declare function usePasskeyCapabilities(client?: PasskeyClient): PasskeyCapabilities;
+
+/**
+ * Register a passkey: fetch options, run `navigator.credentials.create`, hand the
+ * credential to your backend.
+ *
+ * `register()` **resolves** rather than rejects on failure, because every failure
+ * here is already state the UI has to render (`error.kind`, `status`). Forcing a
+ * `try/catch` around a button handler that also has to set state would only
+ * duplicate what the hook holds.
+ *
+ * @param options - Transport callbacks plus optional client and listeners.
+ * @returns Ceremony state, the `register` action, and the capability probes.
+ *
+ * @example
+ * const passkey = usePasskeyRegistration({
+ *     getOptions: () => api.post("/webauthn/register/begin"),
+ *     verify: (credential) => api.post("/webauthn/register/finish", { body: credential }),
+ * });
+ *
+ * if (passkey.platformAvailable === false) return null;
+ * return (
+ *     <button onClick={() => void passkey.register()} disabled={passkey.status === "prompting"}>
+ *         Criar passkey
+ *     </button>
+ * );
+ */
+export declare function usePasskeyRegistration<TResult = unknown>(options: UsePasskeyRegistrationOptions<TResult>): UsePasskeyRegistrationResult<TResult>;
+
+/** Options for {@link usePasskeyRegistration}. */
+export declare interface UsePasskeyRegistrationOptions<TResult> {
+    /** Fetch server options — your `POST /webauthn/register/begin`. */
+    getOptions: () => Promise<PasskeyCreationOptionsJSON>;
+    /** Send the credential to be verified — your `POST /webauthn/register/finish`. */
+    verify: (credential: PasskeyRegistrationJSON) => Promise<TResult>;
+    /** Client to use. Defaults to a shared `createPasskeyClient()`. */
+    client?: PasskeyClient;
+    /** Called with whatever `verify` resolved to. */
+    onSuccess?: (result: TResult) => void;
+    /** Called with the classified failure. */
+    onError?: (error: PasskeyError) => void;
+}
+
+/** Value returned by {@link usePasskeyRegistration}. */
+export declare interface UsePasskeyRegistrationResult<TResult> extends PasskeyCapabilities {
+    /** Run the ceremony. Resolves `null` on failure — read `error` for the reason. */
+    register: () => Promise<TResult | null>;
+    /** Current phase. */
+    status: PasskeyStatus;
+    /** Last failure, cleared when a new attempt starts. */
+    error: PasskeyError | null;
+    /** Whatever `verify` resolved to, on success. */
+    data: TResult | null;
+    /** Close the browser sheet from your own UI. */
+    cancel: () => void;
+    /** Back to `"idle"`, clearing `error` and `data`. */
+    reset: () => void;
+}
+
+/**
+ * Sign in with a passkey, with or without the autofill flow.
+ *
+ * Two ways in, and a good login page wires both. `signIn()` is the explicit
+ * button. `conditional: true` arms the pleasant one: the browser lists the user's
+ * passkeys inside the username field itself, so signing in is one tap and no
+ * password was ever typed. The field must carry
+ * `autocomplete="username webauthn"` or the list never appears — the hook cannot
+ * do that part for you.
+ *
+ * A conditional request that is aborted (unmount, or the user typing a password
+ * instead) is **not** surfaced as an error: nothing failed, the user chose
+ * another door.
+ *
+ * @param options - Transport callbacks, `conditional`, optional client and listeners.
+ * @returns Ceremony state, the `signIn` action, and the capability probes.
+ *
+ * @example
+ * const passkey = usePasskeySignIn({
+ *     conditional: true,
+ *     getOptions: () => api.post("/webauthn/signin/begin"),
+ *     verify: (assertion) => api.post("/webauthn/signin/finish", { body: assertion }),
+ *     onSuccess: (session) => auth.setToken(session.access_token),
+ * });
+ *
+ * <input name="email" autoComplete="username webauthn" />
+ * <button onClick={() => void passkey.signIn()}>Entrar com passkey</button>
+ */
+export declare function usePasskeySignIn<TResult = unknown>(options: UsePasskeySignInOptions<TResult>): UsePasskeySignInResult<TResult>;
+
+/** Options for {@link usePasskeySignIn}. */
+export declare interface UsePasskeySignInOptions<TResult> {
+    /** Fetch server options — your `POST /webauthn/signin/begin`. */
+    getOptions: () => Promise<PasskeyRequestOptionsJSON>;
+    /** Send the assertion to be verified — your `POST /webauthn/signin/finish`. */
+    verify: (assertion: PasskeyAuthenticationJSON) => Promise<TResult>;
+    /** Client to use. Defaults to a shared `createPasskeyClient()`. */
+    client?: PasskeyClient;
+    /**
+     * Arm the autofill flow on mount (`mediation: "conditional"`).
+     *
+     * The request stays pending, invisibly, until the user picks a passkey from
+     * the browser's autofill list — so the field it should appear on needs
+     * `autocomplete="username webauthn"`. Only one conditional request may be live
+     * per page, and it is aborted on unmount.
+     */
+    conditional?: boolean;
+    /** Called with whatever `verify` resolved to. */
+    onSuccess?: (result: TResult) => void;
+    /** Called with the classified failure. */
+    onError?: (error: PasskeyError) => void;
+}
+
+/** Value returned by {@link usePasskeySignIn}. */
+export declare interface UsePasskeySignInResult<TResult> extends PasskeyCapabilities {
+    /** Run the modal ceremony. Resolves `null` on failure. */
+    signIn: () => Promise<TResult | null>;
+    /** Current phase. */
+    status: PasskeyStatus;
+    /** Last failure, cleared when a new attempt starts. */
+    error: PasskeyError | null;
+    /** Whatever `verify` resolved to, on success. */
+    data: TResult | null;
+    /** True while an armed conditional (autofill) request is waiting. */
+    conditionalPending: boolean;
+    /** Close the browser sheet from your own UI. */
+    cancel: () => void;
+    /** Back to `"idle"`, clearing `error` and `data`. */
+    reset: () => void;
+}
+
 /**
  * Poll an async factory on a fixed interval. Skips overlapping requests if a
  * prior call has not finished. Pause via `disabled` or `stopWhen`.
@@ -10795,6 +13087,102 @@ export declare function useResizeObserver(ref: RefObject<Element | null>): Eleme
 
 export { useRouteError }
 
+/**
+ * Capture a screen, a window or a tab with `getDisplayMedia`.
+ *
+ * Three states decide whether this feels right, and two of them are easy to miss:
+ *
+ * - **The user dismissed the picker.** A rejection, but not a failure. It leaves
+ *   `error` at `null` and the status back at `"idle"`, and calls `onCancelled`.
+ * - **The user stopped the share from the browser's own bar.** Nothing in your UI was
+ *   clicked and no promise rejects — the *only* signal is the video track's `ended`
+ *   event, so the hook listens for it and clears the stream. Without that listener, an
+ *   app shows "gravando" over a stream that is already dead.
+ * - **The share is live.** `surface` says what was picked and `hasAudio` says whether
+ *   audio actually came along, which is not what you asked for but what you got.
+ *
+ * The stream is owned here: `stop()` and unmount both release every track. A recorder
+ * built on it (`useVideoRecorder`) deliberately does not, so stopping a recording
+ * leaves the share running for the next take.
+ *
+ * @param options - See {@link UseScreenCaptureOptions}.
+ * @returns The stream, its status, a classified error and `start`/`stop`.
+ *
+ * @example
+ * const screen = useScreenCapture({ preferCurrentTab: true, onEnded: () => save() });
+ * const rec = useVideoRecorder(screen.stream);
+ * <button onClick={screen.start}>Compartilhar tela</button>
+ */
+export declare function useScreenCapture(options?: UseScreenCaptureOptions): UseScreenCaptureResult;
+
+/** Options for {@link useScreenCapture}. */
+export declare interface UseScreenCaptureOptions {
+    /**
+     * Capture the tab's audio too. Default `false`.
+     *
+     * Chromium only offers this for a **tab** — sharing a window or a whole screen
+     * yields no audio track no matter what you ask for, and Safari has no display
+     * audio at all. Ask for it and check what you got.
+     */
+    audio?: boolean;
+    /**
+     * Which surface the picker should offer first — `"browser"` is a tab.
+     *
+     * A hint, never a guarantee: the user can always pick something else, and Firefox
+     * ignores it. Read `surface` afterwards to learn what actually happened.
+     */
+    displaySurface?: DisplaySurfaceHint;
+    /**
+     * Put *this* tab at the top of the picker. Default `false`.
+     *
+     * The right setting for "record what you are seeing right now" in a support flow.
+     * Chromium only.
+     */
+    preferCurrentTab?: boolean;
+    /** Offer this tab in the list at all. `"exclude"` prevents the hall-of-mirrors capture. */
+    selfBrowserSurface?: "include" | "exclude";
+    /** Let the user switch to a different surface mid-share, without a new prompt. */
+    surfaceSwitching?: "include" | "exclude";
+    /** Include the system audio when a whole screen is shared. Chromium, Windows only. */
+    systemAudio?: "include" | "exclude";
+    /** Escape hatch: full options, replacing everything above. */
+    options?: DisplayMediaStreamOptions;
+    /**
+     * The user stopped the share from the browser's own bar.
+     *
+     * The single most important callback here — see the note on
+     * {@link useScreenCapture}.
+     */
+    onEnded?: () => void;
+    /**
+     * The user dismissed the picker. **Not an error.**
+     *
+     * Receives the rejection so an app that needs to tell a dismissal from an OS-level
+     * block (macOS screen-recording permission) can look at the message. Most should
+     * simply return the UI to its previous state.
+     */
+    onCancelled?: (reason: unknown) => void;
+}
+
+/** Value returned by {@link useScreenCapture}. */
+export declare interface UseScreenCaptureResult {
+    status: ScreenCaptureStatus;
+    /** The live stream, or `null`. Feed it to {@link useVideoRecorder} or a `<video>`. */
+    stream: MediaStream | null;
+    /** Classified error, or `null`. A cancelled picker leaves this `null`. */
+    error: MediaAccessError | null;
+    /** What the user actually picked, when the browser reports it. */
+    surface: string | null;
+    /** Whether the stream carries an audio track — ask, do not assume. */
+    hasAudio: boolean;
+    /** `false` when `getDisplayMedia` is missing (every browser on iOS, insecure pages). */
+    supported: boolean;
+    /** Open the picker. Must be called from a user gesture. */
+    start: () => void;
+    /** Stop sharing from the app side. Fires nothing — you asked for it. */
+    stop: () => void;
+}
+
 /**
  * Lock `<body>` scroll while `active` is true. Restores the previous overflow
  * value on unmount. Safe to nest: stacks the restoration via a counter.
@@ -11013,6 +13401,96 @@ export declare interface UseSortableResult {
     setContainer: (node: HTMLElement | null) => void;
 }
 
+/**
+ * Dictate into your app with the Web Speech API — no dependency, no API key.
+ *
+ * ## Recognition is not local
+ *
+ * **Chromium streams the captured audio to a Google server to transcribe it.** Nothing
+ * about the API says so, there is no setting that changes it, and it happens on every
+ * `start()`. Anything the user says while a session is open leaves the device. Do not
+ * put this on a field that takes clinical notes, credentials, or a client's financial
+ * detail without telling them first — and if the data cannot leave your infrastructure,
+ * this API is the wrong tool and a self-hosted model is the right one.
+ *
+ * ## What the states mean
+ *
+ * `transcript` accumulates the phrases the engine has **settled** on; `interim` is the
+ * guess it is still revising and is replaced wholesale on every event, so rendering
+ * `transcript + interim` gives the live caption effect and rendering `transcript` alone
+ * gives the committed text. `no-speech` and `aborted` come through `onError` but are
+ * routine — a user who pressed the button and said nothing is not a failure to report.
+ *
+ * There is deliberately **no auto-restart** when the engine ends a session on silence.
+ * A restart loop is how an app ends up holding the microphone indefinitely — and, in
+ * Chromium, streaming audio to a third party indefinitely. Show that listening stopped
+ * and let the user press again.
+ *
+ * @param options - See {@link UseSpeechRecognitionOptions}.
+ * @returns Session state, the transcript and the controls.
+ *
+ * @example
+ * const speech = useSpeechRecognition({ onFinal: (text) => setPrompt(text) });
+ * <button onClick={speech.listening ? speech.stop : speech.start}>
+ *     {speech.listening ? "Parar" : "Ditar"}
+ * </button>
+ * <p>{speech.transcript}{speech.interim}</p>
+ */
+export declare function useSpeechRecognition(options?: UseSpeechRecognitionOptions): UseSpeechRecognitionResult;
+
+/** Options for {@link useSpeechRecognition}. */
+export declare interface UseSpeechRecognitionOptions {
+    /** BCP-47 tag. Default `"pt-BR"`. */
+    lang?: string;
+    /**
+     * Keep listening after the first phrase settles. Default `false`.
+     *
+     * Even with this on, the engine ends the session by itself after a stretch of
+     * silence — that is a server-side timeout, not a bug — so watch `listening` rather
+     * than assuming the microphone stays open.
+     */
+    continuous?: boolean;
+    /** Publish the running guess as it changes. Default `true`. */
+    interimResults?: boolean;
+    /** How many readings per phrase to ask for. Default 1. */
+    maxAlternatives?: number;
+    /** Every update, settled or not. */
+    onResult?: (result: {
+        transcript: string;
+        isFinal: boolean;
+    }) => void;
+    /** Only the settled text of a phrase. The one to wire dictation to. */
+    onFinal?: (transcript: string) => void;
+    /** Classified failure. `no-speech` and `aborted` arrive here too — they are routine. */
+    onError?: (error: SpeechError) => void;
+    /** The session ended, for any reason. */
+    onEnd?: () => void;
+    /** Build the recogniser yourself — another engine, or a stub in a test. */
+    factory?: () => SpeechRecognitionLike;
+}
+
+/** Value returned by {@link useSpeechRecognition}. */
+export declare interface UseSpeechRecognitionResult {
+    /** `false` in Firefox and in every browser that is not Chromium-based. */
+    supported: boolean;
+    /** Whether a session is open right now. */
+    listening: boolean;
+    /** Everything settled so far in this session. Cleared by `reset()`. */
+    transcript: string;
+    /** The running guess. Replaced on every event, empty once the phrase settles. */
+    interim: string;
+    /** Classified error, or `null`. */
+    error: SpeechError | null;
+    /** Open a session. No-op while already listening. */
+    start: () => void;
+    /** Close the session, keeping what was recognised. */
+    stop: () => void;
+    /** Close the session and throw the pending phrase away. */
+    abort: () => void;
+    /** Clear `transcript`, `interim` and `error`. Does not stop a session. */
+    reset: () => void;
+}
+
 /**
  * Returns a stable function reference that always invokes the latest
  * `callback` argument. Use to break dependency cycles in effects without
@@ -11116,6 +13594,49 @@ export declare function useToast(): ToastApi;
  */
 export declare function useToggle(initial?: boolean): [boolean, ToggleHelpers];
 
+/**
+ * Drive the camera's LED torch on the video track of a stream.
+ *
+ * The lamp is not a device you can open — it is a **constraint on a live video
+ * track**, so there is nothing to control until a camera stream exists, and it
+ * disappears when that stream is released. That is also why `supported` can only be
+ * answered after the track is live: the same code is `true` on an Android rear camera
+ * and `false` on the front one of the same phone.
+ *
+ * Capability detection prefers `getCapabilities()` and falls back to
+ * `getSettings()`, because Firefox implements neither the torch nor
+ * `getCapabilities()` and Safari reports the setting without the capability. When
+ * neither mentions `torch`, the hook reports `supported: false` instead of offering a
+ * button that silently does nothing.
+ *
+ * @param stream - A live camera stream, or `null` before permission lands.
+ * @returns Whether a lamp exists, its state, and setters.
+ *
+ * @example
+ * const camera = useBarcodeScanner();
+ * {camera.torch.supported && (
+ *     <button onClick={() => void camera.torch.toggle()}>Lanterna</button>
+ * )}
+ */
+export declare function useTorch(stream: MediaStream | null): UseTorchResult;
+
+/** Value returned by {@link useTorch}. */
+export declare interface UseTorchResult {
+    /** Whether this track has a controllable lamp. `false` on every desktop webcam. */
+    supported: boolean;
+    /** Whether the lamp is on, as far as this hook knows. */
+    on: boolean;
+    /**
+     * Turn the lamp on or off.
+     *
+     * @param next - `true` to light it up.
+     * @returns `false` when the track refused — treat that as "no torch".
+     */
+    set: (next: boolean) => Promise<boolean>;
+    /** Flip it. Same return contract as {@link UseTorchResult.set}. */
+    toggle: () => Promise<boolean>;
+}
+
 /**
  * Shortcut for components that only need the `t` function — avoids destructuring.
  */
@@ -11149,6 +13670,70 @@ export declare interface UseViaCEPResult {
     reset: () => void;
 }
 
+/**
+ * Record a video stream — from {@link useScreenCapture}, from a camera, or from a
+ * canvas.
+ *
+ * Pass the stream in; the hook stays `ready: false` until there is one, so a page can
+ * render the whole recorder UI before the user has picked a screen and simply have it
+ * disabled.
+ *
+ * There is no level meter here, which is the one real difference from
+ * `useAudioRecorder`: metering a screen share means opening an `AudioContext` on a
+ * stream that usually has no audio track at all, and browsers cap the number of live
+ * contexts. If you are recording a camera **and** want a level, run
+ * `createLevelMeter` on the same stream yourself.
+ *
+ * The clock is published every `tickMs` (default 250 ms) rather than per frame: a
+ * video recording UI shows `0:07`, and a hook that re-rendered its parent 60 times a
+ * second to move a one-second counter would be the most expensive thing on the page.
+ *
+ * @param stream - The stream to record, or `null` while the picker is open.
+ * @param options - See {@link UseVideoRecorderOptions}.
+ *
+ * @example
+ * const screen = useScreenCapture();
+ * const rec = useVideoRecorder(screen.stream, { maxDurationMs: 120_000 });
+ * <button disabled={!rec.ready} onClick={rec.start}>Gravar tela</button>
+ */
+export declare function useVideoRecorder(stream: MediaStream | null, options?: UseVideoRecorderOptions): UseVideoRecorderResult;
+
+/** Options for {@link useVideoRecorder}. */
+export declare interface UseVideoRecorderOptions extends VideoRecorderOptions {
+    /**
+     * Stop automatically after this many milliseconds.
+     *
+     * Worth setting on anything user-facing, and more so than for audio: a minute of
+     * 1080p at 2.5 Mbps is roughly 19 MB, so a recording left running by accident
+     * fills memory an order of magnitude faster than a voice note does.
+     */
+    maxDurationMs?: number;
+    /** Called once the recording is assembled, whether by `stop()` or `maxDurationMs`. */
+    onRecorded?: (recording: VideoRecording) => void;
+    /** How often the clock is published, in ms. Default 250. */
+    tickMs?: number;
+}
+
+/** Value returned by {@link useVideoRecorder}. */
+export declare interface UseVideoRecorderResult {
+    status: MediaRecorderStatus;
+    /** Recorded length so far, excluding paused time. */
+    durationMs: number;
+    /** The finished recording, or `null` before the first `stop()`. */
+    recording: VideoRecording | null;
+    /** Recorder-level error (encoder failure, share revoked mid-recording). */
+    error: unknown;
+    /** `false` when there is no stream yet, or the browser cannot record video. */
+    ready: boolean;
+    start: () => void;
+    pause: () => void;
+    resume: () => void;
+    /** Stop and resolve with the recording. Also published on `recording`. */
+    stop: () => Promise<VideoRecording | null>;
+    /** Stop and throw the video away. */
+    cancel: () => void;
+}
+
 export { useWatch }
 
 /**
@@ -11266,6 +13851,70 @@ export declare interface ViaCEPResult {
     siafi?: string;
 }
 
+/**
+ * Container/codec candidates for video, best first.
+ *
+ * VP9 in WebM leads because it is the best quality per byte that Chromium and Firefox
+ * both encode natively; VP8 is the fallback for older Chromium and for hardware that
+ * refuses VP9. `video/mp4` is last and exists for Safari, which produces H.264 in MP4
+ * and nothing else — and only since Safari 14.1.
+ *
+ * Every candidate carries **Opus or AAC audio in the same container**, because a
+ * screen recording with the tab's audio dropped is a support ticket, not a
+ * simplification. On a stream with no audio track the browser simply omits it.
+ *
+ * Ported from the intersection of what `MediaRecorder.isTypeSupported` accepts in
+ * Chrome 120+, Firefox 115+ and Safari 17. Re-check against
+ * <https://developer.mozilla.org/docs/Web/API/MediaRecorder/isTypeSupported> before
+ * adding to the list.
+ */
+export declare const VIDEO_MIME_CANDIDATES: readonly string[];
+
+/** Imperative video recorder. Same shape as the audio one. */
+export declare type VideoRecorderHandle = MediaRecorderHandle;
+
+/** Options for {@link createVideoRecorder}. */
+export declare interface VideoRecorderOptions {
+    /**
+     * Force a container. Throws when the browser cannot produce it.
+     *
+     * Leave it out. The default negotiates from {@link VIDEO_MIME_CANDIDATES}, which
+     * is the only way one call site works on both Chromium and Safari.
+     */
+    mimeType?: string;
+    /**
+     * Target video bitrate.
+     *
+     * The browser's default is conservative and a screen recording of text at
+     * 1080p looks smeared under it. 2_500_000 is a good floor for a UI capture,
+     * 8_000_000 for full-motion camera video.
+     */
+    videoBitsPerSecond?: number;
+    /** Target audio bitrate, when the stream carries audio. 64000–128000 is plenty. */
+    audioBitsPerSecond?: number;
+    /**
+     * Emit a chunk every N ms through `onChunk`, for streaming upload.
+     *
+     * Worth setting for video far sooner than for audio: a minute of 1080p at
+     * 2.5 Mbps is roughly 19 MB sitting in memory.
+     */
+    timesliceMs?: number;
+    /** Receives each chunk when `timesliceMs` is set. Chunks are **not** independently playable. */
+    onChunk?: (chunk: Blob) => void;
+    /** Recorder-level failure (screen share revoked mid-recording, encoder error). */
+    onError?: (error: unknown) => void;
+}
+
+/**
+ * A finished video recording.
+ *
+ * Structurally the same three fields as an audio one — there is nothing
+ * video-specific to add, and inventing a `width`/`height` here would be a lie: the
+ * browser negotiates the frame size with the device and can change it mid-recording.
+ * Read it from the track's `getSettings()` if you need it.
+ */
+export declare type VideoRecording = MediaRecording;
+
 /**
  * Fixed-height virtual list. Renders only the visible window plus a small
  * overscan buffer. Suitable for lists of thousands of identical rows.
@@ -11709,6 +14358,24 @@ export declare interface WatermarkStore {
     clear: () => void;
 }
 
+/** Options for {@link blobToWav}. */
+export declare interface WavOptions {
+    /**
+     * Mix down to one channel. Default `false`.
+     *
+     * Worth turning on for speech headed to a server: a microphone recorded in stereo
+     * carries two nearly identical channels and doubles the upload for nothing.
+     */
+    mono?: boolean;
+    /**
+     * Resample to this rate. Default: keep the source rate.
+     *
+     * 16000 is the rate most speech-to-text APIs want, and dropping 48 kHz to 16 kHz
+     * removes two thirds of the bytes with no audible loss on voice.
+     */
+    sampleRate?: number;
+}
+
 /**
  * Browser-side Web Push helper. Wraps `Notification.requestPermission`,
  * `pushManager.subscribe`, and the corresponding teardown. Transport is up to