@streaming-cdn/rtc-web 1.3.12 → 1.3.14

package/LICENSE.txt

@@ -0,0 +1,15 @@
+STREAMING CDN SDK BINARY LICENSE
+
+Copyright (c) 2026. All rights reserved.
+
+The SDK binaries, public API declarations, documentation, and example code are
+licensed for use with an active Streaming CDN service account and are governed
+by the applicable service agreement.
+
+Except where third-party notices state otherwise, redistribution, modification,
+reverse engineering, decompilation, and creation of derivative SDK products are
+not permitted without prior written authorization.
+
+Example applications may be modified and incorporated into an application that
+uses the Streaming CDN service. No ownership rights in the SDK binaries or
+service are transferred.

package/NOTICE.md

@@ -0,0 +1,8 @@
+# Third-party notices
+
+The SDK uses platform and media-runtime components distributed under their own
+licenses. Those components remain subject to their respective license terms.
+
+The binary SDK license applies only to the Streaming CDN integration layer.
+Applications must also comply with Apple, Google, browser, notification-service,
+and media-runtime requirements applicable to the selected integration modules.

package/README.md

@@ -1,4 +1,4 @@
-# RTC Web SDK 1.3.12
+# RTC Web SDK 1.3.14
 
 The customer package contains compiled ESM/UMD JavaScript and TypeScript declarations. It intentionally excludes implementation source and source maps. Example source remains available under `examples/`.
 
@@ -152,14 +152,57 @@ side receives a terminal call state. Manual integrations must call
 `transport: "mesh"` (the default) opens one connection per pair, which suits
 direct calls and small rooms. `transport: "sfu"` sends media once to the
 platform SFU and receives each remote participant from it, which is what a
-large room needs — media no longer grows with the participant count. The
-credential, the events and the rest of the API are identical, so an
-application switches transports without changing its UI or call flow. SDP for
-the SFU travels over `/v1/rtc/sfu/*` authenticated by the same signaling
-token; no separate credential exists. With a single uplink there is no
-per-connection tier, so `peerquality` is not emitted on this transport and
-`setQuality` applies to the uplink directly. The React Native adapter
-currently ships the mesh transport.
+large room needs — media no longer grows with the participant count.
+`transport: "auto"` picks the SFU for `meeting` mode and the mesh for `voice`
+and `video` calls. The credential, the events and the rest of the API are
+identical, so an application switches transports without changing its UI or
+call flow. SDP for the SFU travels over `/v1/rtc/sfu/*` authenticated by the
+same signaling token; no separate credential exists.
+
+The SFU uplink publishes three simulcast layers (720p/360p/180p-class), so the
+SFU can hand every subscriber the layer their downlink carries. `setQuality`
+caps which layers are encoded; there is no per-connection tier on a single
+uplink, so `peerquality` is not emitted on this transport. To deliberately
+receive a lower layer for one participant — a thumbnail tile has no use for
+720p — call `setRemoteQuality(participantId, "low" | "medium" | "high")` on
+the room client (`getNativeClient()`); the publisher keeps sending every
+layer. The React Native adapter has the same transport option and the same
+`setRemoteQuality` on the client.
+
+## Active speaker
+
+The client samples WebRTC audio levels once a second on both transports and
+emits `activespeaker` (`{ participantId }`, or `null` when the room is
+silent). The choice has hysteresis — the highlight only moves when somebody is
+clearly louder than the current speaker — so two people at similar volume do
+not flap the indicator. Use it to light up the speaking tile:
+
+```ts
+media.addEventListener("activespeaker", ({ detail }) => {
+  highlightTile(detail.detail.participantId);
+});
+```
+
+## Picture-in-picture
+
+`createPictureInPictureController(media.getNativeClient())` floats a
+participant's video in the browser's always-on-top window while the user works
+elsewhere. `enter(participantId?)` must run inside a click handler — browsers
+require a user gesture — and picks the first remote participant by default,
+falling back to the local preview. `onLeave` fires when the user closes the
+floating window; `supported` is false where the browser has no PiP.
+
+```ts
+import { createPictureInPictureController } from "@streaming-cdn/rtc-web";
+
+const pip = createPictureInPictureController(media.getNativeClient(), {
+  onLeave: () => showInlineVideoAgain()
+});
+pipButton.onclick = () => { void pip.enter(); };
+```
+
+Android and iOS system PiP require native application support and are on the
+SDK roadmap.
 
 ## Quality and codecs
 

