@camstack/ui-library 1.2.256 → 1.2.258

package/dist/composites/training/training-refusal-text.d.ts

@@ -1,10 +1,10 @@
 /**
- * What the operator reads when a frame could not be sent to training.
- *
- * Pure, so every refusal the hub can name has a sentence here and a test
- * that says so — a refusal rendered as its raw code reads like a crash.
- */
+* What the operator reads when a frame could not be sent to training.
+*
+* Pure, so every refusal the hub can name has a sentence here and a test
+* that says so — a refusal rendered as its raw code reads like a crash.
+*/
 /** The refusal codes `addRetrainFrameFromRecording` answers with. */
-export type TrainingFrameRefusal = 'unknown-collection' | 'still-unavailable' | 'still-busy' | 'unreadable-image' | 'write-failed';
+export type TrainingFrameRefusal = "unknown-collection" | "still-unavailable" | "still-busy" | "unreadable-image" | "write-failed";
 /** One sentence for a refusal, with the hub's own detail appended. */
 export declare function trainingRefusalText(reason: TrainingFrameRefusal, detail?: string): string;

package/dist/composites/unit-picker/UnitPicker.d.ts

@@ -1,16 +1,21 @@
-import { UnitDimension } from '@camstack/types';
-import { ReactNode } from 'react';
+/**
+* Same-dimension unit picker. Lists only `unitsForDimension(dimension)`; an
+* empty dimension disables the control and shows `emptyReason` so the operator
+* never sees a refused conversion as a pickable option.
+*/
+import { type UnitDimension } from "@camstack/types";
+import type { ReactNode } from "react";
 export interface UnitPickerProps {
-    readonly dimension: UnitDimension | undefined;
-    readonly value: string;
-    readonly onChange: (unit: string) => void;
-    readonly disabled?: boolean;
-    /** Shown when `dimension` is undefined; never offered as a pickable unit. */
-    readonly emptyReason?: string;
-    /** Optional empty-value option label (inherit / source). */
-    readonly inheritLabel?: string;
-    readonly className?: string;
-    readonly id?: string;
-    readonly 'aria-label'?: string;
+	readonly dimension: UnitDimension | undefined;
+	readonly value: string;
+	readonly onChange: (unit: string) => void;
+	readonly disabled?: boolean;
+	/** Shown when `dimension` is undefined; never offered as a pickable unit. */
+	readonly emptyReason?: string;
+	/** Optional empty-value option label (inherit / source). */
+	readonly inheritLabel?: string;
+	readonly className?: string;
+	readonly id?: string;
+	readonly "aria-label"?: string;
 }
-export declare function UnitPicker({ dimension, value, onChange, disabled, emptyReason, inheritLabel, className, id, 'aria-label': ariaLabel, }: UnitPickerProps): ReactNode;
+export declare function UnitPicker({ dimension, value, onChange, disabled, emptyReason, inheritLabel, className, id, "aria-label": ariaLabel }: UnitPickerProps): ReactNode;

package/dist/composites/unit-picker/index.d.ts

@@ -1 +1 @@
-export { UnitPicker, type UnitPickerProps } from './UnitPicker.js';
+export { UnitPicker, type UnitPickerProps } from "./UnitPicker.js";

package/dist/composites/use-data-table-filter.d.ts

