@stream-io/video-client 1.57.0 → 1.59.0

package/dist/src/gen/video/sfu/models/models.d.ts

@@ -37,6 +37,14 @@ export interface CallState {
      * @generated from protobuf field: repeated stream.video.sfu.models.Pin pins = 4;
      */
     pins: Pin[];
+    /**
+     * e2ee_enabled is true when the call uses end-to-end encryption. Clients
+     * must enable their frame encryptor; the SFU forwards encrypted frames
+     * opaquely and server-side recording/transcription/broadcasting are disabled.
+     *
+     * @generated from protobuf field: bool e2ee_enabled = 5 [json_name = "e2eeEnabled"];
+     */
+    e2EeEnabled: boolean;
 }
 /**
  * @generated from protobuf message stream.video.sfu.models.ParticipantCount

package/dist/src/helpers/MediaStreamRecorder.d.ts

@@ -0,0 +1,26 @@
+export type MediaStreamRecorderOptions = {
+    /** Auto-stop after this many milliseconds. */
+    maxDurationMs?: number;
+};
+export type MediaRecordingResult = {
+    blob: Blob;
+};
+/** Single-use `MediaRecorder` wrapper that returns an in-memory blob. */
+export declare class MediaStreamRecorder {
+    private recording;
+    private logger;
+    private chunks;
+    private timeoutId;
+    private recorder;
+    private readonly tracks;
+    private readonly maxDurationMs;
+    constructor(stream: MediaStream, options?: MediaStreamRecorderOptions);
+    /** Starts recording and resolves when recording stops. */
+    start: () => Promise<MediaRecordingResult | null>;
+    /** Stops recording early. */
+    stop: () => void;
+    private isSettled;
+    private detach;
+    private handleStop;
+    private handleError;
+}

package/dist/src/helpers/TypedEventEmitter.d.ts

@@ -0,0 +1,23 @@
+import { ScopedLogger } from '../logger';
+export type EventMap = Record<string, unknown>;
+export type Listener<P> = (payload: P) => void | Promise<void>;
+/**
+ * Tiny, type-safe event emitter.
+ *
+ * Usage styles:
+ * - compose: `private readonly events = new TypedEventEmitter<MyMap>()`
+ * - extend:  `class Foo extends TypedEventEmitter<MyMap> {}`
+ *
+ * Listener exceptions (sync throw or rejected promise) are caught and logged,
+ * so one bad listener cannot break dispatch for the rest.
+ */
+export declare class TypedEventEmitter<M extends EventMap> {
+    protected readonly logger: ScopedLogger;
+    private readonly byEvent;
+    constructor(logger?: ScopedLogger | string);
+    on: <E extends keyof M>(event: E, fn: Listener<M[E]>) => (() => void);
+    off: <E extends keyof M>(event: E, fn: Listener<M[E]>) => void;
+    emit: <E extends keyof M>(event: E, payload: M[E]) => void;
+    removeAllListeners: (event?: keyof M) => void;
+    private invoke;
+}

package/dist/src/helpers/concurrency.d.ts

@@ -27,6 +27,14 @@ export declare const withoutConcurrency: <T>(tag: TagKey, cb: () => Promise<T>)
  * it's up to the function to decide how to react to cancelation.
  */
 export declare const withCancellation: <T>(tag: TagKey, cb: (signal: AbortSignal) => Promise<T | "canceled">) => Promise<T | "canceled">;
+/**
+ * Wraps an async function so concurrent calls share the in-flight promise
+ * instead of queueing another execution.
+ *
+ * @param cb Async function to wrap.
+ * @returns Wrapped async function.
+ */
+export declare function singleFlight<P extends unknown[], T>(cb: (...args: P) => Promise<T>): (...args: P) => Promise<T>;
 export declare function hasPending(tag: TagKey): boolean;
 export declare function settled(tag: TagKey): Promise<void>;
 export {};

package/dist/src/helpers/ensureExhausted.d.ts

@@ -1 +1 @@
-export declare const ensureExhausted: (x: never, message: string) => void;
+export declare const ensureExhausted: (x: never, message?: string) => void;

package/dist/src/helpers/loopback.d.ts