package/dist/active-speaker.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Active speaker detection.
+ *
+ * A call UI wants to highlight whoever is talking without every application
+ * re-implementing audio-level plumbing. Levels come from WebRTC's own
+ * `inbound-rtp` audio stats — no AudioContext, no extra decoding — and the
+ * choice has hysteresis: the floor only changes hands when somebody is
+ * clearly louder than the current speaker, otherwise two people at similar
+ * volume would flap the highlight every second.
+ */
+export interface SpeakerLevel {
+    participantId: string;
+    /** WebRTC audioLevel, 0..1. */
+    level: number;
+}
+/** Below this a level is background noise, not speech. */
+export declare const SPEAKER_NOISE_FLOOR = 0.02;
+/** A challenger must be this much louder than the current speaker to take over. */
+export declare const SPEAKER_TAKEOVER_RATIO = 1.4;
+export declare function pickActiveSpeaker(levels: SpeakerLevel[], previous: string | null, noiseFloor?: number, takeoverRatio?: number): string | null;
+/** Reads the audio level of each inbound audio RTP stream, keyed by mid. */
+export declare function readAudioLevels(report: Iterable<Record<string, unknown>>): Array<{
+    mid: string | null;
+    level: number;
+}>;

package/dist/index.d.ts

@@ -0,0 +1,341 @@
+export { createPictureInPictureController } from "./picture-in-picture";
+export type { PictureInPictureController, PictureInPictureOptions } from "./picture-in-picture";
+export { pickActiveSpeaker, SPEAKER_NOISE_FLOOR, SPEAKER_TAKEOVER_RATIO } from "./active-speaker";
+export type { SpeakerLevel } from "./active-speaker";
+export type RtcMode = "voice" | "video" | "meeting";
+/**
+ * How media travels. `mesh` (the default) opens one connection per pair and
+ * suits direct calls and small rooms; `sfu` sends media once to the platform
+ * SFU and pulls each remote participant from it, which is what a large room
+ * needs. `auto` picks by product: meetings — rooms that grow — take the SFU,
+ * voice and video calls stay on the mesh. The rest of the public contract is
+ * identical either way.
+ */
+export type RtcTransport = "mesh" | "sfu" | "auto";
+export type RtcQuality = "auto" | "audio" | "low" | "medium" | "high";
+export type RtcVideoCodec = "auto" | "vp8" | "h264";
+export type RtcIceTransportPolicy = "all" | "relay";
+export type RtcConnectionState = "initialized" | "joining" | "connected" | "reconnecting" | "disconnected" | "failed";
+export interface RtcCredential {
+    signalingToken: string;
+    signalingUrl: string;
+    iceServers?: RTCIceServer[];
+    iceServersExpiresAt?: string;
+    roomId: string;
+    participantId?: string;
+    externalUserId?: string;
+    telemetryToken?: string;
+    telemetryEndpoint?: string;
+    telemetryExpiresAt?: string;
+}
+export interface RtcClientOptions {
+    credential: RtcCredential;
+    mode: RtcMode;
+    /** Reuses media acquired by a pre-join device room instead of requesting it again. */
+    localStream?: MediaStream | null;
+    /** Publishes microphone audio when true. */
+    audio?: boolean;
+    /** Publishes camera video when true. */
+    video?: boolean;
+    /** Creates an audio recvonly transceiver when local audio is not published. */
+    receiveAudio?: boolean;
+    /** Creates a video recvonly transceiver when local video is not published. */
+    receiveVideo?: boolean;
+    /** Initial outbound video quality. "auto" adapts between low, medium and high. */
+    quality?: RtcQuality;
+    /** Preferred video codec. Negotiation still retains compatible fallback codecs. */
+    preferredVideoCodec?: RtcVideoCodec;
+    /** Uses every ICE route by default. Set relay to diagnose or avoid a poor direct carrier route. */
+    iceTransportPolicy?: RtcIceTransportPolicy;
+    /** Media transport. Defaults to the peer mesh; "sfu" routes media through the platform SFU. */
+    transport?: RtcTransport;
+    /** Enables automatic quality changes when quality is "auto". */
+    adaptiveQuality?: boolean;
+    autoJoin?: boolean;
+    statsInterval?: number;
+    telemetryInterval?: number;
+    autoReportStats?: boolean;
+    telemetryEndpoint?: string;
+    preflightProbeUrl?: string;
+    peerConnection?: RTCPeerConnection | null;
+    statsProvider?: () => Promise<Partial<RtcQualitySample>>;
+    onEvent?: (event: RtcSdkEvent) => void;
+}
+export interface RtcSdkEvent<T = unknown> {
+    type: string;
+    timestamp: string;
+    detail: T;
+}
+export interface RtcQualitySample {
+    sampleType: "preflight" | "runtime" | "final";
+    sampledAt: string;
+    connectionState: string;
+    mediaScore: number | null;
+    networkScore: number;
+    estimatedMos: number;
+    rttMs: number | null;
+    jitterMs: number | null;
+    packetLossPct: number | null;
+    /** Packet loss since the previous sample. packetLossPct uses the same interval. */
+    packetLossCumulativePct: number | null;
+    packetsLost: number | null;
+    packetsReceived: number | null;
+    inboundBitrateBps: number | null;
+    outboundBitrateBps: number | null;
+    availableOutgoingBitrateBps: number | null;
+    framesPerSecond: number | null;
+    frameWidth: number | null;
+    frameHeight: number | null;
+    framesDropped: number | null;
+    freezeCount: number | null;
+    freezeDurationMs: number | null;
+    concealedSamples: number | null;
+    codec: string | null;
+    transportProtocol: string | null;
+    candidateType: string | null;
+    qualityLimitationReason: string | null;
+    deviceMemoryGb: number | null;
+    effectiveConnectionType: string | null;
+}
+export interface RtcStats {
+    state: RtcConnectionState;
+    participantCount: number;
+    audioEnabled: boolean;
+    videoEnabled: boolean;
+    screenShareEnabled: boolean;
+    latestMediaScore: number | null;
+    latestQuality: RtcQualitySample | null;
+    sampledAt: string;
+}
+export interface RtcPreflightResult {
+    passed: boolean;
+    sampledAt: string;
+    secureContext: boolean;
+    mediaPermission: "granted" | "denied" | "unavailable";
+    microphoneCount: number;
+    cameraCount: number;
+    probeLatencyMs: number | null;
+    effectiveConnectionType: string | null;
+    issues: string[];
+}
+export interface RtcParticipant {
+    id: string;
+    name: string;
+    picture?: string;
+    role: string;
+}
+export interface RtcRemoteStream {
+    participant: RtcParticipant;
+    stream: MediaStream;
+}
+export declare class RtcClient extends EventTarget {
+    readonly mode: RtcMode;
+    private readonly options;
+    private client;
+    private peerConnection;
+    private state;
+    private latestMediaScore;
+    private latestQuality;
+    private statsTimer;
+    private statsRunning;
+    private previousCounters;
+    private lastTelemetryAt;
+    private joinPromise;
+    private requestedQuality;
+    private effectiveQuality;
+    private poorQualitySamples;
+    private goodQualitySamples;
+    constructor(options: RtcClientOptions);
+    initialize(): Promise<this>;
+    join(): Promise<void>;
+    leave(): Promise<void>;
+    setMuted(muted: boolean): Promise<void>;
+    setCameraEnabled(enabled: boolean): Promise<void>;
+    setVideoTrack(track: MediaStreamTrack): Promise<void>;
+    setScreenShareEnabled(enabled: boolean): Promise<void>;
+    setDevice(device: MediaDeviceInfo): Promise<void>;
+    setQuality(quality: RtcQuality): Promise<void>;
+    setPreferredVideoCodec(codec: RtcVideoCodec): Promise<void>;
+    getDevices(): Promise<MediaDeviceInfo[]>;
+    getParticipants(): ReadonlyArray<RtcParticipant>;
+    getLocalStream(): MediaStream | null;
+    getRemoteStreams(): RtcRemoteStream[];
+    setPeerConnection(peerConnection: RTCPeerConnection | null): void;
+    sendChatMessage(message: string, participantIds?: string[]): Promise<void>;
+    sendControlMessage(action: string, detail?: Record<string, unknown>): Promise<void>;
+    createPoll(question: string, options: string[], config?: {
+        anonymous?: boolean;
+        hideVotes?: boolean;
+    }): Promise<void>;
+    votePoll(pollId: string, optionIndex: number): Promise<void>;
+    requestStageAccess(): Promise<void>;
+    cancelStageAccess(): Promise<void>;
+    joinStage(): Promise<void>;
+    leaveStage(): Promise<void>;
+    grantStageAccess(participantIds: string[]): Promise<void>;
+    denyStageAccess(participantIds: string[]): Promise<void>;
+    startRecording(allowMultiple?: boolean): Promise<void>;
+    stopRecording(recordingId?: string): Promise<void>;
+    pauseRecording(recordingId?: string): Promise<void>;
+    resumeRecording(recordingId?: string): Promise<void>;
+    runPreflight(options?: {
+        requestMedia?: boolean;
+        probeUrl?: string;
+    }): Promise<RtcPreflightResult>;
+    collectQualitySample(sampleType?: RtcQualitySample["sampleType"]): Promise<RtcQualitySample>;
+    reportQuality(sample: Partial<RtcQualitySample>): Promise<void>;
+    getStats(): RtcStats;
+    /** Escape hatch for advanced integrations. Prefer the stable SDK methods when possible. */
+    getNativeClient<T = unknown>(): T | null;
+    destroy(): void;
+    private handleNativeEvent;
+    private startStats;
+    private sampleAndReport;
+    private stopStats;
+    private adaptQuality;
+    private applyEffectiveQuality;
+    private requireClient;
+    private emit;
+}
+export declare function createRtcClient(options: RtcClientOptions): Promise<RtcClient>;
+export interface RtcIncomingCall {
+    id: string;
+    mode: "voice" | "video";
+    status: string;
+    caller: {
+        id: string;
+        name: string;
+    };
+    metadata?: Record<string, unknown>;
+    createdAt?: string;
+    expiresAt?: string;
+}
+export interface RtcPresenceUser {
+    externalUserId: string;
+    displayName: string;
+    platform: "web" | "ios" | "android";
+    devices: number;
+    connectedAt: string;
+}
+export type RtcClientTokenReason = "initial" | "expiring" | "reconnect" | "unauthorized";
+export interface RtcClientIdentityToken {
+    token: string;
+    expiresAt?: string;
+}
+export type RtcClientTokenProvider = (context: {
+    reason: RtcClientTokenReason;
+    previousExpiresAt?: string;
+}) => Promise<string | RtcClientIdentityToken>;
+export interface RtcIncomingClientOptions {
+    /** Fixed short-lived token. Prefer tokenProvider for production applications. */
+    token?: string;
+    /** Expiration timestamp for a fixed token, when known. */
+    tokenExpiresAt?: string;
+    /** Fetches a fresh short-lived token from the application's trusted backend. */
+    tokenProvider?: RtcClientTokenProvider;
+    /** Refresh lead time. Defaults to five minutes and scales down for short-lived tokens. */
+    tokenRefreshSkewMs?: number;
+    signalingUrl?: string;
+    apiBaseUrl?: string;
+    autoConnect?: boolean;
+    mount?: HTMLElement | string | null;
+    reconnect?: boolean;
+    reportSignalingDiagnostics?: boolean;
+    /** Enables call audio. Defaults to true. */
+    sounds?: boolean;
+    /** Custom incoming ringtone URL. A built-in tone is used when omitted. */
+    ringtoneUrl?: string;
+    /** Custom outgoing ringback URL. A built-in tone is used when omitted. */
+    ringbackUrl?: string;
+    /** How long terminal call states remain visible in the built-in UI. Defaults to 1600 ms. */
+    terminalStateDurationMs?: number;
+    onEvent?: (event: RtcSdkEvent) => void;
+}
+export interface RtcCallActionResult {
+    call: Record<string, unknown>;
+    credential?: RtcCredential;
+    callerCredential?: RtcCredential;
+}
+/**
+ * Unlock call audio from a click/tap handler before awaiting network work.
+ * Browsers may otherwise block incoming ringtones started by signaling events.
+ */
+export declare function unlockRtcCallAudio(): Promise<boolean>;
+export declare class RtcIncomingClient extends EventTarget {
+    private readonly options;
+    private socket;
+    private stopped;
+    private reconnectAttempt;
+    private reconnectTimer;
+    private heartbeatTimer;
+    private heartbeatDeadline;
+    private currentCall;
+    private outgoingCallId;
+    private mount;
+    private terminalTimer;
+    private tokenRefreshTimer;
+    private tokenRequest;
+    private currentToken;
+    private currentTokenExpiresAt?;
+    private readonly callAudio;
+    private readonly mediaClients;
+    private readonly activeCallIds;
+    private readonly seenInvitationIds;
+    private startCallRequest;
+    private lastDisconnect;
+    constructor(options: RtcIncomingClientOptions);
+    connect(): this;
+    setMount(target: HTMLElement | string | null): void;
+    /** Binds media lifetime to a call. Terminal call states automatically leave and destroy it. */
+    attachMediaClient(callId: string, media: RtcClient): () => void;
+    /**
+     * Rings everyone in `targets` as a single call and connects whoever answers
+     * first; the rest stop ringing on their own. `target` still works and means a
+     * call with one recipient.
+     */
+    startCall(input: {
+        mode: "voice" | "video";
+        target?: {
+            id: string;
+            name: string;
+        };
+        targets?: Array<{
+            id: string;
+            name: string;
+        }>;
+        metadata?: Record<string, unknown>;
+        idempotencyKey?: string;
+    }): Promise<RtcCallActionResult>;
+    accept(callId?: string | undefined): Promise<RtcCallActionResult>;
+    reject(callId?: string | undefined): Promise<RtcCallActionResult>;
+    busy(callId?: string | undefined): Promise<RtcCallActionResult>;
+    end(callId: string): Promise<RtcCallActionResult>;
+    cancel(callId: string): Promise<RtcCallActionResult>;
+    /** Injects an incoming call received through the application's own push or signaling channel. */
+    handleIncomingCall(call: RtcIncomingCall): void;
+    /** Applies a call state received through the application's own push or signaling channel. */
+    handleCallUpdate(call: {
+        id: string;
+        status: string;
+    }): void;
+    disconnect(): void;
+    destroy(): void;
+    private openSocket;
+    private handleSignal;
+    private callAction;
+    private request;
+    private renderIncoming;
+    private dismiss;
+    private showTerminal;
+    private clearUi;
+    private scheduleReconnect;
+    private resolveToken;
+    private tokenNeedsRefresh;
+    private refreshSkew;
+    private scheduleTokenRefresh;
+    private releaseMedia;
+    private reportSignalingDiagnostic;
+    private emit;
+}
+export declare function createRtcIncomingClient(options: RtcIncomingClientOptions): RtcIncomingClient;
+export declare const version = "1.3.14";

