@camstack/ui-library 1.2.242 → 1.2.244

package/dist/composites/camera-stream-player.d.ts

@@ -310,5 +310,21 @@ export interface CameraStreamPlayerProps {
      * element itself — the recorded-scrub receiver-credit acks are the use case.
      */
     onVideoElement?: (el: HTMLVideoElement | null) => void;
+    /**
+     * DIAGNOSTICS ONLY — the browser's ICE transport policy for every peer
+     * connection this player builds. Absent (always, in production) the policy
+     * is not set and the browser gathers host/srflx/relay as before. The WebRTC
+     * diagnostics set `'relay'` to prove whether a TURN-only path reaches the
+     * hub; see `peer-connection-config.ts` for why the player never does.
+     */
+    iceTransportPolicy?: RTCIceTransportPolicy;
+    /**
+     * Observer of every peer connection this player creates (first connect,
+     * reconnects, re-offers), handed over right after construction and before
+     * any signaling. For listeners only — the diagnostics read ICE / DTLS
+     * transitions and local candidates through `addEventListener`; a caller
+     * must never assign the `on*` handlers the player owns.
+     */
+    onPeerConnection?: (pc: RTCPeerConnection) => void;
 }
-export declare function CameraStreamPlayer({ serverUrl, streamKey, label, autoPlay, muted: initialMuted, showControls, showStats, onDebugStats, onPlaybackStats, onClientNetworkSample, probeAuthToken, onConnectTiming, className, onStateChange, onError, onReconnectAttempt, overlay, createSession, sendAnswer, handleOffer, getIceServers, addIceCandidate, getIceCandidates, closeSession, getSessionState, getSessionDebug, applyDownlinkProbe, reoffer, posterUrl, hintsOverride, onAdaptiveHints, reconnectSignal, onControlChannel, onVideoElement, }: CameraStreamPlayerProps): import("react").JSX.Element;
+export declare function CameraStreamPlayer({ serverUrl, streamKey, label, autoPlay, muted: initialMuted, showControls, showStats, onDebugStats, onPlaybackStats, onClientNetworkSample, probeAuthToken, onConnectTiming, className, onStateChange, onError, onReconnectAttempt, overlay, createSession, sendAnswer, handleOffer, getIceServers, addIceCandidate, getIceCandidates, closeSession, getSessionState, getSessionDebug, applyDownlinkProbe, reoffer, posterUrl, hintsOverride, onAdaptiveHints, reconnectSignal, onControlChannel, onVideoElement, iceTransportPolicy, onPeerConnection, }: CameraStreamPlayerProps): import("react").JSX.Element;

package/dist/composites/index.d.ts

@@ -23,6 +23,21 @@ export { StreamDebugOverlay } from './stream-debug/stream-debug-overlay';
 export type { StreamDebugOverlayProps } from './stream-debug/stream-debug-overlay';
 export { deriveWebrtcDebugStats, freezeVerdict, } from './stream-debug/webrtc-debug-stats';
 export type { DeriveWebrtcDebugStatsInput, FreezeVerdict, FreezeVerdictKind, ResolutionMark, StreamDebugSample, WebrtcDebugStats, WebrtcDebugWindow, } from './stream-debug/webrtc-debug-stats';
+export { buildPeerConnectionConfig } from './peer-connection-config';
+export { EndpointResultsCard, EndpointTestCard, NatResultCard, } from './webrtc-diagnostics/EndpointTestCard';
+export type { EndpointTestCardProps } from './webrtc-diagnostics/EndpointTestCard';
+export { HUB_SESSION_RUN_MS, HubSessionTestCard, pinnedStreamChoices, } from './webrtc-diagnostics/HubSessionTestCard';
+export type { HubSessionTestCardProps } from './webrtc-diagnostics/HubSessionTestCard';
+export { RunReport } from './webrtc-diagnostics/RunReport';
+export { classifyAddressScope, parseIceCandidate, summarizeHubCandidates, } from './webrtc-diagnostics/ice-candidates';
+export type { HubCandidateSummary, HubReachabilityFlag, ParsedIceCandidate, } from './webrtc-diagnostics/ice-candidates';
+export { compareSrflxMappings } from './webrtc-diagnostics/nat-mapping';
+export type { NatMappingVerdict } from './webrtc-diagnostics/nat-mapping';
+export { emptySessionRun, finalizeSessionRun, reduceSessionRun, } from './webrtc-diagnostics/session-run';
+export type { HubSessionRunReport, SessionRunEvent, SessionRunState, } from './webrtc-diagnostics/session-run';
+export { classifySessionVerdict } from './webrtc-diagnostics/session-verdict';
+export type { DiagnosticIcePolicy, SessionVerdict, SessionVerdictLayer, } from './webrtc-diagnostics/session-verdict';
+export type { EndpointTestRow, IceServerEntry, NatCheckResult, } from './webrtc-diagnostics/endpoint-test';
 export { AutotrackSection } from './cap-settings/AutotrackSection';
 export { ConsumablesPanel } from './cap-settings/ConsumablesPanel';
 export type { CapSettingsComponentProps } from './cap-settings/index';