@@ -1,25 +1,25 @@
-import { DataTableFacet, DataTableFilterConfig, DataTableFilterState } from './data-table-filter';
+import { type DataTableFacet, type DataTableFilterConfig, type DataTableFilterState } from "./data-table-filter";
 /** A facet group as the bar renders it: its chips and what is selected. */
 export interface DataTableFilterGroupView {
-    readonly id: string;
-    readonly facets: readonly DataTableFacet[];
-    readonly selected: readonly string[];
+	readonly id: string;
+	readonly facets: readonly DataTableFacet[];
+	readonly selected: readonly string[];
 }
 export interface DataTableFilter<T> {
-    readonly state: DataTableFilterState;
-    readonly setSearch: (search: string) => void;
-    readonly toggleFacet: (value: string) => void;
-    readonly toggleGroupFacet: (groupId: string, value: string) => void;
-    /** One entry per `facetGroups` config, chips derived from the UNFILTERED rows. */
-    readonly groups: readonly DataTableFilterGroupView[];
-    readonly clear: () => void;
-    /** Chips derived from the UNFILTERED rows — a chip never disappears because
-     *  it was the one just pressed. */
-    readonly facets: readonly DataTableFacet[];
-    /** The rows that survive the filter. */
-    readonly rows: readonly T[];
-    /** True when the filter is narrowing anything — what an empty state should
-     *  read before it says "there is nothing here". */
-    readonly active: boolean;
+	readonly state: DataTableFilterState;
+	readonly setSearch: (search: string) => void;
+	readonly toggleFacet: (value: string) => void;
+	readonly toggleGroupFacet: (groupId: string, value: string) => void;
+	/** One entry per `facetGroups` config, chips derived from the UNFILTERED rows. */
+	readonly groups: readonly DataTableFilterGroupView[];
+	readonly clear: () => void;
+	/** Chips derived from the UNFILTERED rows — a chip never disappears because
+	*  it was the one just pressed. */
+	readonly facets: readonly DataTableFacet[];
+	/** The rows that survive the filter. */
+	readonly rows: readonly T[];
+	/** True when the filter is narrowing anything — what an empty state should
+	*  read before it says "there is nothing here". */
+	readonly active: boolean;
 }
 export declare function useDataTableFilter<T>(rows: readonly T[], config: DataTableFilterConfig<T>): DataTableFilter<T>;

package/dist/composites/version-badge.d.ts

@@ -1,24 +1,25 @@
-import { default as React } from 'react';
-export type SemanticBadgeVariant = 'success' | 'warning' | 'danger' | 'info' | 'neutral';
+import React from "react";
+import { type JSX } from "react";
+export type SemanticBadgeVariant = "success" | "warning" | "danger" | "info" | "neutral";
 export interface SemanticBadgeProps {
-    children: React.ReactNode;
-    variant?: SemanticBadgeVariant;
-    /** Use monospace font (good for versions, codes) */
-    mono?: boolean;
-    className?: string;
+	children: React.ReactNode;
+	variant?: SemanticBadgeVariant;
+	/** Use monospace font (good for versions, codes) */
+	mono?: boolean;
+	className?: string;
 }
 /**
- * General-purpose badge with semantic color variants.
- * Solid background with dark text for maximum contrast.
- */
-export declare function SemanticBadge({ children, variant, mono, className, }: SemanticBadgeProps): React.JSX.Element;
+* General-purpose badge with semantic color variants.
+* Solid background with dark text for maximum contrast.
+*/
+export declare function SemanticBadge({ children, variant, mono, className }: SemanticBadgeProps): JSX.Element;
 export interface VersionBadgeProps {
-    version: string;
-    preRelease?: boolean;
-    className?: string;
+	version: string;
+	preRelease?: boolean;
+	className?: string;
 }
 /**
- * Version badge — auto-detects pre-release versions.
- * Stable = success (green), Pre-release = warning (amber).
- */
-export declare function VersionBadge({ version, preRelease, className }: VersionBadgeProps): React.JSX.Element;
+* Version badge — auto-detects pre-release versions.
+* Stable = success (green), Pre-release = warning (amber).
+*/
+export declare function VersionBadge({ version, preRelease, className }: VersionBadgeProps): JSX.Element;

package/dist/composites/webrtc-diagnostics/EndpointTestCard.d.ts

@@ -1,15 +1,15 @@
-import { ReactNode } from 'react';
-import { EndpointTestRow, IceServerEntry, NatCheckResult } from './endpoint-test';
+import { type ReactNode } from "react";
+import { type EndpointTestRow, type IceServerEntry, type NatCheckResult } from "./endpoint-test";
 export interface EndpointTestCardProps {
-    /** Fetch the live ICE server list (`turnProvider.getTurnServers`). */
-    readonly loadServers: () => Promise<readonly IceServerEntry[]>;
+	/** Fetch the live ICE server list (`turnProvider.getTurnServers`). */
+	readonly loadServers: () => Promise<readonly IceServerEntry[]>;
 }
 /** The per-endpoint result table — one row per tested ICE URL. */
