tempest-react-sdk 0.52.0 → 0.54.0

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

@@ -539,10 +539,41 @@ export declare function announce(message: string, politeness?: AnnouncePolitenes
  */
 export declare type AnnouncePoliteness = "polite" | "assertive";
 
+/**
+ * Any React component, whatever props it declares.
+ *
+ * Props sit in a *parameter* position, so a bound over them is contravariant:
+ * `ComponentType<unknown>` reads as "a component that accepts every possible
+ * props object", and only a component that declares no props at all satisfies
+ * it. A page typed `({ mode }: Props) => …` is rejected, and so is one whose
+ * props are entirely optional. `any` is the only bound that admits every
+ * component — which is why React itself declares `lazy` and
+ * `LazyExoticComponent` as `ComponentType<any>`. `ComponentType<never>` is not
+ * an escape: it fails React's own bound through
+ * `ComponentClass.getDerivedStateFromProps`, where the props land back in a
+ * covariant position.
+ *
+ * This relaxes the *bound* only. `T` is still inferred as the concrete
+ * component, so the rendered element keeps checking its props and `preload()`
+ * still resolves to the concrete module.
+ */
+declare type AnyComponent = ComponentType<any>;
+
 declare type AnyEventTarget = EventTarget | {
     current: EventTarget | null;
 } | null | undefined;
 
+/**
+ * Any page component a route can point at, whatever props it declares.
+ *
+ * Same contravariance as `lazyWithRetry`, which this field is handed to:
+ * `ComponentType<unknown>` means "accepts every possible props object", so a
+ * route module default-exporting `({ id }: Props) => …` would not assign here —
+ * and neither would one whose props are all optional. React declares its own
+ * `lazy` as `ComponentType<any>` for the same reason.
+ */
+declare type AnyRouteComponent = ComponentType<any>;
+
 /**
  * Translation key the {@link useDescribeApiError} hook looks up.
  *
@@ -717,13 +748,21 @@ export declare interface ApiError {
     retryAfter?: number;
     /**
      * Field-level messages from a validation response, keyed by the field path
-     * the backend named (`"email"`, `"items.0.price"`).
+     * the backend named (`"email"`, `"items.0.price"`, `"phone"`).
+     *
+     * Present whenever the body named a field, through either shape a Tempest
+     * stack sends:
+     *
+     * - FastAPI's validation list — `detail: [{ loc, msg, type }]`, one entry per
+     *   field, each keyed by its `loc` path.
+     * - The singular keys a `tempest-fastapi-sdk` backend uses once it owns the
+     *   handler — `detail.field`, then top-level `field`, then `details.field`, in
+     *   that order. There the single value is the same sentence as `detail`.
      *
-     * Present only when the body carried a validation list — a FastAPI `422`
-     * answers with `detail: [{ loc, msg, type }]`. This is the shape a form
-     * needs: `detail` is one line for a log or a developer, and pulling the
-     * fields back out of it means parsing prose. The first message wins when a
-     * field appears twice, because a field shows one error at a time.
+     * This is the shape a form needs: `detail` is one line for a log or a
+     * developer, and pulling the fields back out of it means parsing prose. The
+     * first message wins when a field appears twice, because a field shows one
+     * error at a time.
      */
     fields?: Record<string, string>;
     /** The raw parsed error body, when available. */
@@ -959,7 +998,12 @@ export declare interface AppRouterProps {
     basename?: string;
     /** Initial URLs for the `"memory"` router (tests / non-DOM hosts). */
     initialEntries?: string[];
-    /** Suspense fallback shown while a `lazy` route chunk loads. */
+    /**
+     * Suspense fallback shown while a `lazy` route chunk loads, and the default
+     * for a route whose `guard` answers `"pending"` — one spinner covers both
+     * kinds of "not ready yet". A route overrides it with its own
+     * `guardFallback`.
+     */
     fallback?: ReactNode;
 }
 
@@ -1059,6 +1103,88 @@ export declare type AsyncStatus = "idle" | "pending" | "success" | "error";
  */
 export declare const AUDIO_MIME_CANDIDATES: readonly string[];
 
+/** A running mix. */
+export declare interface AudioBus {
+    /**
+     * Play a stream through the shared mix.
+     *
+     * @param stream - The stream to play. Only its first audio track is used.
+     * @param options - `gain` is the initial multiplier, default `1`.
+     * @returns A handle to adjust or detach this source.
+     */
+    attach: (stream: MediaStream, options?: {
+        gain?: number;
+    }) => AudioBusHandle;
+    /** Scale every source, on top of its own gain. */
+    setMasterGain: (gain: number) => void;
+    /** Current master gain, after clamping. */
+    readonly masterGain: number;
+    /**
+     * Route the whole mix to one output device.
+     *
+     * @param deviceId - Device id from `useMediaDevices().audioOutputs`, or `""`
+     *   for the system default.
+     * @returns `false` when the engine cannot route audio, or the device is gone.
+     */
+    setOutputDevice: (deviceId: string) => Promise<boolean>;
+    /** Device id the mix is routed to. `""` is the system default. */
+    readonly outputDevice: string;
+    /**
+     * Resume a context the browser started suspended.
+     *
+     * Autoplay policy suspends a context created outside a user gesture, and a
+     * suspended context is silent with no error anywhere. Call this from the
+     * click that starts playback.
+     */
+    resume: () => Promise<void>;
+    /**
+     * Detach everything and close the context this bus created.
+     *
+     * Idempotent, and the bus stays callable afterwards: `attach` hands back an
+     * inert handle instead of throwing. That is not politeness — creating a node
+     * on a closed `AudioContext` throws `InvalidStateError`, and the stream that
+     * arrives late is the normal case (a WebRTC `ontrack` firing after the
+     * component that owned the bus went away).
+     */
+    close: () => void;
+    /** Whether this browser gave us a Web Audio graph at all. */
+    readonly supported: boolean;
+    /** Whether this browser can route the mix to a chosen output device. */
+    readonly canSelectOutput: boolean;
+}
+
+/** One source attached to the bus. */
+export declare interface AudioBusHandle {
+    /**
+     * Set this source's gain, where `1` is the level it arrived at.
+     *
+     * Values above `1` are the point of the whole graph: `element.volume` is
+     * clamped at `1`, so a quiet talker could only ever be attenuated — the one
+     * correction nobody needs.
+     */
+    setGain: (gain: number) => void;
+    /** Current gain, after clamping. */
+    readonly gain: number;
+    /** Detach this source and release its nodes. The bus stays up. */
+    stop: () => void;
+}
+
+/** Options for {@link createAudioBus}. */
+export declare interface AudioBusOptions {
+    /** Ceiling for every gain on this bus. Default {@link DEFAULT_MAX_GAIN}. */
+    maxGain?: number;
+    /** Override the master limiter, or pass `false` to run without one. */
+    limiter?: Partial<LimiterSettings> | false;
+    /**
+     * Reuse an existing `AudioContext` instead of creating one.
+     *
+     * Browsers cap the number of live contexts (Chrome allows around six), so a
+     * page that already has one — a level meter, a player — should hand it over
+     * rather than open a second.
+     */
+    context?: AudioContext;
+}
+
 /**
  * Playback transport for one clip: play/pause, a seek bar, elapsed and total time.
  *
@@ -2048,8 +2174,8 @@ 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
- * pending, nothing is rendered.
+ * action is allowed and `fallback` when it is denied. While an async check is
+ * pending it renders `pending`, which defaults to `fallback`.
  *
  * @example
  * ```tsx
@@ -2057,8 +2183,20 @@ declare type CameraStreamStatus = "idle" | "loading" | "ready" | "error";
  *   <NewPostButton />
  * </Can>
  * ```
+ *
+ * @example
+ * ```tsx
+ * <Can
+ *   action="read"
+ *   resource="finance"
+ *   fallback={<p>No access</p>}
+ *   pending={<Spinner />}
+ * >
+ *   <FinancePanel />
+ * </Can>
+ * ```
  */
-export declare function Can({ action, resource, params, children, fallback }: CanProps): JSX.Element;
+export declare function Can({ action, resource, params, children, fallback, pending }: CanProps): JSX.Element;
 
 /**
  * Arguments describing the access check to perform.
@@ -2077,6 +2215,16 @@ export declare interface CanProps extends CanParams {
     children: ReactNode;
     /** Rendered when the action is denied. Defaults to nothing. */
     fallback?: ReactNode;
+    /**
+     * Rendered while an async check is still in flight. Defaults to
+     * {@link fallback}, which keeps the pre-existing behaviour.
+     *
+     * Worth setting whenever `fallback` says something denial-shaped: without
+     * it, a permission that resolves over the network flashes "no access" to
+     * someone who has it. `pending={null}` renders nothing until the answer
+     * lands; `pending={<Spinner />}` says why the screen is waiting.
+     */
+    pending?: ReactNode;
 }
 
 /**
@@ -2910,6 +3058,34 @@ export declare const CPFInput: ForwardRefExoticComponent<Omit<InputProps, "value
  */
 export declare function createApiClient(config: ApiClientConfig): ApiClient;
 
+/**
+ * Mix several streams into one output, with gain above 100% and a master limiter.
+ *
+ * Three things make this a graph instead of a few `<audio>` elements:
+ *
+ * 1. **`element.volume` is clamped at `1`.** A participant who speaks too quietly
+ *    can only be turned *down* — the one correction nobody needs. A `GainNode`
+ *    has no ceiling, so this bus takes one (`maxGain`, default 3).
+ * 2. **Clipping is a property of the sum.** Three sources at 200% each are clean
+ *    alone and distort the instant they play together. A per-source limiter
+ *    cannot see that; the one after the mix can, which is where this puts it.
+ * 3. **`setSinkId` lives on the element, not on the context.** Sending the mix to
+ *    a headset while the rest of the system keeps the speakers is only reachable
+ *    by leaving through a `MediaStreamAudioDestinationNode` into a real
+ *    `<audio>`. `AudioContext.setSinkId` has far thinner support.
+ *
+ * @param options - See {@link AudioBusOptions}.
+ * @returns The bus. On an engine with no Web Audio it is inert but callable, and
+ *   `supported` is `false` — a page without sound beats a page that throws.
+ *
+ * @example
+ * const bus = createAudioBus({ maxGain: 3 });
+ * const handle = bus.attach(remoteStream, { gain: 1 });
+ * handle.setGain(2.4);              // above 1 — the point of the whole thing
+ * await bus.setOutputDevice(headsetId);
+ */
+export declare function createAudioBus({ maxGain, limiter: limiterOptions, context: injectedContext, }?: AudioBusOptions): AudioBus;
+
 /**
  * Create an isolated audio player that tracks a single "current" clip.
  * Multiple players coexist independently; use this when several layers of UI
@@ -3045,6 +3221,16 @@ export declare interface CreateEventStreamOptions<T> {
     maxBackoff?: number;
     /** Parse `event.data`. Defaults to JSON with raw-string fallback. */
     parser?: (raw: string) => T;