@@ -0,0 +1,55 @@
+import type { Call } from '../Call';
+import type { StreamVideoParticipant } from '../types';
+/** Default loopback stream wait timeout. */
+export declare const LOOPBACK_STREAMS_WAIT_TIMEOUT_MS: number;
+/** Default loopback recording duration. */
+export declare const DEFAULT_LOOPBACK_RECORDING_DURATION_MS: number;
+/** Shortest permitted loopback recording duration. */
+export declare const MIN_LOOPBACK_RECORDING_DURATION_MS: number;
+/** Longest permitted loopback recording duration. */
+export declare const MAX_LOOPBACK_RECORDING_DURATION_MS: number;
+/** SFU-echoed streams on the local participant. */
+export type LoopbackStreams = {
+    loopbackVideoStream?: MediaStream;
+    loopbackAudioStream?: MediaStream;
+};
+/** SFU-echoed tracks on the local participant. */
+export type LoopbackTracks = {
+    audioTrack?: MediaStreamTrack;
+    videoTrack?: MediaStreamTrack;
+};
+/** Thrown when loopback tracks do not arrive in time. */
+export declare class LoopbackStreamsTimeoutError extends Error {
+    constructor();
+}
+/**
+ * Returns the streams on the given participant that the SFU echoed back to us,
+ * ignoring the local capture streams the publishing path writes to the same
+ * fields.
+ */
+export declare const getLoopbackStreams: (call: Call | undefined, participant: StreamVideoParticipant | undefined) => LoopbackStreams;
+/**
+ * Returns loopback tracks when all required tracks are present.
+ *
+ * Prefer {@link waitForLoopbackStreams}, which observes call state until the
+ * tracks arrive. This is the synchronous snapshot it is built from.
+ *
+ * @internal
+ */
+export declare const getLoopbackTracks: (call: Call | undefined, participant: StreamVideoParticipant | undefined, includeVideo: boolean) => LoopbackTracks | undefined;
+export type WaitForLoopbackStreamsOptions = {
+    /** Whether video is required. Audio is always required. */
+    includeVideo: boolean;
+    /** Aborts the wait. */
+    signal: AbortSignal;
+    /** Defaults to {@link LOOPBACK_STREAMS_WAIT_TIMEOUT_MS}. */
+    timeoutMs?: number;
+};
+/** Waits for the requested loopback tracks. */
+export declare const waitForLoopbackStreams: (call: Call, opts: WaitForLoopbackStreamsOptions) => Promise<LoopbackTracks | null>;
+/** Enables loopback audio while `fn` runs, then restores it. */
+export declare const withLoopbackAudioEnabled: <T>(tracks: LoopbackTracks, fn: () => Promise<T>) => Promise<T>;
+/** Enables loopback audio and returns a restore function. */
+export declare const enableLoopbackAudio: (tracks: LoopbackTracks) => (() => void);
+/** Clamps and rounds a loopback recording duration. */
+export declare const clampLoopbackRecordingDuration: (durationMs: number) => number;

package/dist/src/permissions/PermissionsContext.d.ts

@@ -1,4 +1,4 @@
-import { CallSettingsResponse, OwnCapability } from '../gen/coordinator';
+import { CallSettingsResponse, OwnCapability, RequestPermissionRequestPermissionsEnum } from '../gen/coordinator';
 import { TrackType } from '../gen/video/sfu/models/models';
 /**
  * Stores the permissions for the current user and exposes
@@ -41,5 +41,5 @@ export declare class PermissionsContext {
      * @param permission the permission to check for.
      * @param settings the call settings to check against (optional).
      */
-    canRequest: (permission: OwnCapability, settings?: CallSettingsResponse | undefined) => boolean;
+    canRequest: (permission: RequestPermissionRequestPermissionsEnum, settings?: CallSettingsResponse | undefined) => boolean;
 }

package/dist/src/reporting/ClientEventReporter.d.ts