-export declare function EndpointResultsCard({ rows, }: {
-    readonly rows: readonly EndpointTestRow[];
+export declare function EndpointResultsCard({ rows }: {
+	readonly rows: readonly EndpointTestRow[];
 }): ReactNode;
 /** The NAT mapping verdict for this browser. */
 export declare function NatResultCard({ result }: {
-    readonly result: NatCheckResult;
+	readonly result: NatCheckResult;
 }): ReactNode;
 export declare function EndpointTestCard({ loadServers }: EndpointTestCardProps): ReactNode;

package/dist/composites/webrtc-diagnostics/HubSessionTestCard.d.ts

@@ -1,18 +1,18 @@
-import { ReactNode } from 'react';
-import { UseDeviceWebrtcTrpc } from '../../hooks/use-device-webrtc';
-import { StreamChoice } from '../stream-panel';
+import { type ReactNode } from "react";
+import type { UseDeviceWebrtcTrpc } from "../../hooks/use-device-webrtc";
+import type { StreamChoice } from "../stream-panel";
 export interface HubSessionTestCardProps {
-    readonly trpc: UseDeviceWebrtcTrpc;
-    /** The hub base URL the player talks to (the adaptive probe origin). */
-    readonly serverUrl: string;
-    /** The camera under test; null until the host picked one. */
-    readonly deviceId: number | null;
-    /** The host's camera picker, drawn at the top of the card. */
-    readonly cameraField?: ReactNode;
-    /** Length of each run. */
-    readonly runMs?: number;
+	readonly trpc: UseDeviceWebrtcTrpc;
+	/** The hub base URL the player talks to (the adaptive probe origin). */
+	readonly serverUrl: string;
+	/** The camera under test; null until the host picked one. */
+	readonly deviceId: number | null;
+	/** The host's camera picker, drawn at the top of the card. */
+	readonly cameraField?: ReactNode;
+	/** Length of each run. */
+	readonly runMs?: number;
 }
-export declare const HUB_SESSION_RUN_MS = 15000;
+export declare const HUB_SESSION_RUN_MS = 15e3;
 /** Pinned targets only, cheapest first: an adaptive target would climb mid-run. */
 export declare function pinnedStreamChoices(streams: readonly StreamChoice[]): readonly StreamChoice[];
-export declare function HubSessionTestCard({ trpc, serverUrl, deviceId, cameraField, runMs, }: HubSessionTestCardProps): ReactNode;
+export declare function HubSessionTestCard({ trpc, serverUrl, deviceId, cameraField, runMs }: HubSessionTestCardProps): ReactNode;

package/dist/composites/webrtc-diagnostics/RunReport.d.ts

@@ -1,6 +1,11 @@
-import { ReactNode } from 'react';
-import { HubSessionRunReport } from './session-run';
-export declare function RunReport({ report, title, }: {
-    readonly report: HubSessionRunReport;
-    readonly title: string;
+/**
+* One hub session run, rendered: the verdict first, then the evidence by
+* layer (hub candidates → timeline → path → media). Every unmeasured value
+* reads "unknown" (D393), never 0.
+*/
+import type { ReactNode } from "react";
+import type { HubSessionRunReport } from "./session-run";
+export declare function RunReport({ report, title }: {
+	readonly report: HubSessionRunReport;
+	readonly title: string;
 }): ReactNode;

package/dist/composites/webrtc-diagnostics/endpoint-probe.d.ts

@@ -1,32 +1,52 @@
-import { ParsedIceCandidate } from './ice-candidates';
+/**
+* Browser-side probes behind "Test each endpoint" and the NAT mapping check.
+*
+* Everything runs in the operator's browser against real `RTCPeerConnection`s;
+* the only server round-trip is fetching the ICE server list.
+*
+*  - `gatherCandidates` — one peer connection, a given server set: which
+*    candidate types it produces, which server URL produced each (the ICE
+*    event's `url`) and, for a relay, the transport to the TURN server
+*    (`relayProtocol`: udp / tcp / tls).
+*  - `relayLoopback` — two peer connections in this page, both forced to
+*    `relay`: the ONLY way they connect is through the TURN server, so a
+*    connect proves allocation and forwarding work, and the selected pair
+*    gives the relay RTT and the local relay protocol from `getStats()`.
+*    (A same-page loopback with policy `all` proves nothing — the two peers
+*    connect host↔host — which is why it is not offered.)
+*
+* Credentials are attached to `turn:`/`turns:` entries only and never leave
+* this module: nothing here logs or returns them.
+*/
+import { type ParsedIceCandidate } from "./ice-candidates";
 /** A single flattened ICE server URL with optional credentials. */
 export interface IceServerConfig {
-    readonly url: string;
-    readonly username?: string;
-    readonly credential?: string;
+	readonly url: string;
+	readonly username?: string;
+	readonly credential?: string;
 }
 export interface ProbedCandidate {
-    readonly candidate: ParsedIceCandidate;
-    /** The server URL the browser says produced this candidate; null when not reported. */
-    readonly url: string | null;
-    /** udp / tcp / tls between the browser and the TURN server, relay candidates only. */
-    readonly relayProtocol: string | null;
-    /** Milliseconds from gather start. */
-    readonly tMs: number;
+	readonly candidate: ParsedIceCandidate;
+	/** The server URL the browser says produced this candidate; null when not reported. */
+	readonly url: string | null;
+	/** udp / tcp / tls between the browser and the TURN server, relay candidates only. */
+	readonly relayProtocol: string | null;
+	/** Milliseconds from gather start. */
+	readonly tMs: number;
 }
 export interface GatherResult {
-    readonly candidates: readonly ProbedCandidate[];
-    readonly durationMs: number;
-    readonly timedOut: boolean;
-    readonly error: string | null;
+	readonly candidates: readonly ProbedCandidate[];
+	readonly durationMs: number;
+	readonly timedOut: boolean;
+	readonly error: string | null;
 }
 export interface RelayLoopbackResult {
-    readonly connected: boolean;
-    readonly state: string;
-    readonly rttMs: number | null;
-    readonly relayProtocol: string | null;
-    readonly durationMs: number;
-    readonly error: string | null;
+	readonly connected: boolean;
+	readonly state: string;
+	readonly rttMs: number | null;
+	readonly relayProtocol: string | null;
+	readonly durationMs: number;
+	readonly error: string | null;
 }
 /** `RTCIceCandidate.relayProtocol` — Chromium and WebKit report it; lib.dom does not type it. */
 export declare function candidateRelayProtocol(c: RTCIceCandidate): string | null;

package/dist/composites/webrtc-diagnostics/endpoint-test.d.ts

@@ -1,43 +1,48 @@
-import { GatherResult, IceServerConfig, RelayLoopbackResult } from './endpoint-probe';
-import { NatMappingVerdict, SrflxObservation } from './nat-mapping';
-export type IceEndpointScheme = 'stun' | 'turn' | 'turns' | 'other';
+/**
+* "Test each endpoint" and the NAT mapping check — the orchestration around
+* the browser probes, with the row derivation kept pure so it is tested
+* without a browser.
+*/
+import { type GatherResult, type IceServerConfig, type RelayLoopbackResult } from "./endpoint-probe";
+import { type NatMappingVerdict, type SrflxObservation } from "./nat-mapping";
+export type IceEndpointScheme = "stun" | "turn" | "turns" | "other";
 export interface IceEndpoint extends IceServerConfig {
-    /** Stable key: the URL is unique within the flattened list. */
-    readonly id: string;
-    readonly scheme: IceEndpointScheme;
-    /** `?transport=` of the URL, lower-case; null when the URL names none. */
-    readonly transport: string | null;
-    readonly hasCredentials: boolean;
+	/** Stable key: the URL is unique within the flattened list. */
+	readonly id: string;
+	readonly scheme: IceEndpointScheme;
+	/** `?transport=` of the URL, lower-case; null when the URL names none. */
+	readonly transport: string | null;
+	readonly hasCredentials: boolean;
 }
 /** The shape `turnProvider.getTurnServers` answers. */
 export interface IceServerEntry {
-    readonly urls: string | readonly string[];
-    readonly username?: string;
-    readonly credential?: string;
+	readonly urls: string | readonly string[];
+	readonly username?: string;
+	readonly credential?: string;
 }
 export interface EndpointTestRow {
-    readonly id: string;
-    readonly url: string;
-    readonly scheme: IceEndpointScheme;
-    readonly transport: string | null;
-    /** The public mapping a STUN answer gave this browser, `address:port`. */
-    readonly srflx: string | null;
-    /** Whether a relay candidate was allocated. */
-    readonly relay: boolean;
-    /** udp / tcp / tls to the TURN server — from the loopback's stats, else the candidate. */
-    readonly relayProtocol: string | null;
-    /** The URL the browser attributed the srflx / relay candidate to (the ICE event `url`). */
-    readonly eventUrl: string | null;
-    /** Relay loopback outcome; null for a STUN endpoint, which cannot relay. */
-    readonly relayConnected: boolean | null;
-    readonly rttMs: number | null;
-    readonly timedOut: boolean;
-    readonly error: string | null;
+	readonly id: string;
+	readonly url: string;
+	readonly scheme: IceEndpointScheme;
+	readonly transport: string | null;
+	/** The public mapping a STUN answer gave this browser, `address:port`. */
+	readonly srflx: string | null;
+	/** Whether a relay candidate was allocated. */
+	readonly relay: boolean;
+	/** udp / tcp / tls to the TURN server — from the loopback's stats, else the candidate. */
+	readonly relayProtocol: string | null;
+	/** The URL the browser attributed the srflx / relay candidate to (the ICE event `url`). */
+	readonly eventUrl: string | null;
+	/** Relay loopback outcome; null for a STUN endpoint, which cannot relay. */
+	readonly relayConnected: boolean | null;
+	readonly rttMs: number | null;
+	readonly timedOut: boolean;
+	readonly error: string | null;
 }
 export interface NatCheckResult {
-    readonly destinations: readonly string[];
-    readonly verdict: NatMappingVerdict;
-    readonly error: string | null;
+	readonly destinations: readonly string[];
+	readonly verdict: NatMappingVerdict;
+	readonly error: string | null;
 }
 /** Queried in addition to the configured STUN servers until two distinct destinations exist. */
 export declare const FALLBACK_STUN_URLS: readonly string[];

package/dist/composites/webrtc-diagnostics/format.d.ts

@@ -1,7 +1,7 @@
 /**
- * Rendering helpers for the WebRTC diagnostics: an unmeasured value is the
- * word "unknown", never a dash that reads as zero and never a 0 (D393).
- */
+* Rendering helpers for the WebRTC diagnostics: an unmeasured value is the
+* word "unknown", never a dash that reads as zero and never a 0 (D393).
+*/
 export declare const UNKNOWN_TEXT = "unknown";
 export declare function formatMaybe<T>(value: T | null, render: (v: T) => string): string;
 export declare const fmtMs: (v: number | null) => string;

package/dist/composites/webrtc-diagnostics/ice-candidates.d.ts

@@ -1,60 +1,60 @@
 /**
- * ICE candidate parsing for the WebRTC diagnostics.
- *
- * The hub session test has to answer "what addresses did the HUB offer this
- * browser?" — the one fact that decides whether a remote or relay-only client
- * can ever reach it. The answer lives in two places: the `a=candidate` lines of
- * the hub's answer SDP and the candidates it trickles afterwards
- * (`webrtcSession.getIceCandidates`). Both are the RFC 8839 grammar:
- *
- *   candidate:<foundation> <component> <transport> <priority> <address> <port>
- *     typ <type> [raddr <address> rport <port>] [tcptype <t>] ...
- *
- * Everything that could not be read stays `null` (D393): a candidate whose
- * port did not parse has an unknown port, not port 0.
- */
-export type IceCandidateType = 'host' | 'srflx' | 'prflx' | 'relay' | 'unknown';
+* ICE candidate parsing for the WebRTC diagnostics.
+*
+* The hub session test has to answer "what addresses did the HUB offer this
+* browser?" — the one fact that decides whether a remote or relay-only client
+* can ever reach it. The answer lives in two places: the `a=candidate` lines of
+* the hub's answer SDP and the candidates it trickles afterwards
+* (`webrtcSession.getIceCandidates`). Both are the RFC 8839 grammar:
+*
+*   candidate:<foundation> <component> <transport> <priority> <address> <port>
+*     typ <type> [raddr <address> rport <port>] [tcptype <t>] ...
+*
+* Everything that could not be read stays `null` (D393): a candidate whose
+* port did not parse has an unknown port, not port 0.
+*/
+export type IceCandidateType = "host" | "srflx" | "prflx" | "relay" | "unknown";
 /** Where an address is reachable from. `tailscale` is the 100.64.0.0/10
- *  CGNAT range and Tailscale's `fd7a:115c:a1e0::/48` — reachable only from
- *  inside that tailnet, exactly like a LAN address. */
-export type AddressScope = 'loopback' | 'link-local' | 'lan' | 'tailscale' | 'mdns' | 'public' | 'unknown';
-export type AddressFamily = 'ipv4' | 'ipv6' | 'mdns' | 'unknown';
+*  CGNAT range and Tailscale's `fd7a:115c:a1e0::/48` — reachable only from
+*  inside that tailnet, exactly like a LAN address. */
+export type AddressScope = "loopback" | "link-local" | "lan" | "tailscale" | "mdns" | "public" | "unknown";
+export type AddressFamily = "ipv4" | "ipv6" | "mdns" | "unknown";
 export interface ParsedIceCandidate {
-    readonly type: IceCandidateType;
-    readonly protocol: string | null;
-    readonly address: string | null;
-    readonly port: number | null;
-    readonly relatedAddress: string | null;
-    readonly relatedPort: number | null;
-    readonly family: AddressFamily;
-    readonly scope: AddressScope;
-    /** The candidate attribute as received, without `a=`. */
-    readonly raw: string;
+	readonly type: IceCandidateType;
+	readonly protocol: string | null;
+	readonly address: string | null;
+	readonly port: number | null;
+	readonly relatedAddress: string | null;
+	readonly relatedPort: number | null;
+	readonly family: AddressFamily;
+	readonly scope: AddressScope;
+	/** The candidate attribute as received, without `a=`. */
+	readonly raw: string;
 }
 /**
- * How reachable the hub's offered set is from outside its own networks.
- * - `public-path`: at least one srflx, relay or public host candidate.
- * - `private-only`: candidates exist, all LAN / Tailscale / loopback / mDNS.
- * - `none`: the hub answered and offered nothing (yet).
- * - `unknown`: no answer was received, so nothing was measured.
- */
-export type HubReachabilityFlag = 'public-path' | 'private-only' | 'none' | 'unknown';
+* How reachable the hub's offered set is from outside its own networks.
+* - `public-path`: at least one srflx, relay or public host candidate.
+* - `private-only`: candidates exist, all LAN / Tailscale / loopback / mDNS.
+* - `none`: the hub answered and offered nothing (yet).
+* - `unknown`: no answer was received, so nothing was measured.
+*/
+export type HubReachabilityFlag = "public-path" | "private-only" | "none" | "unknown";
 export interface HubCandidateSummary {
-    readonly candidates: readonly ParsedIceCandidate[];
-    readonly fromSdp: number;
-    readonly fromTrickle: number;
-    readonly countByType: Readonly<Record<IceCandidateType, number>>;
-    readonly hasSrflx: boolean;
-    readonly hasRelay: boolean;
-    readonly hasPublicHost: boolean;
-    readonly flag: HubReachabilityFlag;
-    /** Whether the hub reported its gathering complete; null when never asked. */
-    readonly trickleDone: boolean | null;
+	readonly candidates: readonly ParsedIceCandidate[];
+	readonly fromSdp: number;
+	readonly fromTrickle: number;
+	readonly countByType: Readonly<Record<IceCandidateType, number>>;
+	readonly hasSrflx: boolean;
+	readonly hasRelay: boolean;
+	readonly hasPublicHost: boolean;
+	readonly flag: HubReachabilityFlag;
+	/** Whether the hub reported its gathering complete; null when never asked. */
+	readonly trickleDone: boolean | null;
 }
 export interface SummarizeHubCandidatesInput {
-    readonly sdpAnswer: string | null;
-    readonly trickled: readonly string[];
-    readonly trickleDone: boolean | null;
+	readonly sdpAnswer: string | null;
+	readonly trickled: readonly string[];
+	readonly trickleDone: boolean | null;
 }
 export declare function classifyAddressScope(address: string): AddressScope;
 /** Parse one candidate attribute (`candidate:…`, with or without `a=`). */

package/dist/composites/webrtc-diagnostics/nat-mapping.d.ts

@@ -1,44 +1,44 @@
 /**
- * The cheap client-side NAT mapping check.
- *
- * One peer connection asks two STUN destinations (two servers, or one server
- * on two ports) for its server-reflexive address. Both requests leave from the
- * SAME local socket, so:
- *  - the same public `address:port` from both ⇒ the NAT reuses one mapping for
- *    every destination (endpoint-independent): a srflx candidate is usable by a
- *    peer, direct media can work;
- *  - a different public port per destination ⇒ endpoint-dependent mapping
- *    ("symmetric NAT"): the mapping the hub would need is never the one STUN
- *    saw, so only a TURN relay reaches this browser.
- *
- * Browsers drop a srflx candidate identical to one already gathered, so two
- * servers agreeing usually shows as ONE candidate. That is reported as
- * `likely`, never `confirmed`, because it cannot be told apart from the second
- * server simply not answering.
- */
+* The cheap client-side NAT mapping check.
+*
+* One peer connection asks two STUN destinations (two servers, or one server
+* on two ports) for its server-reflexive address. Both requests leave from the
+* SAME local socket, so:
+*  - the same public `address:port` from both ⇒ the NAT reuses one mapping for
+*    every destination (endpoint-independent): a srflx candidate is usable by a
+*    peer, direct media can work;
+*  - a different public port per destination ⇒ endpoint-dependent mapping
+*    ("symmetric NAT"): the mapping the hub would need is never the one STUN
+*    saw, so only a TURN relay reaches this browser.
+*
+* Browsers drop a srflx candidate identical to one already gathered, so two
+* servers agreeing usually shows as ONE candidate. That is reported as
+* `likely`, never `confirmed`, because it cannot be told apart from the second
+* server simply not answering.
+*/
 export interface SrflxObservation {
-    readonly address: string;
-    readonly port: number;
-    readonly protocol: string;
-    /** The local base (`raddr` / `rport`); `0.0.0.0` / `0` when the browser hides it. */
-    readonly relatedAddress: string | null;
-    readonly relatedPort: number | null;
-    /** The STUN URL that produced it (`RTCPeerConnectionIceEvent.url`), when reported. */
-    readonly url: string | null;
+	readonly address: string;
+	readonly port: number;
+	readonly protocol: string;
+	/** The local base (`raddr` / `rport`); `0.0.0.0` / `0` when the browser hides it. */
+	readonly relatedAddress: string | null;
+	readonly relatedPort: number | null;
+	/** The STUN URL that produced it (`RTCPeerConnectionIceEvent.url`), when reported. */
+	readonly url: string | null;
 }
-export type NatMappingKind = 'endpoint-independent' | 'endpoint-dependent' | 'unknown';
-export type NatMappingConfidence = 'confirmed' | 'likely' | 'none';
+export type NatMappingKind = "endpoint-independent" | "endpoint-dependent" | "unknown";
+export type NatMappingConfidence = "confirmed" | "likely" | "none";
 export interface NatMappingVerdict {
-    readonly kind: NatMappingKind;
-    readonly confidence: NatMappingConfidence;
-    readonly reason: string;
-    /** Distinct public mappings seen per local base, e.g. `["203.0.113.7:61000"]`. */
-    readonly mappings: readonly string[];
+	readonly kind: NatMappingKind;
+	readonly confidence: NatMappingConfidence;
+	readonly reason: string;
+	/** Distinct public mappings seen per local base, e.g. `["203.0.113.7:61000"]`. */
+	readonly mappings: readonly string[];
 }
 /**
- * The distinct STUN destinations (`stun:host:port`) among the given URLs —
- * the number the check needs to be at least two. TURN URLs are excluded:
- * this check is about plain STUN binding.
- */
+* The distinct STUN destinations (`stun:host:port`) among the given URLs —
+* the number the check needs to be at least two. TURN URLs are excluded:
+* this check is about plain STUN binding.
+*/
 export declare function distinctStunDestinations(urls: readonly string[]): readonly string[];
 export declare function compareSrflxMappings(observations: readonly SrflxObservation[], stunDestinationsQueried: number): NatMappingVerdict;