package/dist/native-room.d.ts

@@ -0,0 +1,104 @@
+export interface NativeRoomIdentity {
+    participantId: string;
+    externalUserId: string;
+    displayName: string;
+    platform: string;
+}
+export interface NativeRoomCredential {
+    signalingToken: string;
+    signalingUrl: string;
+    roomId: string;
+    participantId: string;
+    externalUserId?: string;
+    iceServers?: RTCIceServer[];
+    iceServersExpiresAt?: string;
+}
+export interface NativeRoomOptions {
+    credential: NativeRoomCredential;
+    audio: boolean;
+    video: boolean;
+    receiveAudio: boolean;
+    receiveVideo: boolean;
+    quality?: NativeRoomQuality;
+    preferredVideoCodec?: NativeRoomVideoCodec;
+    iceTransportPolicy?: RTCIceTransportPolicy;
+    localStream?: MediaStream | null;
+    onEvent: (type: string, detail: unknown) => void;
+}
+export type NativeRoomQuality = "audio" | "low" | "medium" | "high";
+export type NativeRoomVideoCodec = "auto" | "vp8" | "h264";
+export declare class NativeRoomClient {
+    private readonly options;
+    private socket;
+    private localStream;
+    private screenStream;
+    private readonly peers;
+    private joinPromise;
+    private resolveJoin;
+    private rejectJoin;
+    private joined;
+    private stopped;
+    private reconnectAttempt;
+    private reconnectTimer;
+    private heartbeatTimer;
+    private qualityTimer;
+    private speakerTimer;
+    private activeSpeaker;
+    private heartbeatDeadline;
+    private quality;
+    private preferredVideoCodec;
+    private signalQueue;
+    private socketGeneration;
+    constructor(options: NativeRoomOptions);
+    initialize(): Promise<void>;
+    join(): Promise<void>;
+    leave(): Promise<void>;
+    setMuted(muted: boolean): void;
+    setCameraEnabled(enabled: boolean): Promise<void>;
+    setScreenShareEnabled(enabled: boolean): Promise<void>;
+    setDevice(device: MediaDeviceInfo): Promise<void>;
+    setQuality(quality: NativeRoomQuality): Promise<void>;
+    private static clampToCeiling;
+    setPreferredVideoCodec(codec: NativeRoomVideoCodec): Promise<void>;
+    getParticipants(): NativeRoomIdentity[];
+    getLocalStream(): MediaStream | null;
+    setVideoTrack(track: MediaStreamTrack): Promise<void>;
+    getRemoteStreams(): Array<{
+        participant: NativeRoomIdentity;
+        stream: MediaStream;
+    }>;
+    getPrimaryPeerConnection(): RTCPeerConnection | null;
+    sendChat(message: string, participantIds?: string[]): void;
+    sendControl(action: string, detail?: Record<string, unknown>): void;
+    private connect;
+    private openSocket;
+    private handleSignal;
+    private ensurePeer;
+    private createOffer;
+    private performOffer;
+    private shouldInitiateOffer;
+    private renegotiateAll;
+    private replaceVideoTrack;
+    private applyVideoQuality;
+    /**
+     * Applies this connection's own tier. The room-wide setting is a ceiling
+     * rather than an instruction: asking for audio keeps every link on audio, but
+     * asking for high lets each link settle wherever it can actually hold.
+     */
+    private applyPeerVideoQuality;
+    private startQualitySampling;
+    private stopQualitySampling;
+    private sampleActiveSpeaker;
+    private samplePeerQuality;
+    /** A new link starts one step below the ceiling so it proves itself upward. */
+    private static startingQuality;
+    private applyCodecPreference;
+    private removePeer;
+    private resetPeers;
+    private startHeartbeat;
+    private stopHeartbeat;
+    private clearConnectionTimers;
+    private scheduleReconnect;
+    private send;
+    private stopStream;
+}