@@ -12,7 +12,6 @@ export type CallReportContext = {
     callId: string;
     getSfuId: () => string;
     getCallSessionId: () => string;
-    getUserSessionId: () => string;
 };
 export type ClientEventReporterOptions = {
     streamClient: StreamClient;
@@ -79,7 +78,6 @@ export declare class ClientEventReporter {
     private emitPeerConnectionSuccess;
     private emitPeerConnectionFailure;
     private getSfuId;
-    private getUserSessionId;
     private sessionIdField;
     private buildCommon;
     private send;

package/dist/src/rtc/BasePeerConnection.d.ts

@@ -2,6 +2,7 @@ import { ScopedLogger } from '../logger';
 import type { CallEventListener } from '../coordinator/connection/types';
 import { CallState } from '../store';
 import { PeerType, TrackType } from '../gen/video/sfu/models/models';
+import type { E2EEManager } from './e2ee/E2EEManager';
 import { StreamSfuClient } from '../StreamSfuClient';
 import { AllSfuEvents, Dispatcher } from './Dispatcher';
 import { StatsTracer, Tracer } from '../stats';
@@ -18,6 +19,7 @@ export declare abstract class BasePeerConnection {
     protected readonly state: CallState;
     protected readonly dispatcher: Dispatcher;
     protected readonly clientPublishOptions?: ClientPublishOptions;
+    protected readonly e2ee?: E2EEManager;
     protected tag: string;
     protected sfuClient: StreamSfuClient;
     protected onReconnectionNeeded?: OnReconnectionNeeded;
@@ -39,7 +41,7 @@ export declare abstract class BasePeerConnection {
     /**
      * Constructs a new `BasePeerConnection` instance.
      */
-    protected constructor(peerType: PeerType, { sfuClient, connectionConfig, state, dispatcher, onReconnectionNeeded, onIceConnected, onPeerConnectionStateChange, onRemoteTrackUnmute, tag, enableTracing, clientPublishOptions, iceRestartDelay, statsTimestampDriftThresholdMs, }: BasePeerConnectionOpts);
+    protected constructor(peerType: PeerType, { sfuClient, connectionConfig, state, dispatcher, onReconnectionNeeded, onIceConnected, onPeerConnectionStateChange, onRemoteTrackUnmute, tag, enableTracing, clientPublishOptions, e2ee, iceRestartDelay, statsTimestampDriftThresholdMs, }: BasePeerConnectionOpts);
     private createPeerConnection;
     /**
      * Disposes the `RTCPeerConnection` instance.

package/dist/src/rtc/Subscriber.d.ts

@@ -29,6 +29,11 @@ export declare class Subscriber extends BasePeerConnection {
      * Restarts the ICE connection and renegotiates with the SFU.
      */
     restartIce: () => Promise<void>;
+    /**
+     * Whether the given stream is one the SFU echoed back to us
+     * (`allowOwnTracksLoopback`) rather than a local capture stream.
+     */
+    isSelfSubscribedStream: (stream: MediaStream | undefined) => boolean;
     private handleOnTrack;
     private setRemoteTrackInterrupted;
     private negotiate;

package/dist/src/rtc/e2ee/E2EEManager.d.ts

@@ -0,0 +1,12 @@
+/**
+ * What the RTC layer needs to attach E2EE to a track. {@link EncryptionManager}
+ * is the built-in AES-GCM implementation, but `Call.setE2EEManager` takes any:
+ * an integrator can plug in another scheme, RFC 9605 SFrame for example, by
+ * attaching their own encoded transform in these two methods.
+ */
+export interface E2EEManager {
+    /** `trackType` only groups perf stats, keeping a camera and screen share apart. */
+    encrypt(sender: RTCRtpSender, codec?: string, trackType?: string): void;
+    /** `trackType` only groups perf stats, keeping a peer's audio and video apart. */
+    decrypt(receiver: RTCRtpReceiver, userId: string, trackType?: string): void;
+}

package/dist/src/rtc/e2ee/EncryptionManager.d.ts

@@ -0,0 +1,148 @@
+import { TypedEventEmitter } from '../../helpers/TypedEventEmitter';
+import type { E2EEEventMap } from './events';
+import type { E2EEManager } from './E2EEManager';
+export type { E2EEEventMap, DecryptionFailedEvent, DecryptionResumedEvent, DecryptionStalledEvent, EncryptionFailedEvent, KeyStateReport, MissingKeyEvent, PerfReport, TrackPerf, UnencryptedFrameEvent, UnsupportedVersionEvent, } from './events';
+/**
+ * - `'AES-128-GCM'` (default): 16-byte keys, per BSI TR-02102-1 §3.2.
+ * - `'AES-256-GCM'`: 32-byte keys. For a compliance reviewer that requires
+ *   256-bit strength, such as a KBV Anlage 31b certifier.
+ */
+export type E2EEAlgorithm = 'AES-128-GCM' | 'AES-256-GCM';
+/** Options for {@link EncryptionManager.create}. */
+export type EncryptionManagerOptions = {
+    algorithm?: E2EEAlgorithm;
+};
+/**
+ * Distributes keys to the E2EE Web Worker and attaches encrypt/decrypt
+ * transforms to RTCRtpSenders and RTCRtpReceivers.
+ */
+export declare class EncryptionManager extends TypedEventEmitter<E2EEEventMap> implements E2EEManager {
+    private readonly algorithm;
+    private readonly transform;
+    private disposed;
+    private piped?;
+    private readonly userId;
+    private readonly worker;
+    private readonly workerUrl;
+    private constructor();
+    /**
+     * Whether this browser has WebRTC Encoded Transforms, which E2EE requires.
+     * Use it to guard UI, or to avoid calling {@link create} where it would throw.
+     */
+    static isSupported: () => boolean;
+    /**
+     * Create an EncryptionManager instance and initialize the E2EE Web Worker.
+     *
+     * @param userId - The local user's ID, normally `call.currentUserId`.
+     * @param options - the create options.
+     * @throws {Error} If the browser lacks Encoded Transforms.
+     *
+     * @example
+     * ```ts
+     * if (EncryptionManager.isSupported()) {
+     *   const e2ee = await EncryptionManager.create(call.currentUserId);
+     *   call.setE2EEManager(e2ee);
+     *   e2ee.setSharedKey(0, keyBytes);
+     * }
+     */
+    static create: (userId: string, options?: EncryptionManagerOptions) => Promise<EncryptionManager>;
+    /**
+     * {@link dispose} terminates the worker, so `postMessage` becomes a silent
+     * no-op and an attached transform points at a dead worker: frames would stall
+     * forever with no error and no event. Throwing is also fail-closed, since a
+     * caller that swallows it still publishes nothing rather than cleartext.
+     */
+    private assertUsable;
+    /**
+     * Terminate the worker and release all resources.
+     *
+     * The manager is unusable afterwards and every other method throws. Call
+     * {@link create} for a new one. Safe to call more than once.
+     */
+    dispose: () => void;
+    /**
+     * Set a per-user AES-GCM encryption key in the worker's key store.
+     *
+     * Use it when each participant has their own key from a central authority.
+     * The receiver picks the right one by the `keyIndex` in the frame trailer.
+     *
+     * @param userId - The key owner.
+     * @param keyIndex - Increases with each rotation.
+     * @param rawKey - 16 bytes for AES-128-GCM, 32 for AES-256-GCM.
+     */
+    setKey: (userId: string, keyIndex: number, rawKey: ArrayBuffer) => void;
+    /**
+     * Fallback key for any user without a per-user key. The simplest E2EE mode:
+     * one key for everyone, usually passphrase-derived, no distribution needed.
+     * Setting an epoch makes it active for encryption while older epochs remain
+     * available to decrypt in-flight frames until {@link removeSharedKey}.
+     *
+     * @param keyIndex - An integer 0-255, since one trailer byte carries it.
+     * @param rawKey - 16 bytes for AES-128-GCM, 32 for AES-256-GCM.
+     */
+    setSharedKey: (keyIndex: number, rawKey: ArrayBuffer) => void;
+    /**
+     * Remove one shared-key epoch from the worker's receive key ring.
+     *
+     * If this is the active epoch, shared-key encryption stops until
+     * {@link setSharedKey} succeeds again. An older epoch is not reactivated.
+     *
+     * @param keyIndex - The exact shared-key epoch to remove.
+     */
+    removeSharedKey: (keyIndex: number) => void;
+    /**
+     * Retire one of a user's key epochs, leaving their other epochs usable.
+     *
+     * @param userId - The key owner.
+     * @param keyIndex - The exact epoch to remove. Absent epochs are a no-op.
+     */
+    removeKey: (userId: string, keyIndex: number) => void;
+    /**
+     * Drop every key a user holds, revoking their ability to decrypt later
+     * frames. Call it when a participant leaves.
+     *
+     * To retire one rotated epoch instead, use {@link removeKey}.
+     */
+    removeAllKeys: (userId: string) => void;
+    /**
+     * Called by the Publisher when it adds a transceiver.
+     *
+     * @param sender - The sender to encrypt.
+     * @param codec - Codec name, e.g. 'vp8', selecting the clear-byte rules.
+     * @param trackType - Optional label; only groups perf stats.
+     * @internal
+     */
+    encrypt: (sender: RTCRtpSender, codec?: string, trackType?: string) => void;
+    /**
+     * Called by the Subscriber when a remote track arrives.
+     *
+     * @param receiver - The receiver to decrypt.
+     * @param userId - The remote user, for key lookup in the worker.
+     * @param trackType - Optional label; only groups perf stats.
+     * @internal
+     */
+    decrypt: (receiver: RTCRtpReceiver, userId: string, trackType?: string) => void;
+    /** Pipe through the worker's transform, tracking targets to avoid double-piping. */
+    private pipe;
+    /**
+     * Toggle periodic performance reporting from the E2EE worker.
+     *
+     * While on, the worker emits `e2ee.perf_report` once per second with per-track
+     * FPS and crypto timings. Useful for debugging throughput.
+     */
+    enablePerformanceReporting: (enabled: boolean) => void;
+    /**
+     * Request a snapshot of the worker's keys. It arrives later as the
+     * `e2ee.key_state` event, listing fingerprints only, never key material.
+     */
+    requestKeyState: () => void;
+    private handleWorkerMessage;
+    private handleWorkerError;
+    private validateKeyLength;
+    /**
+     * One trailer byte carries the keyIndex. A larger value would truncate to
+     * `keyIndex & 0xFF`, so the receiver would look up the wrong key and fail
+     * every decrypt. Reject it rather than ship a silently broken key epoch.
+     */
+    private validateKeyIndex;
+}

package/dist/src/rtc/e2ee/e2ee-worker.d.ts

@@ -0,0 +1,25 @@
+/**
+ * E2EE worker. The build populates it.
+ *
+ * The actual implementation lives in `e2ee-worker/e2ee-worker-impl.ts` and its
+ * sibling modules (`constants.ts`, `codec.ts`, `crypto.ts`, `utils.ts`,
+ * `types.ts`), all written as real TypeScript with full type checking
+ * and import support.
+ *
+ * ## How it works
+ *
+ * 1. You edit files in `e2ee-worker/` as normal TypeScript
+ * 2. `yarn build` runs Rollup, which invokes `rollup-plugin-inline-worker`
+ * 3. The plugin bundles `e2ee-worker/e2ee-worker-impl.ts` (and its imports)
+ *    into a single function via a nested Rollup + TypeScript build
+ * 4. The function replaces this file's export at build time
+ * 5. `EncryptionManager.create()` creates a Worker from `e2eeWorker.toString()`
+ *
+ * In tests, this module is mocked (see `__tests__/EncryptionManager.test.ts`),
+ * so the placeholder is never evaluated.
+ *
+ * @see e2ee-worker/e2ee-worker-impl.ts - the entry point
+ * @see ../../plugins/rollup-plugin-inline-worker.ts - the Rollup plugin
+ * @see EncryptionManager.ts - consumes e2eeWorker
+ */
+export declare function e2eeWorker(): void;

package/dist/src/rtc/e2ee/events.d.ts

@@ -0,0 +1,163 @@
+/**
+ * Throughput sample for one track. `userId` is the local sender on encode, the
+ * remote sender on decode. The (userId, trackType) pair keeps a peer's audio
+ * and video reported apart instead of summed.
+ */
+export type TrackPerf = {
+    userId: string;
+    trackType: string;
+    fps: number;
+    maxCryptoMs: number;
+};
+/**
+ * Encode entries carry the `codec` the publisher knows; decode entries cannot,
+ * since a remote sender's codec is not reliably known locally.
+ */
+export type PerfReport = {
+    encode: (TrackPerf & {
+        codec: string;
+    })[];
+    decode: TrackPerf[];
+};
+/**
+ * Fired when a needed key is not held. The `keyIndex` tells the two cases apart:
+ *
+ * - Without it, the local encoder has no key and drops every outgoing frame.
+ *   The host never provided a key, or a key import failed.
+ * - With it, a remote sender's frame named a key this peer does not hold, so
+ *   the frame was dropped. This is normal while a key is in flight, or while a
+ *   rotation propagates.
+ */
+export type MissingKeyEvent = {
+    /** The local user, or the remote sender. */
+    userId: string;
+    /** Decode direction only; absent when the local encoder has no key. */
+    keyIndex?: number;
+    /**
+     * Decode direction only, which reports per track: a peer's tracks can sit on
+     * different key epochs, so one may stall while another plays. The encode
+     * direction stops every outgoing track at once and is reported per user.
+     */
+    trackType?: string;
+};
+/**
+ * A remote frame arrived unencrypted and went to the decoder as-is. Expected
+ * when the call's mode is `available` and that peer publishes plain; where every
+ * peer must encrypt, it means media renders without authentication.
+ */
+export type UnencryptedFrameEvent = {
+    userId: string;
+    trackType?: string;
+};
+/**
+ * A remote frame carried this format's framing but a `version` this build
+ * cannot decrypt, so it was dropped.
+ *
+ * **This client is the one that needs updating**, not the peer: the peer wrote
+ * a newer format than this SDK implements. Prompt the local user to update the
+ * app; no key changes anything.
+ */
+export type UnsupportedVersionEvent = {
+    userId: string;
+    trackType?: string;
+    /** The framing version read from the frame. */
+    version: number;
+};
+/** The worker could not decrypt a remote frame. Throttled per track. */
+export type DecryptionFailedEvent = {
+    userId: string;
+    trackType?: string;
+};
+/**
+ * Fired when a track decrypts again after a reported failure. See
+ * {@link E2EEEventMap} for how it pairs with `e2ee.decryption_failed`.
+ */
+export type DecryptionResumedEvent = {
+    userId: string;
+    trackType?: string;
+};
+/**
+ * An outgoing frame could not be encrypted, so that track publishes nothing.
+ * Latched per track, so a permanently failing track reports once.
+ */
+export type EncryptionFailedEvent = {
+    userId: string;
+    /** Only this track is affected; the sender's others keep publishing. */
+    trackType?: string;
+    /** Short, human-readable reason. */
+    reason: string;
+};
+/**
+ * Fired when a remote track passes the internal failure tolerance: decryption
+ * has failed on that many consecutive frames, so the track renders nothing until
+ * it recovers. The cause is not known here: a key mismatch is the common one,
+ * but a tampered or truncated frame looks the same to the decryptor.
+ */
+export type DecryptionStalledEvent = {
+    userId: string;
+    /** The keyIndex that crossed the tolerance. */
+    keyIndex: number;
+    trackType?: string;
+};
+/**
+ * Answer to {@link EncryptionManager.requestKeyState}. `fingerprint` is hex of
+ * the first 8 bytes of SHA-256(rawKey): not reversible, so safe to log. Key
+ * material is never returned.
+ */
+export type KeyStateReport = {
+    perUserKeys: Array<{
+        userId: string;
+        keyIndex: number;
+        fingerprint: string;
+    }>;
+    /** Every shared receive epoch, including the one currently used to encode. */
+    sharedKeys: Array<{
+        keyIndex: number;
+        fingerprint: string;
+        isActive: boolean;
+    }>;
+};
+/**
+ * Events that the E2EE {@link EncryptionManager} emits.
+ *
+ * Subscribe with `manager.on(eventName, handler)`. To unsubscribe, call the
+ * function it returns, or `manager.off(eventName, handler)`.
+ *
+ * Every name follows the `e2ee.<snake_case>` convention. That makes them easy
+ * to grep, and keeps them distinct from SFU and coordinator events.
+ */
+export type E2EEEventMap = {
+    /** Key mismatch, rotation in progress, or a tampered frame. */
+    'e2ee.decryption_failed': DecryptionFailedEvent;
+    /**
+     * Pairs one-to-one with `e2ee.decryption_failed` and is never throttled, so a
+     * host can drive its UI from the pair alone. Also fires for a track that
+     * recovers on a new keyIndex.
+     */
+    'e2ee.decryption_resumed': DecryptionResumedEvent;
+    /**
+     * Consecutive decrypt failures on one track crossed the internal tolerance.
+     * Fires once per (userId, keyIndex) entering that state, and
+     * `e2ee.decryption_resumed` is what clears it.
+     */
+    'e2ee.decryption_stalled': DecryptionStalledEvent;
+    /** That track is publishing nothing. Latched, so it reports once. */
+    'e2ee.encryption_failed': EncryptionFailedEvent;
+    /**
+     * The host must set or distribute a key. Distinct from
+     * `e2ee.encryption_failed`, where a key was present but the crypto threw.
+     * Throttled, and stops once the key arrives.
+     */
+    'e2ee.missing_key': MissingKeyEvent;
+    'e2ee.unencrypted_frame': UnencryptedFrameEvent;
+    /**
+     * A peer is publishing a framing version this build cannot read, so its
+     * frames are dropped. Throttled per track; surface it as a prompt to update
+     * **this** client.
+     */
+    'e2ee.unsupported_version': UnsupportedVersionEvent;
+    /** Once per second while {@link EncryptionManager.enablePerformanceReporting} is on. */
+    'e2ee.perf_report': PerfReport;
+    /** Answer to {@link EncryptionManager.requestKeyState}. */
+    'e2ee.key_state': KeyStateReport;
+};

package/dist/src/rtc/e2ee/transformSupport.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Detection and selection policy for the two WebRTC Encoded Transform APIs.
+ * Internal: which one the SDK attaches is an RTC-layer detail. Consumers want
+ * `EncryptionManager.isSupported` instead.
+ */
+/**
+ * Chrome only, and the reason an RTCPeerConnection carrying E2EE needs the
+ * non-standard `encodedInsertableStreams` flag.
+ */
+export declare const hasInsertableStreams: () => boolean;
+/** Whether the standard `RTCRtpScriptTransform` API exists. */
+export declare const hasScriptTransform: () => boolean;
+/**
+ * Which Encoded Transform API to attach E2EE with here.
+ *
+ * - `'insertable'`: legacy Insertable Streams. Used on Chrome, where
+ *   `RTCRtpScriptTransform` is still unreliable for E2EE.
+ * - `'script'`: the standard API. Used everywhere else.
+ * - `undefined`: neither exists, so E2EE cannot run.
+ */
+export declare const preferredTransform: () => "script" | "insertable" | undefined;

package/dist/src/rtc/helpers/rtcConfiguration.d.ts

@@ -1,2 +1,2 @@
-import { ICEServer } from '../../gen/coordinator';
-export declare const toRtcConfiguration: (config: ICEServer[]) => RTCConfiguration;
+import { ICEServerResponse } from '../../gen/coordinator';
+export declare const toRtcConfiguration: (config: ICEServerResponse[]) => RTCConfiguration;

package/dist/src/rtc/index.d.ts

@@ -1,4 +1,5 @@
 export * from './codecs';
+export * from './mediaEngine';
 export * from './Dispatcher';
 export * from './NegotiationError';
 export * from './IceTrickleBuffer';

package/dist/src/rtc/mediaEngine.d.ts

@@ -0,0 +1,23 @@
+/**
+ * A per-call media engine. On React Native it owns the call's native
+ * `PeerConnectionFactory` (built with the call's audio configuration); on web it
+ * is a no-op. Capture (`getUserMedia`/`getDisplayMedia`) and peer-connection creation
+ * always go through the WebRTC globals, which resolve to this factory while it
+ * is the live call factory — so the engine only needs to manage its lifecycle.
+ *
+ * @internal
+ */
+export interface CallMediaEngine {
+    dispose(): Promise<boolean>;
+}
+/**
+ * Creates a per-call {@link CallMediaEngine}. Registered once at SDK startup
+ * via {@link setCallMediaEngineProvider}. May return the engine synchronously
+ * (the default globals engine) or asynchronously (React Native, where allocating
+ * the native per-call factory is an async bridge call).
+ *
+ * @internal
+ */
+export type CallMediaEngineProvider = () => CallMediaEngine | Promise<CallMediaEngine>;
+export declare const setCallMediaEngineProvider: (newProvider: CallMediaEngineProvider) => void;
+export declare const getCallMediaEngineProvider: () => CallMediaEngineProvider;

package/dist/src/rtc/types.d.ts

@@ -4,6 +4,7 @@ import { CallState } from '../store';
 import { Dispatcher } from './Dispatcher';
 import type { OptimalVideoLayer } from './layers';
 import type { ClientPublishOptions } from '../types';
+import type { E2EEManager } from './e2ee/E2EEManager';
 import type { VideoSender } from '../gen/video/sfu/event/events';
 /**
  * Canonical reasons the SDK uses to trigger a reconnection. Free-form strings
@@ -81,6 +82,7 @@ export type BasePeerConnectionOpts = {
     iceRestartDelay?: number;
     clientPublishOptions?: ClientPublishOptions;
     statsTimestampDriftThresholdMs?: number;
+    e2ee?: E2EEManager;
 };
 export type TrackPublishOptions = {
     audioBitrateProfile?: AudioBitrateProfile;