@streaming-cdn/rtc-web 1.3.13 → 1.3.15

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.13
+# RTC Web SDK 1.3.15
 
 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/`.
 
@@ -169,6 +169,41 @@ 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.
 
+## Virtual backgrounds and effects
+
+`createVideoEffectsPipeline(cameraTrack)` draws the camera through a canvas
+and hands back a processed track for `setVideoTrack`, so both transports
+publish it unchanged. Backgrounds: `blur`, animated procedural scenes
+(`aurora`, `cybergrid`, `bokeh`, `sunset`), or your own `image`. Overlays:
+`snow`, `confetti`, `vignette`. Person cut-out uses any `Segmenter` you plug
+in (for example a self-hosted MediaPipe selfie model); without one the
+pipeline degrades honestly — `blur` blurs the whole frame, scenes show the
+camera as a floating card.
+
+```ts
+const effects = createVideoEffectsPipeline(cameraTrack, { segmenter });
+effects.setBackground("aurora");
+effects.setOverlay("confetti");
+await media.setVideoTrack(effects.track);
+```
+
+## Call recording
+
+`createCallRecorder(media.getNativeClient(), { credential })` composites every
+participant's video onto a canvas, mixes all audio, records with
+MediaRecorder, and on `stop()` uploads the file with the room signaling token.
+The platform stores it, bills the storage, lists it under
+`GET /v1/rtc/recordings` (Server API), and serves it from
+`GET /v1/rtc/recordings/{id}/download`. Recording happens on this client —
+what is recorded is what this participant saw and heard.
+
+```ts
+const recorder = createCallRecorder(media.getNativeClient(), { credential });
+await recorder.start();
+// ... later
+const { recordingId, durationSeconds } = await recorder.stop();
+```
+
 ## Active speaker
 
 The client samples WebRTC audio levels once a second on both transports and

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/call-recorder.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Client-side call recording.
+ *
+ * The mesh has no server with access to the media, so the first recorder that
+ * can exist lives where the media already is: this client. It composites every
+ * video tile onto a canvas, mixes every audio track, records the result with
+ * MediaRecorder, and uploads the finished file with the room signaling token.
+ * The platform bills and purges the stored file through the same
+ * `rtc_recordings` rows a future server-side recorder will use.
+ */
+export interface RecordableRoomClient {
+    getRemoteStreams(): Array<{
+        participant: {
+            participantId: string;
+            displayName: string;
+        };
+        stream: MediaStream;
+    }>;
+    getLocalStream(): MediaStream | null;
+}
+export interface CallRecorderOptions {
+    credential: {
+        signalingToken: string;
+        signalingUrl: string;
+    };
+    /** Canvas output height; width follows 16:9. Default 720. */
+    height?: number;
+    mimeType?: string;
+    /** Test seams. */
+    document?: Document;
+    mediaRecorderFactory?: (stream: MediaStream, options: {
+        mimeType: string;
+    }) => MediaRecorder;
+    fetchImplementation?: typeof fetch;
+}
+export interface CallRecorderResult {
+    recordingId: string;
+    sizeBytes: number;
+    durationSeconds: number;
+}
+export interface CallRecorder {
+    readonly recording: boolean;
+    start(): Promise<void>;
+    /** Stops, uploads, and marks the recording ready. */
+    stop(): Promise<CallRecorderResult>;
+    dispose(): void;
+}
+export declare function createCallRecorder(client: RecordableRoomClient, options: CallRecorderOptions): CallRecorder;

package/dist/index.d.ts

@@ -0,0 +1,345 @@
+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 { createCallRecorder } from "./call-recorder";
+export type { CallRecorder, CallRecorderOptions, CallRecorderResult } from "./call-recorder";
+export { BACKGROUND_PRESETS, createVideoEffectsPipeline, OVERLAY_EFFECTS, scenePainters } from "./video-effects";
+export type { BackgroundPreset, OverlayEffect, Segmenter, VideoEffectsOptions, VideoEffectsPipeline } from "./video-effects";
+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.15";

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;
+};