package/dist/peer-quality.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Per-connection quality for a peer mesh.
+ *
+ * A mesh has no forwarding server, so there is nothing to send several
+ * qualities to — simulcast solves a problem this topology does not have. What
+ * it does have is one connection per participant, each with its own link, and
+ * until now a single room-wide quality was applied to all of them. One
+ * participant on a poor connection therefore either dragged the whole room down
+ * or was left with a stream their link could not carry. Each connection is
+ * rated on its own evidence instead.
+ *
+ * The ladder matches `sdk/react-native/src/quality.ts`, including the parts
+ * that look wrong until you read its tests: `"none"` is a truthy string and has
+ * to be normalised, and the step-up gate compares the bandwidth estimate
+ * against the *current* tier's ceiling on purpose. A field report argued the
+ * latter suppresses upgrades; the same report's data showed the estimate
+ * reaching 1,029,490 bps while pinned to a 600,000 tier, so the encoder cap was
+ * not holding it down, and relaxing the gate made the ladder climb to a tier the
+ * link could not carry.
+ */
+export type PeerQuality = "audio" | "low" | "medium" | "high";
+export interface PeerQualityTier {
+    active: boolean;
+    maxBitrate: number;
+    maxFramerate: number;
+    scaleResolutionDownBy: number;
+}
+export declare const peerQualityTiers: Record<PeerQuality, PeerQualityTier>;
+export interface PeerQualityThresholds {
+    warmupSamples: number;
+    poorSamplesToStepDown: number;
+    goodSamplesToStepUp: number;
+    criticalLossPct: number;
+    criticalRttMs: number;
+    poorLossPct: number;
+    poorRttMs: number;
+    goodLossPct: number;
+    goodRttMs: number;
+    sustainRatio: number;
+}
+export declare const defaultPeerQualityThresholds: PeerQualityThresholds;
+export interface PeerQualitySample {
+    packetLossPct: number | null;
+    rttMs: number | null;
+    availableOutgoingBitrateBps: number | null;
+    qualityLimitationReason: string | null;
+}
+export interface PeerQualityState {
+    quality: Exclude<PeerQuality, "audio">;
+    poorSamples: number;
+    goodSamples: number;
+    samplesSeen: number;
+    changed: boolean;
+}
+/** `"none"` is what a healthy sender reports, and it is a truthy string. */
+export declare function normalizeLimitation(reason: string | null | undefined): "" | "cpu" | "bandwidth" | "other";
+/**
+ * Chooses this connection's tier. `ceiling` is what the application asked for:
+ * adaptation may move below it but never above, so an app that asked for audio
+ * stays on audio.
+ */
+export declare function adaptPeerQuality(current: Exclude<PeerQuality, "audio">, sample: PeerQualitySample, poorSamples: number, goodSamples: number, options?: {
+    samplesSeen?: number;
+    ceiling?: PeerQuality;
+    thresholds?: Partial<PeerQualityThresholds>;
+}): PeerQualityState;
+export interface PeerCounters {
+    packetsSent: number;
+    packetsLost: number;
+    timestamp: number;
+}
+/**
+ * Reads one connection's outbound video health. Loss is a delta against the
+ * previous read rather than the session total, so a connection that struggled
+ * early is not held down by history it has recovered from.
+ */
+export declare function readPeerSample(report: Map<string, Record<string, unknown>> | Iterable<[string, Record<string, unknown>]>, previous: PeerCounters | null): {
+    sample: PeerQualitySample;
+    counters: PeerCounters | null;
+};