package/dist/composites/peer-connection-config.d.ts

@@ -0,0 +1,13 @@
+/**
+ * The player's `RTCConfiguration`, in one place for every connect path.
+ *
+ * The player never forces `iceTransportPolicy: 'relay'` on its own (werift's
+ * relay forward is unreliable across two real TURN servers, and relay would
+ * defeat the direct LAN/Tailscale path). The policy exists for the WebRTC
+ * diagnostics only, which run the SAME player once with `all` and once with
+ * `relay` to tell a reachable relay path from a dead one. Absent, the key is
+ * not set at all, so a production connect is byte-for-byte what it was.
+ */
+/** Public STUN kept as a fallback beside whatever the hub's TURN provider returns. */
+export declare const FALLBACK_STUN_SERVER: RTCIceServer;
+export declare function buildPeerConnectionConfig(iceServers: readonly RTCIceServer[] | undefined, iceTransportPolicy: RTCIceTransportPolicy | undefined): RTCConfiguration;

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

@@ -0,0 +1,15 @@
+import { ReactNode } from 'react';
+import { EndpointTestRow, IceServerEntry, NatCheckResult } from './endpoint-test';
+export interface EndpointTestCardProps {
+    /** 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[];
+}): ReactNode;
+/** The NAT mapping verdict for this browser. */
+export declare function NatResultCard({ result }: {
+    readonly result: NatCheckResult;
+}): ReactNode;
+export declare function EndpointTestCard({ loadServers }: EndpointTestCardProps): ReactNode;

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

@@ -0,0 +1,18 @@
+import { ReactNode } from 'react';
+import { UseDeviceWebrtcTrpc } from '../../hooks/use-device-webrtc';
+import { 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;
+}
+export declare const HUB_SESSION_RUN_MS = 15000;
+/** 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;

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

@@ -0,0 +1,6 @@
+import { ReactNode } from 'react';
+import { 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

@@ -0,0 +1,36 @@
+import { 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;
+}
+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;
+}
+export interface GatherResult {
+    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;
+}
+/** `RTCIceCandidate.relayProtocol` — Chromium and WebKit report it; lib.dom does not type it. */
+export declare function candidateRelayProtocol(c: RTCIceCandidate): string | null;
+/** One local candidate from an ICE event, or null for the end-of-candidates event. */
+export declare function probedCandidateFromEvent(e: RTCPeerConnectionIceEvent, tMs: number): ProbedCandidate | null;
+export declare function gatherCandidates(servers: readonly IceServerConfig[], policy: RTCIceTransportPolicy, timeoutMs?: number): Promise<GatherResult>;
+export declare function relayLoopback(servers: readonly IceServerConfig[], timeoutMs?: number): Promise<RelayLoopbackResult>;

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

@@ -0,0 +1,54 @@
+import { GatherResult, IceServerConfig, RelayLoopbackResult } from './endpoint-probe';
+import { NatMappingVerdict, 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;
+}
+/** The shape `turnProvider.getTurnServers` answers. */
+export interface IceServerEntry {
+    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;
+}
+export interface NatCheckResult {
+    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[];
+export declare function schemeOf(url: string): IceEndpointScheme;
+export declare function transportOf(url: string): string | null;
+/** One row per URL: an entry's `urls` may be a string or a list. */
+export declare function flattenIceServers(servers: readonly IceServerEntry[]): readonly IceEndpoint[];
+export declare function endpointRowFromProbe(endpoint: IceEndpoint, gather: GatherResult, loopback: RelayLoopbackResult | null): EndpointTestRow;
+/** Gather against ONE endpoint; for a TURN endpoint, also prove the relay forwards. */
+export declare function testEndpoint(endpoint: IceEndpoint): Promise<EndpointTestRow>;
+/** The STUN destinations the NAT check queries: configured first, public fallbacks to reach two. */
+export declare function natCheckDestinations(endpoints: readonly IceEndpoint[]): readonly string[];
+export declare function srflxObservations(gather: GatherResult): readonly SrflxObservation[];
+export declare function runNatCheck(endpoints: readonly IceEndpoint[]): Promise<NatCheckResult>;

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

@@ -0,0 +1,11 @@
+/**
+ * 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;
+export declare const fmtCount: (v: number | null) => string;
+export declare const fmtBytes: (v: number | null) => string;
+export declare const fmtPercent: (v: number | null) => string;
+export declare const fmtText: (v: string | null) => string;

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

@@ -0,0 +1,66 @@
+/**
+ * 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';
+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;
+}
+/**
+ * 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;
+}
+export interface SummarizeHubCandidatesInput {
+    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=`). */
+export declare function parseIceCandidate(line: string): ParsedIceCandidate | null;
+/** Every `a=candidate` line of an SDP, in order. */
+export declare function candidateLinesFromSdp(sdp: string): readonly string[];
+export declare function countCandidateTypes(candidates: readonly ParsedIceCandidate[]): Readonly<Record<IceCandidateType, number>>;
+/** The hub's offered candidates: answer SDP plus trickle, deduplicated. */
+export declare function summarizeHubCandidates(input: SummarizeHubCandidatesInput): HubCandidateSummary;

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

@@ -0,0 +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.
+ */
+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;
+}
+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[];
+}
+/**
+ * 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;

package/dist/composites/webrtc-diagnostics/session-run.d.ts

@@ -0,0 +1,125 @@
+import { WebrtcSessionDebug } from '@camstack/types';
+import { StreamDebugSample, WebrtcDebugStats } from '../stream-debug/webrtc-debug-stats';
+import { HubCandidateSummary, IceCandidateType, ParsedIceCandidate } from './ice-candidates';
+import { DiagnosticIcePolicy, SessionVerdict } from './session-verdict';
+export type SessionRunEvent = {
+    readonly kind: 'offer-answered';
+    readonly at: number;
+    readonly sessionId: string;
+    readonly sdpAnswer: string;
+} | {
+    readonly kind: 'hub-candidates';
+    readonly at: number;
+    readonly candidates: readonly string[];
+    readonly done: boolean;
+} | {
+    readonly kind: 'local-candidate';
+    readonly at: number;
+    readonly candidate: string;
+    readonly url: string | null;
+    readonly relayProtocol: string | null;
+} | {
+    readonly kind: 'ice-state';
+    readonly at: number;
+    readonly state: string;
+} | {
+    readonly kind: 'dtls-state';
+    readonly at: number;
+    readonly state: string;
+} | {
+    readonly kind: 'peer-state';
+    readonly at: number;
+    readonly state: string;
+} | {
+    readonly kind: 'first-frame';
+    readonly at: number;
+} | {
+    readonly kind: 'sample';
+    readonly at: number;
+    readonly sample: StreamDebugSample;
+} | {
+    readonly kind: 'reconnect';
+    readonly at: number;
+} | {
+    readonly kind: 'error';
+    readonly at: number;
+    readonly message: string;
+};
+export interface StateMark {
+    readonly state: string;
+    readonly at: number;
+}
+export interface LocalCandidateRecord {
+    readonly candidate: ParsedIceCandidate;
+    readonly url: string | null;
+    readonly relayProtocol: string | null;
+}
+export interface SessionRunState {
+    readonly policy: DiagnosticIcePolicy;
+    readonly sessionIds: readonly string[];
+    readonly sdpAnswer: string | null;
+    readonly trickled: readonly string[];
+    readonly trickleDone: boolean | null;
+    readonly local: readonly LocalCandidateRecord[];
+    readonly ice: readonly StateMark[];
+    readonly dtls: readonly StateMark[];
+    readonly peer: readonly StateMark[];
+    readonly firstFrameAt: number | null;
+    /** The last sample that carried client stats — a later failed poll keeps it. */
+    readonly lastStats: WebrtcDebugStats | null;
+    readonly lastServer: WebrtcSessionDebug | null;
+    readonly maxServerPacketsSent: number | null;
+    readonly lastServerError: string | null;
+    readonly samples: number;
+    readonly reconnects: number;
+    readonly errors: readonly string[];
+}
+export declare function emptySessionRun(policy: DiagnosticIcePolicy): SessionRunState;
+export declare function reduceSessionRun(state: SessionRunState, event: SessionRunEvent): SessionRunState;
+export interface SessionTimeline {
+    readonly iceConnectedMs: number | null;
+    readonly dtlsConnectedMs: number | null;
+    readonly firstFrameMs: number | null;
+    readonly iceFinalState: string | null;
+    readonly dtlsFinalState: string | null;
+}
+export interface SessionPath {
+    /** `local/remote` candidate types of the selected pair, e.g. `relay/host`. */
+    readonly pairType: string | null;
+    readonly protocol: string | null;
+    readonly rttMs: number | null;
+}
+export interface SessionMedia {
+    readonly clientBytesReceived: number | null;
+    readonly clientPacketsReceived: number | null;
+    readonly framesDecoded: number | null;
+    readonly serverPacketsSent: number | null;
+    readonly serverAlive: boolean | null;
+    readonly servedTier: string | null;
+    readonly egressLeg: string | null;
+    readonly lossPercent: number | null;
+    readonly freezeCount: number | null;
+    readonly totalFreezeMs: number | null;
+    readonly pliCount: number | null;
+    readonly nackCount: number | null;
+}
+export interface SessionLocalCandidates {
+    readonly countByType: Readonly<Record<IceCandidateType, number>>;
+    readonly relayProtocols: readonly string[];
+    readonly urls: readonly string[];
+}
+export interface HubSessionRunReport {
+    readonly policy: DiagnosticIcePolicy;
+    readonly durationMs: number;
+    readonly sessionIds: readonly string[];
+    readonly hub: HubCandidateSummary;
+    readonly local: SessionLocalCandidates;
+    readonly timeline: SessionTimeline;
+    readonly path: SessionPath;
+    readonly media: SessionMedia;
+    readonly reconnects: number;
+    readonly errors: readonly string[];
+    readonly serverError: string | null;
+    readonly verdict: SessionVerdict;
+}
+export declare function finalizeSessionRun(state: SessionRunState, durationMs: number): HubSessionRunReport;