+    /**
+     * A frame arrived that is not valid JSON, and no `parser` was supplied.
+     *
+     * Registering this drops the frame instead of delivering it: the previous
+     * behaviour handed `onMessage` the raw `string` announced as your message
+     * type, so the failure surfaced later, at the first property access, with
+     * nothing left pointing at the parse. Leave it out and that behaviour is
+     * kept, with a one-time warning in development builds.
+     */
+    onParseError?: (error: unknown, raw: string) => void;
     onOpen?: () => void;
     onMessage?: (message: EventStreamMessage<T>) => void;
     onError?: (error: Event) => void;
@@ -3255,7 +3441,35 @@ export declare interface CreateLaunchDarklyFeatureFlagsAdapterOptions {
  * 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;
+export declare function createLevelMeter(stream: MediaStream, { fftSize, decay, context: injectedContext }?: LevelMeterOptions): LevelMeter;
+
+/**
+ * Track one link's throughput, resolution and round trip across samples.
+ *
+ * Every rate here is a **delta**. `bytesSent` is cumulative since the connection
+ * opened, so dividing it by the session length gives the historical average —
+ * a number that only ever falls and never shows what is happening now. The
+ * previous reading is kept on the sampler and subtracted, which is the part
+ * every hand-rolled copy of this ends up rewriting.
+ *
+ * Bytes are summed across every matching sender, because a peer publishing a
+ * camera and a screen at once occupies one uplink with both — and the uplink is
+ * what runs out. Resolution and frame rate come from the **largest** stream by
+ * area, which is the one that dominates that bandwidth and the one somebody
+ * watching the call is looking at.
+ *
+ * @param options - See {@link LinkStatsSamplerOptions}.
+ * @returns A sampler. Use one per `RTCPeerConnection`.
+ *
+ * @example
+ * const sampler = createLinkStatsSampler();
+ *
+ * setInterval(async () => {
+ *   const stats = await sampler.sample(pc);
+ *   badge.textContent = `${stats.kbps} kbps · ${stats.rttMs ?? "—"} ms`;
+ * }, 2000);
+ */
+export declare function createLinkStatsSampler(options?: LinkStatsSamplerOptions): LinkStatsSampler;
 
 /**
  * `localStorage`-backed resume storage — the default.
@@ -4015,12 +4229,64 @@ export declare interface CreateThemeOptions {
 export declare function createVideoRecorder(stream: MediaStream, options?: VideoRecorderOptions): VideoRecorderHandle;
 
 /**
- * Open a WebSocket with automatic exponential-backoff reconnect, optional
- * heartbeat pings, and typed JSON parsing.
+ * Build the processing a microphone is published through.
+ *
+ * Ordered the way a console is: cut what is not speech, gate what is left, level
+ * it, shape it, set how loud it goes out, then hold a ceiling. **The order is not
+ * cosmetic.** Gating before the high-pass lets a rumble hold the gate open;
+ * compressing before the gate lifts the noise floor up to meet the threshold; and
+ * a limiter placed before the output gain is a ceiling the gain then walks
+ * straight through.
+ *
+ * This sits *after* the browser's own echo cancellation and noise suppression,
+ * which stay on: the two solve different problems. The browser's is trained on
+ * stationary noise inside the capture pipeline; this cuts what it leaves behind
+ * and decides when the line should be silent at all.
+ *
+ * @param source - The captured microphone track.
+ * @param settings - Which stages to build. Default {@link DEFAULT_VOICE_CHAIN}.
+ * @param options - See {@link VoiceChainOptions}.
+ * @returns The track to publish plus its teardown. On an engine with no Web Audio,
+ *   and when every stage is off, the source track is handed back untouched and
+ *   `supported` is `false` — a call without processing beats a call that throws.
+ *   The idle case is decided **before** a context is opened, because browsers cap
+ *   how many can be live and one built for a chain that does nothing still counts.
+ *
+ * @example
+ * const floor = await measureNoiseFloor(stream);
+ * const chain = createVoiceChain(micTrack, {
+ *     ...DEFAULT_VOICE_CHAIN,
+ *     gate: true,
+ *     gateThreshold: suggestGateThreshold(floor),
+ * }, { gain: 1.4 });
+ * await mesh.setLocalTrack("mic", chain.track);
+ */
+export declare function createVoiceChain(source: MediaStreamTrack, settings?: VoiceChainSettings, { gain, context: injectedContext, ownsSource }?: VoiceChainOptions): VoiceChain;
+
+/**
+ * Open a WebSocket that survives a bad network: exponential backoff with jitter,
+ * a handshake timeout, a silence watchdog, optional heartbeat pings and typed
+ * JSON parsing.
+ *
+ * Three failure modes are covered that an event-driven retry loop misses on its
+ * own, because none of them fire an event: a handshake that hangs instead of
+ * failing, an open socket whose link died mid-flight, and a device with its
+ * radio off burning the retry budget. See `handshakeTimeout`, `silenceTimeout`
+ * and `waitForOnline`.
  *
  * @param url - Full ws:// or wss:// URL.
  * @param options - Connection configuration and callbacks.
- * @returns Controller exposing `send`, `close`, `reconnect`, and `status`.
+ * @returns Controller exposing `send`, `close`, `reconnect`, `setSilenceTimeout`,
+ *   `opened` and `status`.
+ *
+ * @example
+ * const socket = createWebSocket(url, {
+ *   silenceTimeout: 75_000,
+ *   onReconnecting: (n, total) => setBanner(`Reconectando ${n}/${total}…`),
+ *   onReconnected: () => refetchEverything(),
+ *   onLost: (reason) => setBanner(reason === "rejected" ? "Acesso negado" : "Sem conexão"),
+ * });
+ * await socket.opened;
  */
 export declare function createWebSocket<T = unknown>(url: string, options?: CreateWebSocketOptions<T>): WebSocketController;
 
@@ -4033,6 +4299,50 @@ export declare interface CreateWebSocketOptions<T> {
     initialBackoff?: number;
     /** Maximum backoff (ms). Default: 30000. */
     maxBackoff?: number;
+    /**
+     * Fraction of each backoff delay added at random, 0–1. Default: 0.3.
+     *
+     * Matters when the *server* is what went down: every client retries on the
+     * same schedule, so the box comes back up into a synchronized stampede. Pass
+     * `0` for a fixed schedule.
+     */
+    jitter?: number;
+    /**
+     * How long one handshake may stay in `CONNECTING` before the attempt is
+     * abandoned and retried (ms). Default: 8000. Pass 0 to disable.
+     *
+     * A `WebSocket` that cannot reach its server does not necessarily fail: it
+     * sits in `CONNECTING` firing neither `open` nor `close` nor `error`. A retry
+     * chain built only on those events stops on its first hung attempt and never
+     * moves again — and hung, rather than refused, is precisely how a bad mobile
+     * link behaves, which is the case reconnection exists for.
+     */
+    handshakeTimeout?: number;
+    /**
+     * Silence tolerated on an open socket before the link is treated as dead (ms).
+     * Default: 0 (off).
+     *
+     * The socket only reports a connection that closes cleanly. A link that dies
+     * mid-flight leaves `readyState` at `OPEN` on this side with nothing ever
+     * arriving again, so silence is the only symptom available. The timer is
+     * re-armed by **any** inbound frame, not just by pings — traffic is traffic.
+     *
+     * Set it to a comfortable multiple of the server's ping interval (2.5× is a
+     * good default) so one dropped ping is not mistaken for an outage. When the
+     * server announces its own interval in the handshake, feed that back with
+     * {@link WebSocketController.setSilenceTimeout} instead of hard-coding the
+     * value on both ends.
+     */
+    silenceTimeout?: number;
+    /**
+     * Suspend the retry schedule while `navigator.onLine` is false, and resume on
+     * the `online` event. Default: true.
+     *
+     * Burning retries against a radio that is switched off is how a phone
+     * exhausts its budget inside a tunnel and gives up exactly when it comes out
+     * the other side.
+     */
+    waitForOnline?: boolean;
     /**
      * Ping interval (ms). When set, the client sends `pingPayload` periodically
      * to keep the socket alive. Default: 0 (disabled).
@@ -4068,11 +4378,49 @@ export declare interface CreateWebSocketOptions<T> {
     maxQueuedMessages?: number;
     /** Parse incoming frames. Default: JSON with raw-string fallback. */
     parser?: (raw: string) => T;
+    /**
+     * A frame arrived that is not valid JSON, and no `parser` was supplied.
+     *
+     * Registering this drops the frame instead of delivering it: the previous
+     * behaviour handed `onMessage` the raw `string` announced as your message
+     * type, so the failure surfaced later, at the first property access, with
+     * nothing left pointing at the parse. Leave it out and that behaviour is
+     * kept, with a one-time warning in development builds.
+     */
+    onParseError?: (error: unknown, raw: string) => void;
     onOpen?: (event: Event) => void;
     onMessage?: (message: WebSocketMessage<T>) => void;
     onClose?: (event: CloseEvent) => void;
     onError?: (event: Event) => void;
     onStatusChange?: (status: WebSocketStatus) => void;
+    /**
+     * A retry has been scheduled. `attempt` is 1-based, `total` is `maxRetries`.
+     *
+     * Reconnecting is not an error and reads badly as one: announcing every
+     * attempt puts a fresh "the connection dropped" in front of someone whose
+     * session is in the middle of coming back on its own. Show a quiet
+     * reconnecting state here and treat {@link CreateWebSocketOptions.onLost} as
+     * the failure.
+     */
+    onReconnecting?: (attempt: number, total: number) => void;
+    /**
+     * The socket is back up after at least one retry.
+     *
+     * Nothing is resumed for you: a server that keys state by connection sees a
+     * brand-new client, so this is where the caller re-subscribes, re-joins or
+     * refetches whatever the gap invalidated.
+     */
+    onReconnected?: () => void;
+    /**
+     * No further attempt will be made — `"rejected"` when the server refused the
+     * client outright (close code 4400–4499, minus the 4408 heartbeat timeout),
+     * `"exhausted"` when the schedule ran out.
+     *
+     * This is the one that deserves UI, because it is the only state the caller
+     * can act on: offer a "try again" that calls
+     * {@link WebSocketController.reconnect}.
+     */
+    onLost?: (reason: WebSocketLostReason) => void;
 }
 
 /**
@@ -4700,6 +5048,9 @@ export declare const DEFAULT_CHUNK_SIZE: number;
  */
 export declare const DEFAULT_CIRCUITY_FACTOR = 1.3;
 
+/** Default ceiling for a per-source or master gain, as a multiplier. */
+export declare const DEFAULT_MAX_GAIN = 3;
+
 /**
  * Per-mode multipliers applied to the car duration. Mirrors
  * `DEFAULT_MODE_DURATION_FACTORS` from `tempest-fastapi-sdk` — motorcycles are
@@ -4722,6 +5073,19 @@ export declare const DEFAULT_PUB_KEY_CRED_PARAMS: {
     alg: number;
 }[];
 
+/** The key a caller gets when it does not choose one. */
+export declare const DEFAULT_PUSH_TO_TALK_KEY = "Space";
+
+/**
+ * What a call wants before anybody touches a slider.
+ *
+ * High-pass, leveller and limiter only. Gate, presence, hiss cut and de-esser are
+ * off because each has an audible cost when it is not needed — a gate set for the
+ * wrong room clips words, presence on a bright microphone is harsh, and a de-esser
+ * on a voice that does not hiss just dulls it.
+ */
+export declare const DEFAULT_VOICE_CHAIN: VoiceChainSettings;
+
 /**
  * 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.
@@ -4750,12 +5114,20 @@ export declare function defineRoutes(routes: TempestRouteObject[]): TempestRoute
  *    offline sentence. This is the step apps skip, and skipping it renders
  *    "erro 0" or a raw `TypeError` at the user.
  * 2. A validation rejection — `error.fields` is set — produces the validation
- *    sentence, **not** `detail`. On a `422` the `detail` line is assembled from
- *    the backend's field paths and the validator's own wording
+ *    sentence, **not** `detail`. On a FastAPI `422` the `detail` line is assembled
+ *    from the backend's field paths and the validator's own wording
  *    (`"items.0.price: Input should be greater than 0"`), which is right for a
  *    log and wrong for a person: it is half English in a pt-BR screen and it
  *    names internals. The per-field messages stay on `fields`, where a form can
  *    attach them to the inputs that failed.
+ *
+ *    This step also catches a business error that named a single field, whose
+ *    `detail` **was** a finished sentence ("Cidade não encontrada para o estado
+ *    informado."). The trade is deliberate: that sentence is now on `fields`,
+ *    against the input it is about, which is where it does the most good. Three
+ *    ways back, in order of preference: `codes: { VALIDATION_ERROR: "…" }` (step 0,
+ *    which still wins), `validation: error.detail` at the call site, or reading
+ *    `error.detail` yourself — it is untouched.
  * 3. The backend's own `detail`, which is the most specific thing available and
  *    is already written for a person — unless `useDetail: false` says that text
  *    is for developers.
@@ -5002,11 +5374,21 @@ export declare interface DrawerProps {
 }
 
 /**
- * Dropdown menu — list of selectable actions anchored to a trigger.
+ * Dropdown menu — a list of actions anchored to a trigger, following the
+ * [APG menu button pattern](https://www.w3.org/WAI/ARIA/apg/patterns/menu-button/).
+ *
+ * `role="menu"` is a promise about the keyboard, and this component keeps it:
  *
- * - Toggle on trigger click.
- * - Close on outside click / Escape / item selection.
- * - Arrow keys navigate, Enter activates focused item.
+ * - `Enter`, `Space` or `ArrowDown` on the trigger opens and focuses the first
+ *   entry; `ArrowUp` opens and focuses the last.
+ * - `ArrowUp` / `ArrowDown` move with wrap, `Home` / `End` jump to the ends.
+ * - `Escape` closes and returns focus to the trigger, so the next `Tab` continues
+ *   from where the user was rather than from the top of the document.
+ * - `Tab` closes the menu and lets the page's own tab order take over.
+ * - Focus is managed: entries carry `tabIndex={-1}` and only the active one is
+ *   `0`, which is what stops `Tab` from walking the menu one entry at a time.
+ *
+ * Disabled entries, separators and labels are skipped by every movement.
  */
 export declare function DropdownMenu({ trigger, items, placement, className, }: DropdownMenuProps): JSX.Element;
 
@@ -5018,6 +5400,23 @@ export declare type DropdownMenuEntry = {
     danger?: boolean;
     disabled?: boolean;
     onSelect: () => void;
+} | {
+    /**
+     * An entry that carries on/off state.
+     *
+     * Rendered as `role="menuitemcheckbox"` with `aria-checked`, which is how
+     * a screen reader announces "checked" instead of leaving the state
+     * invisible. Selecting it does **not** close the menu: toggling two
+     * settings in a row is the ordinary case, and closing after the first
+     * would make the second a second trip.
+     */
+    type: "checkbox";
+    id: string;
+    label: ReactNode;
+    icon?: ReactNode;
+    checked: boolean;
+    disabled?: boolean;
+    onSelect: () => void;
 } | {
     type: "separator";
     id: string;
@@ -5032,6 +5431,7 @@ export declare type DropdownMenuPlacement = "bottom-start" | "bottom-end" | "top
 export declare interface DropdownMenuProps {
     trigger: ReactElement<{
         onClick?: (e: React.MouseEvent) => void;
+        onKeyDown?: (e: KeyboardEvent_2) => void;
         "aria-expanded"?: boolean;
         "aria-controls"?: string;
         "aria-haspopup"?: boolean | "menu";
@@ -5281,11 +5681,6 @@ export declare interface EventStreamMessage<T> {
     raw: MessageEvent;
 }
 
-/**
- * @tempest-limits function-lines — the body is the SSE line protocol — accumulate
- * `data:` lines until a blank line, track `id:` for Last-Event-ID, honour `retry:` —
- * plus the reconnect that uses the id it just tracked.
- */
 export declare type EventStreamStatus = "idle" | "connecting" | "open" | "closed" | "error";
 
 /**
@@ -5760,6 +6155,38 @@ export declare function formatDateForInput(value: string | Date): string;
  */
 export declare function formatDateTime(value: string | Date): string;
 
+/**
+ * Format an ISO date or Date instance as `yyyy-MM-ddTHH:mm`, the value an
+ * `<input type="datetime-local">` accepts.
+ *
+ * The sibling of {@link formatDateForInput}, and it exists for the same reason:
+ * `toISOString().slice(0, 16)` is the reflex and it is wrong. `toISOString`
+ * converts to UTC first, so a 22:00 appointment in UTC-3 opens the form on the
+ * next day at 01:00 — here the trap costs the hour as well as the date.
+ *
+ * A value already in `yyyy-MM-ddTHH:mm` is returned untouched. A value carrying
+ * a zone (`...Z`, `...-03:00`) deliberately does **not** take that shortcut: it
+ * is a different instant from the naive string that looks like it, so it is
+ * converted to the local calendar parts the input has to show.
+ *
+ * Seconds are dropped. A `datetime-local` steps by the minute unless the app
+ * sets `step`, so a `:ss` the field cannot represent would be silently discarded
+ * on the first edit anyway — truncating here keeps the rendered value and the
+ * submitted value the same.
+ *
+ * @example
+ * <input
+ *     type="datetime-local"
+ *     defaultValue={formatDateTimeForInput(appointment.startsAt)}
+ * />
+ *
+ * @param value - ISO string or Date.
+ * @returns The `yyyy-MM-ddTHH:mm` value, or an empty string when the input is
+ *   invalid — which is what a datetime input reads as "no value", unlike
+ *   `"Invalid Date"`.
+ */
+export declare function formatDateTimeForInput(value: string | Date): string;
+
 /**
  * Rendering helpers for the numbers a profiler produces.
  */
@@ -5831,25 +6258,6 @@ export declare interface FormatPhoneOptions {
     mobile?: boolean;
 }
 
-/**
- * Glue between `react-hook-form` `Controller` and the SDK's controlled
- * components. Wraps any control that accepts `{ value, onChange, label,
- * error }` and routes RHF state into it — eliminating the per-field
- * `<Controller render={...} />` boilerplate.
- *
- * @example
- * const form = useZodForm(schema);
- * <FormProvider {...form}>
- *     <Form>
- *         <FormField name="email" label="Email" required>
- *             <Input type="email" />
- *         </FormField>
- *         <FormField name="cep" label="CEP">
- *             <CEPInput />
- *         </FormField>
- *     </Form>
- * </FormProvider>;
- */
 export declare function FormField<TValues extends FieldValues = FieldValues, TName extends FieldPath<TValues> = FieldPath<TValues>>({ name, label, helperText, required, control, children }: FormFieldProps<TValues, TName>): JSX.Element;
 
 export declare interface FormFieldChildProps {
@@ -6165,6 +6573,17 @@ export { HashRouter }
  */
 export declare function haversineKm(origin: Coordinate, destination: Coordinate): number;
 
+/**
+ * Heartbeat timeout, which sits inside the rejection range but is not one.
+ *
+ * `tempest-fastapi-sdk` closes with 4408 when no `pong` arrived within
+ * `WS_HEARTBEAT_TIMEOUT_SECONDS`. That is the *link* failing, not the server
+ * refusing the peer — exactly the case reconnection exists for. Treating the
+ * whole 4400–4499 range as fatal, which is the obvious reading, makes one
+ * missed pong permanent.
+ */
+export declare const HEARTBEAT_CLOSE_CODE = 4408;
+
 /** Convert a hex color to OKLCH. */
 export declare function hexToOklch(hex: string): Oklch;
 
@@ -6806,6 +7225,23 @@ export declare function isDefined<T>(value: T | null | undefined): value is T;
  */
 export declare function isEmpty(value: unknown): boolean;
 
+/**
+ * Whether this environment can present anything fullscreen at all.
+ *
+ * Two independent reasons for `false`, and skipping either one ships a button
+ * that does nothing when pressed: the API can be missing (older WebKit, and every
+ * browser on iOS for non-`<video>` elements), or present and **disabled** — a
+ * document inside an `<iframe>` without the `allowfullscreen` attribute exposes
+ * `requestFullscreen` and rejects every call to it, which `fullscreenEnabled`
+ * reports up front.
+ *
+ * An engine that exposes the methods and no flag at all is treated as capable:
+ * the flag is the newer half of the API, so its absence says nothing.
+ *
+ * @returns `true` when a fullscreen request stands a chance of being honoured.
+ */
+export declare function isFullscreenSupported(): boolean;
+
 /** Whether any turn in the thread is still streaming. */
 export declare function isGenerating(messages: readonly AIChatMessage[]): boolean;
 
@@ -6895,6 +7331,18 @@ export declare function isPlatformAuthenticatorAvailable(): Promise<boolean>;
  */
 export declare function isPushSupported(): boolean;
 
+/**
+ * Whether a close code means the server refused this client for good.
+ *
+ * @param code - The `CloseEvent.code`.
+ * @returns `true` when reconnecting can only reproduce the refusal.
+ *
+ * @example
+ * isRejectionCloseCode(4401); // true — unauthorized
+ * isRejectionCloseCode(4408); // false — heartbeat timeout, retry it
+ */
+export declare function isRejectionCloseCode(code: number): boolean;
+
 /**
  * Whether an HTTP status describes a condition a replay can plausibly fix.
  *
@@ -6956,6 +7404,20 @@ export declare function isValidLongitude(value: number): boolean;
 /** Whether `MediaRecorder` exists and can produce at least one video container. */
 export declare function isVideoRecordingSupported(): boolean;
 
+/**
+ * Whether any of this would change the signal.
+ *
+ * A chain that only passes audio through still costs a re-encode and a handful of
+ * nodes, so a caller that rebuilds on every settings change should ask first —
+ * and {@link createVoiceChain} asks too, handing back `source` rather than
+ * building a graph that does nothing.
+ *
+ * @param settings - The stages under consideration.
+ * @param gain - The output multiplier that would be applied. Default `1`.
+ * @returns `true` when the chain would be audibly transparent.
+ */
+export declare function isVoiceChainIdle(settings: VoiceChainSettings, gain?: number): boolean;
+
 /** The surface every store built by {@link createJsonStorage} exposes. */
 export declare interface JsonStorage {
     /**
@@ -7189,13 +7651,22 @@ declare interface LayoutProps {
  * up the new bundle; a final `location.reload()` recovers from stale
  * `index.html`.
  *
+ * The wrapped component keeps its own props: `T` is inferred from the module
+ * the factory resolves to, so a page declaring required, optional or no props
+ * all pass through and the rendered element is still checked against them. See
+ * {@link AnyComponent} for why the constraint has to be written the way it is.
+ *
+ * @param factory Dynamic import of the module whose `default` is the component.
+ * @param options Retry count, initial backoff and the final-failure reload.
+ * @returns The lazy component, carrying an extra `preload()`.
+ *
  * @example
  * const Settings = lazyWithRetry(() => import("./Settings"));
  *
  * // Warm the chunk when the route becomes likely, not when it is needed.
  * <a href="/settings" onMouseEnter={() => void Settings.preload()}>Settings</a>
  */
-export declare function lazyWithRetry<T extends ComponentType<unknown>>(factory: () => Promise<{
+export declare function lazyWithRetry<T extends AnyComponent>(factory: () => Promise<{
     default: T;
 }>, options?: LazyWithRetryOptions): PreloadableLazy<T>;
 
@@ -7243,8 +7714,21 @@ export declare interface LevelMeterOptions {
      * 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.
+     *
+     * `0` turns the smoothing off and reports the window's RMS as measured, which is
+     * what a detector wants: {@link monitorVoiceActivity} applies its own release,
+     * and two of them stacked would hold the indicator open long past the speech.
      */
     decay?: number;
+    /**
+     * Reuse an existing `AudioContext` instead of creating one.
+     *
+     * Browsers cap live contexts (Chrome allows around six), and a meter per remote
+     * participant reaches that in a five-person call. A caller measuring several
+     * streams should open one context and hand it to every meter. `stop()` closes
+     * only a context this meter created — an injected one belongs to the caller.
+     */
+    context?: AudioContext;
 }
 
 /**
@@ -7308,8 +7792,94 @@ export declare interface LightboxProps {
     className?: string;
 }
 
+/** Shape of the master limiter. Matches `DynamicsCompressorNode`'s params. */
+export declare interface LimiterSettings {
+    /** dBFS above which the compressor starts working. */
+    threshold: number;
+    /** dB range over which the curve bends. `0` is a hard knee. */
+    knee: number;
+    /** Input/output ratio above the threshold. 20 is limiting, not compression. */
+    ratio: number;
+    /** Seconds to clamp a peak. */
+    attack: number;
+    /** Seconds to let go. */
+    release: number;
+}
+
 export { Link }
 
+/**
+ * One link's outbound picture, in the shape a call UI actually renders.
+ *
+ * Everything here is derived, not reported: WebRTC hands out cumulative
+ * counters and a graph of candidate pairs, and turning that into
+ * `"1,2 Mbps · 42 ms · 1080p60"` is the work {@link createLinkStatsSampler}
+ * does.
+ */
+export declare interface LinkStats {
+    /** Throughput since the previous sample. `0` on the first one — there is no delta yet. */
+    kbps: number;
+    /** Width of the largest stream being sent, or `0` before one is reported. */
+    width: number;
+    /** Height of the largest stream being sent, or `0` before one is reported. */
+    height: number;
+    /** Frame rate of the largest stream being sent, or `0` when the browser omits it. */
+    fps: number;
+    /** Round trip to the peer in milliseconds, or `null` before the first reading. */
+    rttMs: number | null;
+}
+
+/** Which media a sampler counts. */
+export declare type LinkStatsKind = "video" | "audio" | "all";
+
+/**
+ * A sampler bound to one connection.
+ *
+ * Holds the previous byte counter and timestamp, which is the whole reason this
+ * is an object rather than a function: the rate is a delta, so somebody has to
+ * remember the last reading. One sampler per link — sharing one across peers
+ * subtracts one connection's counter from another's and reports nonsense.
+ */
+export declare interface LinkStatsSampler {
+    /**
+     * Reduce a report you already have.
+     *
+     * @param report - A report from `RTCPeerConnection.getStats()`.
+     * @returns The stats for this sample.
+     */
+    read: (report: RTCStatsReport) => LinkStats;
+    /**
+     * Fetch a report and reduce it.
+     *
+     * @param connection - The connection to sample.
+     * @returns The stats for this sample.
+     */
+    sample: (connection: RTCPeerConnection) => Promise<LinkStats>;
+    /**
+     * Drop the baseline the rate is derived from.
+     *
+     * Call it after an ICE restart, a reconnect, or a pause — otherwise the next
+     * sample divides the bytes of the whole gap by the whole gap and reports the
+     * average of a period nobody is asking about. The next reading comes back at
+     * `0` kbps and starts a fresh baseline; the resolution and round trip already
+     * on screen are kept, so the badge does not blank out.
+     */
+    reset: () => void;
+}
+
+/** Options for {@link createLinkStatsSampler}. */
+export declare interface LinkStatsSamplerOptions {
+    /**
+     * Which media the throughput counts. Default `"video"`.
+     *
+     * Video is the default because it is what saturates an uplink — audio is an
+     * order of magnitude cheaper, and mixing it in moves the number by less than
+     * the noise between two samples. Use `"all"` when the figure is meant to be
+     * the connection's real cost rather than the picture's.
+     */
+    kind?: LinkStatsKind;
+}
+
 export declare interface ListOptions<TItem> {
     /** Property to order by. Default: `keyPath`. */
     orderBy?: keyof TItem & string;
@@ -7580,6 +8150,29 @@ export declare interface MasonryProps<T> extends Omit<HTMLAttributes<HTMLDivElem
  */
 export declare function matrixToPath(matrix: QRMatrix, margin?: number): string;
 
+/**
+ * Listen to a room at rest and report how loud its silence is.
+ *
+ * The number a person cannot guess. Setting a gate by ear means switching it on
+ * and hearing what disappeared, which only works if you already know what should
+ * have disappeared — so the usual outcome is leaving it at a default that is
+ * wrong for that room. Measuring replaces the guess.
+ *
+ * The result is the **peak** RMS window observed, not the average: a threshold
+ * under the loudest thing the quiet room did will be opened by that thing.
+ *
+ * @param stream - A live capture of the room while nobody speaks.
+ * @param options - See {@link NoiseFloorOptions}.
+ * @returns The peak RMS observed, `0..1`. `0` when this engine has no Web Audio
+ *   or the stream carries no audio track — which {@link suggestGateThreshold}
+ *   turns into its own floor rather than into a gate that never opens.
+ *
+ * @example
+ * const floor = await measureNoiseFloor(stream, { onProgress: setProgress });
+ * setThreshold(suggestGateThreshold(floor));
+ */
+export declare function measureNoiseFloor(stream: MediaStream, { onProgress, durationMs, context: injectedContext, }?: NoiseFloorOptions): Promise<number>;
+
 /** A classified capture error with a human-readable, English message. */
 export declare interface MediaAccessError {
     kind: MediaAccessErrorKind;
@@ -7876,6 +8469,56 @@ export declare interface MoneyProps extends HTMLAttributes<HTMLSpanElement> {
     locale?: string;
 }
 
+/**
+ * Report when a track is carrying speech.
+ *
+ * Runs entirely on the **receiving** side, over a track the connection already
+ * delivers, and that is the whole point: a speaking indicator changes several
+ * times per second, so signalling it through a server floods the room with
+ * messages carrying information every client can derive for free.
+ *
+ * Two details separate this from a threshold on a level meter:
+ *
+ * 1. **The release.** RMS drops to nothing in the gaps between words, so a bare
+ *    comparison strobes on every syllable. The state only falls after
+ *    `releaseMs` of quiet.
+ * 2. **`onChange` fires on the flip, not on the sample.** A callback per poll
+ *    would re-render a participant list ten times a second to say the same thing.
+ *
+ * The meter underneath runs with smoothing off: its eased decay plus this release
+ * would hold the indicator open long after the speech stopped.
+ *
+ * @param stream - The stream whose first audio track is measured.
+ * @param onChange - Called only when the speaking state actually flips.
+ * @param options - See {@link VoiceActivityOptions}.
+ * @returns A handle carrying the current state and the teardown.
+ *
+ * @example
+ * const vad = monitorVoiceActivity(remoteStream, (speaking) => setSpeaking(speaking));
+ * // later
+ * vad.stop();
+ */
+export declare function monitorVoiceActivity(stream: MediaStream, onChange: (speaking: boolean) => void, { threshold, releaseMs, pollMs, context, }?: VoiceActivityOptions): VoiceActivityMonitor;
+
+/**
+ * Play your own processed microphone back to you.
+ *
+ * The only way to hear what these filters do without a second person on the call.
+ * Every number the chain is tuned by — how deep the de-esser cuts, where the gate
+ * sits, how much presence is too much — is a judgement made by ear, and without
+ * this the only available ear belongs to somebody else.
+ *
+ * **Feedback is the hazard, and the reason this is a held, explicit action rather
+ * than a setting:** without headphones the speakers feed the microphone that feeds
+ * the speakers. Say so in the UI that offers it.
+ *
+ * @param source - The raw captured track to listen to. It is never stopped here.
+ * @param settings - The stages to hear it through. Default {@link DEFAULT_VOICE_CHAIN}.
+ * @param options - See {@link VoiceChainOptions}; `ownsSource` is forced to `false`.
+ * @returns A handle that stops the monitor.
+ */
+export declare function monitorVoiceChain(source: MediaStreamTrack, settings?: VoiceChainSettings, options?: Omit<VoiceChainOptions, "ownsSource">): VoiceMonitor;
+
 /** Reorder helper: move `from` to `to`, returning a new array. */
 export declare function moveItem<T>(items: T[], from: number, to: number): T[];
 
@@ -8044,6 +8687,16 @@ export declare interface NavigationRailProps extends Omit<HTMLAttributes<HTMLEle
 
 export { NavLink }
 
+/** Options for {@link measureNoiseFloor}. */
+export declare interface NoiseFloorOptions {
+    /** Called with `0..1` so a dialog can show the wait. */
+    onProgress?: (fraction: number) => void;
+    /** How long to listen. Default `3000`. */
+    durationMs?: number;
+    /** Reuse an existing `AudioContext` rather than opening one. */
+    context?: AudioContext;
+}
+
 /**
  * Turn one raw detection into a {@link BarcodeScanResult}.
  *
@@ -8603,6 +9256,68 @@ export declare interface OpenModalOptions {
 /** The operators a field offers. */
 export declare function operatorsFor(field: FilterField): FilterOperator[];
 
+/**
+ * @tempest-limits file-lines — parsing a session description, merging one
+ * `fmtp` line and inserting a missing one are the same pass over the same
+ * grammar; split apart, each half is a parser of half an SDP.
+ */
+/** What an Opus `fmtp` line can be asked to carry. Every field is optional. */
+export declare interface OpusProfile {
+    /**
+     * Ceiling the encoder is asked to respect, in bits per second.
+     *
+     * This describes what we want **to receive**. To cap what we *send*, use
+     * `setSenderBitrate` — in a mesh that is the one that matters, because the
+     * uplink carries one copy per participant.
+     */
+    maxAverageBitrate?: number;
+    /** Highest sample rate worth decoding, in Hz. `48000` for full band. */
+    maxPlaybackRate?: number;
+    /**
+     * Two channels instead of one.
+     *
+     * Sets `stereo` **and** `sprop-stereo`, which point in opposite directions:
+     * `stereo=1` asks the *remote* to send two channels, `sprop-stereo=1`
+     * announces that *we* will. Setting only one leaves the link asymmetric,
+     * which is the recurring reason "I asked for stereo and got mono".
+     */
+    stereo?: boolean;
+    /**
+     * In-band forward error correction (`useinbandfec`).
+     *
+     * Rebuilds a lost packet from the next one, which keeps speech intelligible
+     * on a lossy link — and smears music, since it spends bitrate on redundancy
+     * instead of detail.
+     */
+    fec?: boolean;
+    /**
+     * Discontinuous transmission (`usedtx`): stop sending during silence.
+     *
+     * Saves uplink in a mesh, at the cost of clipping the first instant after a
+     * pause. Wrong for music and for a shared screen, where the quiet passages
+     * are content.
+     */
+    dtx?: boolean;
+    /** Constant bitrate (`cbr`). Off by default, as Opus intends. */
+    cbr?: boolean;
+    /**
+     * Any other `fmtp` key, merged verbatim.
+     *
+     * The escape hatch for a parameter this type does not model. Values are
+     * written as given; a key with an empty string is emitted as a bare flag.
+     */
+    extra?: Record<string, string>;
+}
+
+/**
+ * Profiles to apply, keyed by audio m-line index (`0`, `1`, …) or by `mid`.
+ *
+ * Position and `mid` can be mixed in one object. A key that matches nothing is
+ * ignored rather than an error — an SDP is negotiated, and a slot that was not
+ * offered this time is normal.
+ */
+export declare type OpusProfileMap = Record<string | number, OpusProfile>;
+
 /**
  * First sequential step that clears 2:1 against the chart surface.
  *
@@ -8750,8 +9465,19 @@ export declare interface PageProps extends Omit<HTMLAttributes<HTMLElement>, "ti
 
 /**
  * Numeric pagination controls. Pair with {@link usePagination} for state.
+ *
+ * Narrow screens collapse to `‹` / `›` plus the summary by default, which turns
+ * random access into sequential access — fine for a desktop-first app, wrong for
+ * one whose traffic is phones. `compactOnMobile={false}` keeps the numbers at
+ * every width: the row scrolls on its own instead of widening the page, and the
+ * effect below keeps the current page inside the visible part of that row.
+ *
+ * The scroll is why this is one boolean rather than a `variant`. Simply
+ * un-hiding the buttons would push a nine-button row past a 360px viewport and
+ * give the whole document a horizontal scrollbar — the opt-out has to carry its
+ * own layout, so it does.
  */
-export declare function Pagination({ page, totalPages, onPageChange, pageSize, onPageSizeChange, pageSizeOptions, totalItems, siblingCount, className, }: PaginationProps): JSX.Element | null;
+export declare function Pagination({ page, totalPages, onPageChange, pageSize, onPageSizeChange, pageSizeOptions, totalItems, siblingCount, compactOnMobile, className, }: PaginationProps): JSX.Element | null;
 
 export declare interface PaginationProps {
     page: number;
@@ -8762,8 +9488,20 @@ export declare interface PaginationProps {
     pageSizeOptions?: number[];
     /** Total items count; if provided, renders the summary text. */
     totalItems?: number;
-    /** Max number of numbered page buttons to show. Default 7. */
+    /** Pages kept around the current one; ~`siblingCount + 4` buttons render. Default 3. */
     siblingCount?: number;
+    /**
+     * Below 640px, drop to `‹` / `›` plus the summary and hide the numbered
+     * buttons and the size select. Default `true`.
+     *
+     * The default suits a desktop-first app, and costs the thing pagination is
+     * for on a phone: reaching page 7 becomes six taps on "next" instead of one
+     * tap on `7`. Pass `false` in a mobile-first app and the numbers stay at
+     * every width — the row scrolls horizontally by itself rather than pushing
+     * the page wider, and the current page is scrolled into view when it
+     * changes.
+     */
+    compactOnMobile?: boolean;
     className?: string;
 }
 
@@ -8775,13 +9513,28 @@ declare type ParamValue = string | number | boolean | undefined | null;
 /**
  * Validate an unknown response payload against a zod schema.
  *
- * In development, throws a detailed error pointing at the divergent field.
- * In production, throws a generic error so internals do not leak to users.
+ * A development build throws a detailed error naming every divergent field path
+ * and embedding the raw payload; every other build throws a generic sentence, so
+ * server internals never reach a user's screen or an error tracker.
+ *
+ * Which one you get comes from `isDevBuild()`, the SDK's single answer to that
+ * question, rather than from a check written here. This function used to ask
+ * `typeof process !== "undefined" && process.env?.NODE_ENV === "development"`,
+ * and a browser has no `process` identifier at all — so the guard short-circuited
+ * and the detailed branch was dead in exactly the build it was written for, no
+ * matter what the bundler substituted behind it.
+ *
+ * The rule `isDevBuild()` applies is `NODE_ENV !== "production"`, which is wider
+ * than the old `"development" || "test"`: a staging build that never sets
+ * `NODE_ENV=production` gets the drift report, raw payload included.
  *
  * @param schema - The zod schema to parse against.
  * @param raw - The raw response payload.
  * @param context - A label used in error messages, e.g. "POST /auth/login".
  * @returns The parsed, typed payload.
+ * @throws Error When the payload does not match the schema: `[parseResponse]
+ * Contract drift on <context>` with the field paths and the raw payload in a
+ * development build, `Resposta inválida do servidor (<context>).` otherwise.
  */
 export declare function parseResponse<TSchema extends z.ZodTypeAny>(schema: TSchema, raw: unknown, context: string): z.infer<TSchema>;
 
@@ -9315,8 +10068,13 @@ export declare interface PopoverProps {
  * Renders its children into a different part of the DOM tree via a React portal.
  *
  * Useful for overlays (modals, tooltips, dropdowns) that must escape parent
- * overflow/stacking contexts. Defaults to `document.body` when no `container`
- * is provided.
+ * overflow/stacking contexts.
+ *
+ * Without `container` the target is the element currently presented fullscreen,
+ * and `document.body` the rest of the time. `body` alone would be wrong during
+ * fullscreen: the browser paints only the fullscreen element's subtree, so an
+ * overlay mounted outside it is invisible and unclickable while looking perfectly
+ * healthy in the DOM. Passing `container` opts out of that and pins the target.
  *
  * SSR-safe: renders `null` on the server and on the first client render, then
  * mounts the portal after hydration (when `document` is available).
@@ -9329,7 +10087,12 @@ export declare function Portal({ children, container }: PortalProps): ReactNode;
 export declare interface PortalProps {
     /** Content rendered through the portal. */
     children: ReactNode;
-    /** Target DOM node to render into. Defaults to `document.body`. */
+    /**
+     * Target DOM node to render into.
+     *
+     * Defaults to the fullscreen element while one is presented, and to
+     * `document.body` otherwise.
+     */
     container?: Element | null;
 }
 
@@ -9363,7 +10126,7 @@ export declare interface PostHogLike {
 }
 
 /** A lazy component that can also be fetched ahead of being rendered. */
-export declare type PreloadableLazy<T extends ComponentType<unknown>> = ReturnType<typeof lazy<T>> & {
+export declare type PreloadableLazy<T extends AnyComponent> = ReturnType<typeof lazy<T>> & {
     /**
      * Start fetching the chunk now, before anything renders it.
      *
@@ -9461,6 +10224,20 @@ export declare interface PullPage<TRemote> {
     serverTime: string | null;
 }
 
+/**
+ * The keys worth offering for push-to-talk.
+ *
+ * Identified by `code` rather than `key` so a binding survives a layout change:
+ * on an ABNT2 keyboard the `key` reported for the backquote position is not what
+ * a US layout reports, while `Backquote` is the same physical key everywhere.
+ *
+ * Left-hand modifiers only. The right-hand ones sit under the hand that is
+ * usually on the mouse, and a modifier that is also a shortcut prefix
+ * (`ControlLeft` with a browser shortcut) is a deliberate trade the caller makes
+ * by choosing it.
+ */
+export declare const PUSH_TO_TALK_KEYS: readonly PushToTalkKey[];
+
 /**
  * Service-worker context helpers for handling `push` and `notificationclick`
  * events. Import these inside your own `sw.ts` — they expect to run in the
@@ -9485,6 +10262,23 @@ export declare interface PushPayload {
     data?: Record<string, unknown>;
 }
 
+/** A key offered for push-to-talk, with the label a settings screen shows. */
+export declare interface PushToTalkKey {
+    /** `KeyboardEvent.code`, which is layout-independent. */
+    code: string;
+    /** What to show a person. `code` itself is not a label. */
+    label: string;
+}
+
+/**
+ * The label to show for a `KeyboardEvent.code`.
+ *
+ * @param code - The bound key's code.
+ * @returns Its label, or the code itself for a key this list does not name —
+ *     showing `"F13"` beats showing nothing.
+ */
+export declare function pushToTalkKeyLabel(code: string): string;
+
 /** Raised when a payload cannot be encoded at the requested level. */
 export declare class QRCapacityError extends Error {
     readonly length: number;
@@ -9675,7 +10469,7 @@ export declare function range(start: number, end: number, step?: number): number
  * stays accessible and works with keyboards/screen readers without
  * heavyweight positioning libs. The active fill is positioned via percentages.
  */
-export declare function RangeSlider({ value, onChange, min, max, step, label, helperText, disabled, formatValue, className, }: RangeSliderProps): JSX.Element;
+export declare function RangeSlider({ value, onChange, min, max, step, label, helperText, disabled, formatValue, "aria-label": ariaLabel, className, }: RangeSliderProps): JSX.Element;
 
 export declare interface RangeSliderProps {
     value: RangeValue;
@@ -9688,6 +10482,14 @@ export declare interface RangeSliderProps {
     disabled?: boolean;
     /** Formatter for the value badge next to the label. Defaults to `min – max`. */
     formatValue?: (value: RangeValue) => string;
+    /**
+     * Accessible name for the pair, for when the visible `label` block does not fit.
+     *
+     * Each thumb still gets its own suffixed name — `"Preço (mínimo)"` and
+     * `"Preço (máximo)"` — because a screen reader user moving between the two
+     * needs to know which end they are on. Takes precedence over `label`.
+     */
+    "aria-label"?: string;
     className?: string;
 }
 
@@ -9740,6 +10542,29 @@ export declare function readableForeground(background: string, light?: string, d
  */
 export declare function readDeviceProfile(): DeviceProfile;
 
+/**
+ * Read the round trip of the candidate pair actually carrying the link.
+ *
+ * A connection routinely keeps several viable pairs alive at once — host,
+ * server-reflexive, relayed — and only one of them carries traffic. Reading the
+ * first `succeeded` pair makes the number jump between paths that are not being
+ * travelled: 8 ms on an idle host pair alternating with 180 ms on the TURN pair
+ * doing the work. The pair the transport names in `selectedCandidatePairId` is
+ * the one being used.
+ *
+ * A succeeded pair is kept as a fallback because not every browser fills that
+ * field in — losing the reading entirely is worse than an occasionally
+ * optimistic one.
+ *
+ * @param report - A report from `RTCPeerConnection.getStats()`.
+ * @returns Round trip in milliseconds, rounded, or `null` when nothing reported
+ *   one — which is the normal state before the connection settles.
+ *
+ * @example
+ * const rttMs = readRoundTripMs(await pc.getStats());
+ */
+export declare function readRoundTripMs(report: RTCStatsReport): number | null;
+
 /**
  * Read a token's computed value from an element (default: `<html>`).
  *
@@ -9826,7 +10651,19 @@ export declare interface RegisterPeriodicSyncOptions {
  *
  * Skips silently when the runtime has no `serviceWorker` support. The host
  * app keeps full control over the SW file — this helper only handles the
- * boilerplate around `register()` and `updatefound`.
+ * boilerplate around `register()` and update detection.
+ *
+ * Two things can mean "an update is ready", and only one of them is an event.
+ * `updatefound` covers the worker that installs while this tab is open. The
+ * commoner case has no event at all: the user visited after a deploy, the new
+ * worker installed and went to `waiting`, they closed the tab, and they are back
+ * now. `install` already happened, so nothing fires — which is why `waiting` is
+ * read directly once the registration resolves. Both routes go through the same
+ * dedupe, so a worker is announced once even when both apply.
+ *
+ * Neither route fires without `navigator.serviceWorker.controller`: no
+ * controller means this is the first install, which is `onReady` territory, not
+ * an update the user should be prompted about.
  *
  * With `autoUpdate` enabled it additionally polls `registration.update()` on
  * an interval and (by default) reloads the page when a freshly activated worker
@@ -9848,6 +10685,10 @@ export declare interface RegisterServiceWorkerOptions {
      * Called when a new worker has finished installing while another worker
      * still controls the page. The host app typically prompts the user to
      * reload and then calls {@link skipWaiting} on the returned worker.
+     *
+     * Fires for a worker that was already `waiting` when `register()` resolved
+     * — the state a user returning after a deploy actually finds — as well as
+     * for one that installs during this session, and at most once per worker.
      */
     onUpdate?: (waiting: ServiceWorker, registration: ServiceWorkerRegistration) => void;
     /** Called on registration failure. */
@@ -10194,22 +11035,40 @@ export { Route }
 
 /**
  * Declarative route guard built on React Router's `<Navigate>`. Renders its
- * children when `when` is truthy, otherwise redirects. Pairs naturally with
- * `createAuthStore` for protected areas.
+ * children when `when` is `true`, redirects when it is `false`, and holds on
+ * `"pending"`. Pairs naturally with `createAuthStore` for protected areas, and
+ * with `useCan` for permissions that resolve over the network.
  *
  * @example
  * <RouteGuard when={useAuthStore((s) => s.isAuthenticated)} redirectTo="/login">
  *     <Outlet />
  * </RouteGuard>
+ *
+ * @example
+ * const { allowed, isLoading } = useCan({ action: "read", resource: "finance" });
+ *
+ * <RouteGuard when={isLoading ? "pending" : allowed} fallback={<Spinner />}>
+ *     <Outlet />
+ * </RouteGuard>
  */
-export declare function RouteGuard({ when, redirectTo, replace, children }: RouteGuardProps): JSX.Element;
+export declare function RouteGuard({ when, fallback, redirectTo, replace, children, }: RouteGuardProps): JSX.Element;
 
 export declare interface RouteGuardProps {
     /**
-     * Whether access is allowed. Pass a boolean or anything truthy/falsy —
-     * typically `useAuthStore((s) => s.isAuthenticated)`.
+     * Whether access is allowed — typically
+     * `useAuthStore((s) => s.isAuthenticated)`.
+     *
+     * `"pending"` is the third answer, for a permission that has not resolved
+     * yet: it holds the decision and renders {@link fallback} instead of
+     * choosing between two wrong moves — redirecting someone who does have
+     * access, or showing the screen to someone who does not.
      */
-    when: boolean;
+    when: RouteGuardResult;
+    /**
+     * Rendered while `when` is `"pending"`. Defaults to nothing, which is a
+     * blank screen — pass the same spinner the rest of the app uses.
+     */
+    fallback?: ReactNode;
     /** Where to redirect when `when` is falsy (default: `"/"`). */
     redirectTo?: string;
     /** Replace history entry on redirect instead of pushing (default: true). */
@@ -10218,6 +11077,19 @@ export declare interface RouteGuardProps {
     children: ReactNode;
 }
 
+/**
+ * What a route guard can answer.
+ *
+ * `true` renders the route, `false` redirects — and `"pending"` is the third
+ * answer a two-state guard cannot give. Without it, a permission that resolves
+ * asynchronously has to lie while it is in flight, and both lies are wrong:
+ * answering `false` redirects the person who **does** have the permission,
+ * every time the route is opened cold (F5 on the URL, an external link);
+ * answering `true` renders the screen for someone who does not, until the
+ * answer lands.
+ */
+export declare type RouteGuardResult = boolean | "pending";
+
 /** Router history strategy used by {@link AppRouter}. */
 export declare type RouterKind = "browser" | "hash" | "memory";
 
@@ -10578,6 +11450,56 @@ export declare interface SequentialScaleOptions {
  */
 export declare function setAudioOutput(element: HTMLMediaElement | null, sinkId: string): Promise<boolean>;
 
+/**
+ * Cap what one sender transmits, in bits per second.
+ *
+ * This is the other half of the pair that confuses people: an Opus `fmtp` line
+ * describes what we want **to receive**, while this is what limits what we
+ * **send**. Both are needed, and in a mesh topology this one matters more,
+ * because the uplink carries one copy of the stream per participant.
+ *
+ * The read-modify-write is not ceremony. `setParameters` only accepts the very
+ * object `getParameters` handed back — a freshly built one is rejected — and a
+ * sender that has not negotiated yet reports **no** encodings at all, so writing
+ * to `encodings[0]` without checking throws on exactly the call that sets the
+ * cap before the first offer.
+ *
+ * @param sender - The `RTCRtpSender` to cap, from `pc.getSenders()` or
+ *   `transceiver.sender`.
+ * @param maxBitrate - Ceiling in bits per second, or `null` to lift the cap.
+ * @returns `false` when the browser refused the change, which happens when the
+ *   sender has no track or the transceiver is gone. Playback continues
+ *   uncapped — a call that keeps running beats one that throws over a bitrate.
+ *
+ * @example
+ * const sender = pc.getSenders().find((s) => s.track?.kind === "audio");
+ * if (sender) await setSenderBitrate(sender, 48_000);
+ */
+export declare function setSenderBitrate(sender: RTCRtpSender, maxBitrate: number | null): Promise<boolean>;
+
+/**
+ * Set a local description, falling back to the untouched one if it is refused.
+ *
+ * Chrome has been tightening what `setLocalDescription` accepts from edited SDP,
+ * and there is no way to know in advance. Without a fallback the call dies
+ * instead of merely losing the profile — which is the wrong trade by a wide
+ * margin: worse audio beats no audio.
+ *
+ * @param connection - The peer connection.
+ * @param description - The description from `createOffer` / `createAnswer`.
+ * @param profiles - Passed straight to {@link tuneOpus}.
+ * @returns `"tuned"` when the rewritten SDP was accepted, `"original"` when the
+ *   fallback was used — worth reporting, because it means the profile silently
+ *   did not apply.
+ * @throws Whatever `setLocalDescription` throws for the original description: at
+ *   that point the failure is not about the rewrite and the caller has to know.
+ *
+ * @example
+ * const applied = await setTunedLocalDescription(pc, await pc.createOffer(), profiles);
+ * if (applied === "original") logger.warn("opus profile refused by the browser");
+ */
+export declare function setTunedLocalDescription(connection: RTCPeerConnection, description: RTCSessionDescriptionInit, profiles: OpusProfile | OpusProfileMap): Promise<TunedDescriptionResult>;
+
 /** Imperative handle over a pool of short sound effects. */
 export declare interface SfxPool {
     /** Play a clip, allocating and caching its element on first use. */
@@ -10920,7 +11842,7 @@ export declare function sleep(ms: number): Promise<void>;
  * accessible (keyboard + screen reader) with no positioning libs. The active
  * fill is a percentage-width bar. For a two-thumb range, use `RangeSlider`.
  */
-export declare function Slider({ value, onChange, min, max, step, label, helperText, disabled, formatValue, className, }: SliderProps): JSX.Element;
+export declare function Slider({ value, onChange, min, max, step, label, helperText, disabled, formatValue, "aria-label": ariaLabel, className, }: SliderProps): JSX.Element;
 
 export declare interface SliderProps {
     /** Current value. */
@@ -10935,6 +11857,17 @@ export declare interface SliderProps {
     disabled?: boolean;
     /** Formatter for the value badge next to the label. Defaults to the raw number. */
     formatValue?: (value: number) => string;
+    /**
+     * Accessible name, for when the visible `label` block does not fit.
+     *
+     * A slider in a one-line footer, a table cell or a toolbar has no room for the
+     * label row above the track, and without this every such control announces
+     * itself as "Slider" — several on the same screen become indistinguishable to a
+     * screen reader. Takes precedence over `label`; wrapping the field in an outer
+     * `<label>` does not work, because an explicit `aria-label` on the input wins
+     * the accessible-name precedence order.
+     */
+    "aria-label"?: string;
     className?: string;
 }
 
@@ -11298,6 +12231,19 @@ export { StorageEstimate_2 as StorageEstimate }
 
 export { SubmitHandler }
 
+/**
+ * Turn a measured noise floor into a threshold worth using.
+ *
+ * Sits above the floor by a margin rather than on it, and is clamped at both
+ * ends: a room measured as perfectly silent (or not measured at all) would
+ * otherwise get a threshold of zero, which is a gate that never closes, and a
+ * room measured while somebody talked would get one nothing opens.
+ *
+ * @param noiseFloor - Peak RMS measured while nobody spoke.
+ * @returns A threshold for {@link VoiceChainSettings.gateThreshold}, `0.004..0.12`.
+ */
+export declare function suggestGateThreshold(noiseFloor: number): number;
+
 /** Toggle switch backed by a checkbox input. Accessible via keyboard. */
 export declare const Switch: ForwardRefExoticComponent<SwitchProps & RefAttributes<HTMLInputElement>>;
 
@@ -11659,15 +12605,30 @@ export declare interface TempestRouteObject {
      * under the {@link AppRouter} `<Suspense>` boundary.
      */
     lazy?: () => Promise<{
-        default: ComponentType<unknown>;
+        default: AnyRouteComponent;
     }>;
     /** Nested child routes (rendered through this route's `<Outlet />`). */
     children?: TempestRouteObject[];
     /**
      * Access guard. When `false` (or a function returning `false`), the route
-     * renders a redirect to {@link redirectTo} instead of its element.
+     * renders a redirect to {@link redirectTo} instead of its element. When the
+     * function returns `"pending"`, the decision is held and {@link guardFallback}
+     * renders instead — see {@link RouteGuardResult}.
+     *
+     * The function runs inside the guard component's render, so it **may call
+     * hooks** — which is what lets an async permission check like `useCan` plug
+     * straight in. The usual rule applies: call the same hooks on every render
+     * of that route. Guarded routes are keyed per route object, so navigating
+     * between two routes whose guards call different hooks remounts rather than
+     * breaking hook order.
      */
-    guard?: boolean | (() => boolean);
+    guard?: boolean | (() => RouteGuardResult);
+    /**
+     * Rendered while {@link guard} answers `"pending"`. Defaults to the
+     * {@link AppRouter} `fallback`, so a route tree that already passes a
+     * spinner for `lazy` chunks reuses it here with no extra wiring.
+     */
+    guardFallback?: ReactNode;
     /** Destination used when `guard` fails (default: `"/"`). */
     redirectTo?: string;
     /** Match the path case-sensitively. */
@@ -12380,6 +13341,42 @@ export declare interface TruncateTextProps extends HTMLAttributes<HTMLDivElement
     children: ReactNode;
 }
 
+/** Which description a peer connection actually accepted. */
+export declare type TunedDescriptionResult = "tuned" | "original";
+
+/**
+ * Apply Opus profiles to the audio m-lines of a session description.
+ *
+ * Audio over WebRTC is mono and narrow by default, and the only place that is
+ * corrected is the SDP — which is why shared-screen audio famously sounds like a
+ * telephone: music and video inherit the speech profile (mono, ~32 kbps, FEC on,
+ * DTX gating the quiet passages) and no high-level API lets you change it.
+ *
+ * Deliberately **without** built-in presets: which values to use is the
+ * consumer's call — voice in a mesh does not want what system audio wants — and
+ * a preset table is the kind of thing that has no business inside a dependency.
+ * What lives here is the parsing, merging and insertion, which is where the long
+ * tail is. Getting any of it wrong degrades silently: nobody sees an exception,
+ * the audio is just worse.
+ *
+ * @param sdp - The description from `createOffer` or `createAnswer`.
+ * @param profiles - One {@link OpusProfile} for every audio m-line, or an
+ *   {@link OpusProfileMap} keyed by audio m-line index or by `mid`.
+ * @returns The rewritten SDP, with CRLF line endings as RFC 4566 requires.
+ *   Untouched when there is no Opus, when no profile matches, or when a profile
+ *   asks for nothing.
+ *
+ * @example
+ * const tuned = tuneOpus(offer.sdp, {
+ *   0: { maxAverageBitrate: 48_000, stereo: false, fec: true, dtx: true },
+ *   1: { maxAverageBitrate: 192_000, stereo: true, fec: false, dtx: false },
+ * });
+ *
+ * @example
+ * const tuned = tuneOpus(offer.sdp, { stereo: true, dtx: false });
+ */
+export declare function tuneOpus(sdp: string, profiles: OpusProfile | OpusProfileMap): string;
+
 /**
  * Clock label for a turn — the time, not a relative phrase.
  *
@@ -12640,6 +13637,31 @@ export declare interface UseAsyncResult<T> {
  */
 export declare function useAudio(): UseAudioResult;
 
+/**
+ * Keep one {@link AudioBus} alive for as long as the component is mounted.
+ *
+ * The bus is built on the first render and closed on unmount, which matters more
+ * than it looks: browsers cap the number of live `AudioContext`s (Chrome allows
+ * around six), so a bus leaked on unmount eventually breaks every later one on
+ * the page.
+ *
+ * Options are read once. A bus is a device route and a mixing graph, not a
+ * render output — rebuilding it because a prop changed would drop every attached
+ * source mid-sentence. Change gain and output through the bus itself.
+ *
+ * @param options - See {@link AudioBusOptions}. Read on the first render only.
+ * @returns The bus, stable for the component's lifetime.
+ *
+ * @example
+ * const bus = useAudioBus({ maxGain: 3 });
+ *
+ * useEffect(() => {
+ *   const handle = bus.attach(stream, { gain: 1 });
+ *   return () => handle.stop();
+ * }, [bus, stream]);
+ */
+export declare function useAudioBus(options?: AudioBusOptions): AudioBus;
+
 /**
  * Record the given stream, with a clock, a level meter and a state machine.
  *
@@ -13187,6 +14209,71 @@ export { UseFormReturn }
 
 export { useFormState }
 
+/**
+ * Drive an immersive mode whose state stays true to the browser.
+ *
+ * The mistake this exists to remove is storing `isFullscreen` in state and
+ * flipping it inside your own `enter()` / `exit()`. Fullscreen ends in ways your
+ * code never sees — `Esc`, the browser's own exit affordance, F11 pressed while an
+ * API fullscreen is active — and each of those leaves the flag saying "sair" over
+ * a page that is already windowed. The only honest source is the
+ * `fullscreenchange` event, which fires for every one of them, so that is what
+ * this hook reads and what the returned `isFullscreen` reflects. The action
+ * callbacks never touch it.
+ *
+ * The subscription is not this hook's own: it lives in `useFullscreenElement`,
+ * shared with `usePortalHost`, which needs the same fact to decide where an
+ * overlay mounts while fullscreen is on. Two independent listeners for one event
+ * would mean two copies of the WebKit prefix dance and two places to fix the next
+ * quirk, so the primitive answers "which element is presented" once and each
+ * consumer asks its own question of the answer.
+ *
+ * WebKit's prefixed members are handled throughout — `webkitfullscreenchange`,
+ * `webkitFullscreenElement`, `webkitRequestFullscreen`, `webkitExitFullscreen` —
+ * because Safari on iPad still ships them and nothing else.
+ *
+ * `isFullscreen` is identity against the target, not containment: a `<video>`
+ * inside your element going fullscreen on its own is not your element being
+ * presented, and reporting `true` there would put your exit control inside a
+ * subtree the browser is not painting.
+ *
+ * @param ref - The element to present. Omit it to present the whole page
+ * (`document.documentElement`).
+ * @returns `{ isFullscreen, supported, enter, exit, toggle }`.
+ * @throws Nothing during render. `enter()` and `toggle()` reject with the
+ * browser's own error when the request is refused — most often a `TypeError`
+ * because the call did not come from a user gesture — and with an `Error` when
+ * there is no element to present or the environment ships no Fullscreen API.
+ *
+ * @example
+ * const stage = useRef<HTMLDivElement>(null);
+ * const { isFullscreen, supported, toggle } = useFullscreen(stage);
+ *
+ * <div ref={stage}>
+ *   <video src="/aula.mp4" controls />
+ *   {supported ? (
+ *     <button onClick={() => void toggle().catch(() => setRefused(true))}>
+ *       {isFullscreen ? "Sair da tela cheia" : "Tela cheia"}
+ *     </button>
+ *   ) : null}
+ * </div>
+ */
+export declare function useFullscreen(ref?: RefObject<HTMLElement | null>): UseFullscreenResult;
+
+/** Value returned by {@link useFullscreen}. */
+export declare interface UseFullscreenResult {
+    /** Whether the target element is the one the browser is presenting right now. */
+    isFullscreen: boolean;
+    /** Whether a request stands a chance at all — hide the control when `false`. */
+    supported: boolean;
+    /** Present the target. Must be called from a user gesture. Rejects if refused. */
+    enter: () => Promise<void>;
+    /** Leave fullscreen. Resolves immediately when nothing is presented. */
+    exit: () => Promise<void>;
+    /** Leave if the target is presented, otherwise enter. Same gesture rule as `enter`. */
+    toggle: () => Promise<void>;
+}
+
 /**
  * React hook around the Geolocation API.
  *
@@ -13401,6 +14488,51 @@ export declare interface UseKeyboardShortcutOptions {
  */
 export declare function useLatestRef<T>(value: T): RefObject<T>;
 
+/**
+ * Poll one connection's throughput, resolution and round trip.
+ *
+ * Sampling runs only while the connection is `"connected"`, so a link that is
+ * still negotiating or already gone costs nothing. The last reading is kept
+ * across pauses rather than cleared, because a badge that blanks every time the
+ * tab loses focus reads as a broken connection.
+ *
+ * Coming back from a pause resets the baseline first. Without that, the sample
+ * after a five-minute background stretch divides five minutes of bytes by five
+ * minutes and reports the average of a period the person is not asking about.
+ *
+ * @param connection - The connection to watch, or `null` before one exists.
+ * @param options - See {@link UseLinkStatsOptions}.
+ * @returns The latest reading, or `null` before the first sample lands.
+ *
+ * @example
+ * const stats = useLinkStats(pc);
+ *
+ * return <span>{stats ? `${stats.kbps} kbps · ${stats.rttMs ?? "—"} ms` : "medindo…"}</span>;
+ */
+export declare function useLinkStats(connection: RTCPeerConnection | null, options?: UseLinkStatsOptions): LinkStats | null;
+
+/** Options for {@link useLinkStats}. */
+export declare interface UseLinkStatsOptions {
+    /**
+     * How often to sample, in milliseconds. Default `2000`.
+     *
+     * `getStats()` walks every report a connection holds, and a mesh runs one
+     * per participant — on the device least able to pay for it. The numbers feed
+     * a latency badge and a throughput figure nobody reads at 1 Hz, so the
+     * default is deliberately slower than a frame budget suggests.
+     */
+    intervalMs?: number;
+    /**
+     * Stop sampling while the tab is in the background. Default `true`.
+     *
+     * The audio path is untouched by this — people in a backgrounded call still
+     * expect to hear it. What stops is the measuring, which nobody can see.
+     */
+    pauseWhenHidden?: boolean;
+    /** Which media the throughput counts. Default `"video"`. */
+    kind?: LinkStatsKind;
+}
+
 /**
  * Query a paginated list of a resource through the active {@link useDataProvider}.
  *
@@ -14346,6 +15478,57 @@ export declare interface UsePushSubscriptionResult {
     refresh: () => Promise<void>;
 }
 
+/**
+ * Hold a key to transmit; release it to go silent again.
+ *
+ * Looks like `keydown`/`keyup` and is not, because three things go wrong:
+ *
+ * 1. **`blur` has to release.** Alt-tabbing away while holding the key means the
+ *    browser never sees the `keyup`, and the microphone stays open for as long as
+ *    the person is looking at another window — exactly what push-to-talk exists
+ *    to prevent.
+ * 2. **Auto-repeat has to be ignored.** A held key repeats at the keyboard's rate,
+ *    and without the `repeat` check `onDown` fires on every one of them.
+ * 3. **A text field has to win.** Space bound to push-to-talk with the focus in an
+ *    `<input>` means the space never reaches the message being written.
+ *
+ * Unmounting releases too, for the same reason `blur` does: the callback that
+ * stops transmitting has to run even when the component holding it goes away
+ * mid-press.
+ *
+ * The callbacks are read through a ref that a commit-time effect refreshes, so
+ * passing inline arrows neither tears the listeners down on every render nor
+ * writes to the ref during one — a render React discards would leave the ref
+ * pointing at callbacks that never became the UI.
+ *
+ * @param options - See {@link UsePushToTalkOptions}.
+ *
+ * @example
+ * usePushToTalk({
+ *     code: "Space",
+ *     onDown: () => setMicEnabled(true),
+ *     onUp: () => setMicEnabled(false),
+ * });
+ */
+export declare function usePushToTalk({ code, onDown, onUp, enabled, }: UsePushToTalkOptions): void;
+
+/** Options for {@link usePushToTalk}. */
+export declare interface UsePushToTalkOptions {
+    /** `KeyboardEvent.code` to hold. Default {@link DEFAULT_PUSH_TO_TALK_KEY}. */
+    code?: string;
+    /** Called once when the key goes down. */
+    onDown: () => void;
+    /** Called when the key comes up, the window blurs, or the hook unmounts. */
+    onUp: () => void;
+    /**
+     * Whether the binding is live. Default `true`.
+     *
+     * Turning it off releases first, so flipping a call from push-to-talk to an
+     * open microphone while the key is held does not leave `onUp` unfired.
+     */
+    enabled?: boolean;
+}
+
 /**
  * FIFO queue with an optional `limit`. When more items are added than `limit`
  * allows, the surplus is kept in an internal overflow buffer and surfaces into
@@ -15105,11 +16288,13 @@ export { useWatch }
  * for the host component and tears it down on unmount.
  *
  * Every callback is read through a ref, so `onOpen` / `onMessage` / `onClose` /
- * `onError` always run the latest closure — an inline arrow function is fine
- * and never reopens the socket. Connection-shaping options (`protocols`,
- * `maxRetries`, `initialBackoff`, `maxBackoff`, `pingInterval`,
- * `queueWhileClosed`) are baked into the connection, so changing one reopens
- * it with the new value rather than being silently ignored.
+ * `onError` / `onReconnecting` / `onReconnected` / `onLost` always run the
+ * latest closure — an inline arrow function is fine and never reopens the
+ * socket. Connection-shaping options (`protocols`, `maxRetries`,
+ * `initialBackoff`, `maxBackoff`, `jitter`, `handshakeTimeout`,
+ * `silenceTimeout`, `waitForOnline`, `pingInterval`, `queueWhileClosed`) are
+ * baked into the connection, so changing one reopens it with the new value
+ * rather than being silently ignored.
  *
  * @param url - Full ws:// or wss:// URL.
  * @param options - Connection configuration and callbacks.
@@ -15138,6 +16323,13 @@ export declare interface UseWebSocketResult<T> {
     send: (payload: string | Blob | BufferSource) => boolean;
     /** Force a reconnect, resetting the retry counter. */
     reconnect: () => void;
+    /**
+     * Change the silence watchdog at runtime, in ms. `0` disables it.
+     *
+     * For a server that announces its own heartbeat interval in the first frame,
+     * so the tolerated silence is not hard-coded on both ends.
+     */
+    setSilenceTimeout: (ms: number) => void;
 }
 
 /**
@@ -15690,6 +16882,98 @@ export declare interface VisuallyHiddenProps extends HTMLAttributes<HTMLElement>
     as?: keyof JSX.IntrinsicElements;
 }
 
+/** A running voice-activity monitor. */
+export declare interface VoiceActivityMonitor {
+    /** Whether the track is currently carrying speech. */
+    readonly speaking: boolean;
+    /** Stop sampling and release the analysis graph. */
+    stop: () => void;
+}
+
+/** Options for {@link monitorVoiceActivity}. */
+export declare interface VoiceActivityOptions {
+    /** RMS at or above which a window counts as speech. Default `0.045`. */
+    threshold?: number;
+    /** How long the state stays `true` after the level drops. Default `350`. */
+    releaseMs?: number;
+    /** How often the level is sampled, in ms. Default `100`. */
+    pollMs?: number;
+    /**
+     * Reuse an existing `AudioContext` instead of creating one.
+     *
+     * A monitor per remote participant hits the browser's cap on live contexts
+     * (Chrome allows around six) in a five-person call. Open one and share it.
+     */
+    context?: AudioContext;
+}
+
+/** A running voice chain. */
+export declare interface VoiceChain {
+    /** The processed track to publish. */
+    track: MediaStreamTrack;
+    /** Stop the detectors, disconnect the graph, and release the track. */
+    release: () => void;
+    /**
+     * Whether a graph was actually built.
+     *
+     * `false` when this engine has no Web Audio, and also when the settings asked
+     * for nothing — in both cases `track` is `source`, untouched.
+     */
+    readonly supported: boolean;
+}
+
+/** Options for {@link createVoiceChain}. */
+export declare interface VoiceChainOptions {
+    /** Output multiplier, applied after every stage and before the limiter. Default `1`. */
+    gain?: number;
+    /**
+     * Reuse an existing `AudioContext` instead of creating one.
+     *
+     * Browsers cap live contexts (Chrome allows around six), so a page that already
+     * has one — a level meter, an audio bus — should hand it over.
+     */
+    context?: AudioContext;
+    /**
+     * Whether `release()` also stops `source`. Default `true`.
+     *
+     * Pass `false` when the track belongs to somebody else: a settings dialog
+     * building a second chain over its live preview would otherwise kill the meter
+     * the person is watching while they listen.
+     */
+    ownsSource?: boolean;
+}
+
+/** Which stages a voice chain builds. */
+export declare interface VoiceChainSettings {
+    /** Cut everything below speech: fans, traffic rumble, desk knocks, plosives. */
+    highPass: boolean;
+    /** Silence the line when nobody is talking. */
+    gate: boolean;
+    /** RMS below which the gate closes, 0..1. See {@link suggestGateThreshold}. */
+    gateThreshold: number;
+    /** Even out the distance between a whisper and a shout. */
+    compressor: boolean;
+    /** Lift the consonant band so speech reads without getting louder. */
+    presence: boolean;
+    /** Roll off hiss above what speech uses. */
+    hissCut: boolean;
+    /** Ride down harsh S and CH sounds. */
+    deEsser: boolean;
+    /**
+     * Hard ceiling before the signal leaves.
+     *
+     * On by default and worth leaving on: the leveller is 3:1, which controls the
+     * average and lets a peak through, and `gain` can reach well above 1.
+     */
+    limiter: boolean;
+}
+
+/** A running monitor. */
+export declare interface VoiceMonitor {
+    /** Stop listening and release the graph. Does **not** stop the source track. */
+    stop: () => void;
+}
+
 /**
  * Pluggable persistence for the pull watermark (the "changed since" cursor).
  * Pass an object with a `storageKey` to use a `localStorage`-backed default.
@@ -15797,10 +17081,38 @@ export declare interface WebSocketController {
     close: (code?: number, reason?: string) => void;
     /** Force an immediate reconnect, resetting the retry counter. */
     reconnect: () => void;
+    /**
+     * Change the silence watchdog at runtime, in ms. `0` disables it.
+     *
+     * For the common case where the server announces its heartbeat interval in
+     * the first frame, so the tolerated silence is not hard-coded on both ends:
+     *
+     * ```ts
+     * onMessage: ({ data }) => {
+     *   if (data.type === "welcome") socket.setSilenceTimeout(data.heartbeat_seconds * 2500);
+     * }
+     * ```
+     */
+    setSilenceTimeout: (ms: number) => void;
+    /**
+     * Resolves on the first successful open, rejects when the socket is lost
+     * before ever opening.
+     *
+     * Joining and dropping are different events: a call that never connected has
+     * to be reported, while one that dropped mid-session should reconnect
+     * quietly. Await this for the join, handle
+     * {@link CreateWebSocketOptions.onLost} for the drop. Pair it with
+     * `maxRetries: 0` when the first attempt should fail fast instead of
+     * spending the whole schedule on a server that is not there.
+     */
+    opened: Promise<void>;
     /** Current connection status. */
     readonly status: WebSocketStatus;
 }
 
+/** Why a socket stopped trying to come back. */
+export declare type WebSocketLostReason = "rejected" | "exhausted";
+
 export declare interface WebSocketMessage<T> {
     /** Parsed payload — JSON-decoded when possible, raw string otherwise. */
     data: T;
@@ -15808,12 +17120,6 @@ export declare interface WebSocketMessage<T> {
     raw: MessageEvent;
 }
 
-/**
- * @tempest-limits file-lines, function-lines — reconnect with backoff, heartbeat,
- * the send queue that survives a disconnect and the listener set that must be re-
- * attached to each new socket — one connection's lifetime, one closure. The queue
- * and the reconnect timer are the same decision seen twice.
- */
 export declare type WebSocketStatus = "idle" | "connecting" | "open" | "closing" | "closed" | "error";
 
 export declare type WeekStart = 0 | 1;