package/dist/composites/webrtc-diagnostics/session-verdict.d.ts

@@ -0,0 +1,29 @@
+import { HubReachabilityFlag } from './ice-candidates';
+export type SessionVerdictLayer = 'transport' | 'hub-dtls' | 'media-black-hole' | 'hub-not-sending' | 'loss-keyframe' | 'healthy' | 'unknown';
+export interface SessionVerdict {
+    readonly layer: SessionVerdictLayer;
+    readonly title: string;
+    readonly detail: string;
+}
+export type DiagnosticIcePolicy = 'all' | 'relay';
+export interface VerdictInput {
+    readonly policy: DiagnosticIcePolicy;
+    readonly durationMs: number;
+    readonly iceConnected: boolean;
+    readonly iceFinalState: string | null;
+    readonly dtlsConnected: boolean;
+    readonly dtlsFinalState: string | null;
+    readonly hubFlag: HubReachabilityFlag;
+    readonly clientPacketsReceived: number | null;
+    readonly framesDecoded: number | null;
+    readonly serverPacketsSent: number | null;
+    readonly pliCount: number | null;
+    readonly freezeCount: number | null;
+    readonly lossPercent: number | null;
+}
+/** PLIs the browser may send in one run before it counts as a storm: one at
+ *  start-up plus one recovery is normal; three means keyframes keep breaking. */
+export declare const PLI_STORM_COUNT = 3;
+/** Packet loss over the run above which a freeze is attributed to loss. */
+export declare const LOSS_PERCENT_HIGH = 2;
+export declare function classifySessionVerdict(input: VerdictInput): SessionVerdict;

package/dist/generated/system-hooks.d.ts

@@ -1529,6 +1529,8 @@ export declare const usePipelineOrchestratorSetCameraStepToggle: typeof trpc.pip
 export declare const usePipelineOrchestratorGetCameraStepOverrides: typeof trpc.pipelineOrchestrator.getCameraStepOverrides.useQuery;
 /** Generated alias around `trpc.pipelineOrchestrator.setCameraStepOverride.useMutation`. */
 export declare const usePipelineOrchestratorSetCameraStepOverride: typeof trpc.pipelineOrchestrator.setCameraStepOverride.useMutation;
+/** Generated alias around `trpc.pipelineOrchestrator.setCameraStepSettings.useMutation`. */
+export declare const usePipelineOrchestratorSetCameraStepSettings: typeof trpc.pipelineOrchestrator.setCameraStepSettings.useMutation;
 /** Generated alias around `trpc.pipelineOrchestrator.setCameraPipelineForAgent.useMutation`. */
 export declare const usePipelineOrchestratorSetCameraPipelineForAgent: typeof trpc.pipelineOrchestrator.setCameraPipelineForAgent.useMutation;
 /** Generated alias around `trpc.pipelineOrchestrator.resolvePipeline.useQuery`. */