@stream-io/video-client 1.57.0 → 1.58.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/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/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/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/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/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;

package/dist/src/store/CallState.d.ts

@@ -12,6 +12,7 @@ type OrphanedTrack = {
     trackLookupPrefix: string;
     trackType: TrackType;
     track: MediaStream;
+    receiver?: RTCRtpReceiver;
 };
 /**
  * Holds the state of the current call.
@@ -35,6 +36,7 @@ export declare class CallState {
     private settingsSubject;
     private transcribingSubject;
     private captioningSubject;
+    private e2eeEnabledSubject;
     private endedBySubject;
     private thumbnailsSubject;
     private membersSubject;
@@ -188,6 +190,11 @@ export declare class CallState {
      * Will provide the closed captioning state of this call.
      */
     captioning$: Observable<boolean>;
+    /**
+     * Whether end-to-end encryption is active for this call, as reported by the
+     * SFU in the join response.
+     */
+    e2eeEnabled$: Observable<boolean>;
     /**
      * Will provide the user who ended this call.
      */
@@ -476,6 +483,10 @@ export declare class CallState {
      * Will provide the transcribing state of this call.
      */
     get transcribing(): boolean;
+    /**
+     * Whether end-to-end encryption is active for this call.
+     */
+    get e2eeEnabled(): boolean;
     /**
      * Will provide the user who ended this call.
      */
@@ -571,6 +582,16 @@ export declare class CallState {
      * @param id the ID of the orphaned track to remove.
      */
     removeOrphanedTrack: (id: string) => void;
+    /**
+     * Drops every orphaned track. Call this when the peer connections that own
+     * the stored receivers go away (full leave, reconnect, or migration):
+     * `pc.close()` does not raise the track `ended` event, so the per-track
+     * cleanup never fires and the receivers + their closed PCs would otherwise
+     * leak for the call's lifetime.
+     *
+     * @internal
+     */
+    removeAllOrphanedTracks: () => void;
     /**
      * Takes all orphaned tracks with the given track lookup prefix.
      * All orphaned tracks with the given track lookup prefix are removed from the call state.

package/dist/src/types.d.ts

@@ -1,5 +1,5 @@
 import type { Participant, TrackType, VideoDimension } from './gen/video/sfu/models/models';
-import type { AudioSettingsRequestDefaultDeviceEnum, CallRecordingStartedEventRecordingTypeEnum, JoinCallRequest, MemberResponse, OwnCapability, ReactionResponse, StartRecordingRequest, StartRecordingResponse } from './gen/coordinator';
+import type { AudioSettingsRequestDefaultDeviceEnum, CallRecordingStartedEventRecordingTypeEnum, JoinCallRequest, MemberResponse, OwnCapability, VideoReactionResponse, StartRecordingRequest, StartRecordingResponse } from './gen/coordinator';
 import type { StreamClient } from './coordinator/connection/client';
 import type { ClientEventReporter } from './reporting';
 import type { RejectReason, StreamClientOptions, TokenProvider, User } from './coordinator/connection/types';
@@ -7,7 +7,7 @@ import type { Comparator } from './sorting';
 import type { StreamVideoWriteableStateStore } from './store';
 import { AxiosError } from 'axios';
 import type { Call } from './Call';
-export type StreamReaction = Pick<ReactionResponse, 'type' | 'emoji_code' | 'custom'>;
+export type StreamReaction = Pick<VideoReactionResponse, 'type' | 'emoji_code' | 'custom'>;
 export declare enum VisibilityState {
     UNKNOWN = "UNKNOWN",
     VISIBLE = "VISIBLE",
@@ -344,8 +344,15 @@ type StreamRNVideoSDKCallManagerRingingParams = {
     isRingingTypeCall: boolean;
 };
 type StreamRNVideoSDKCallManagerSetupParams = StreamRNVideoSDKCallManagerRingingParams & {
+    cid: string;
     defaultDevice: AudioSettingsRequestDefaultDeviceEnum;
 };
+type StreamRNVideoSDKCallManagerStartParams = StreamRNVideoSDKCallManagerRingingParams & {
+    cid: string;
+};
+type StreamRNVideoSDKCallManagerStopParams = StreamRNVideoSDKCallManagerRingingParams & {
+    shouldStopCallManager: boolean;
+};
 type StreamRNVideoSDKEndCallReason = 
 /** Call ended by the local user (e.g., hanging up). */
 'local'
@@ -371,6 +378,8 @@ type StreamRNVideoSDKCallingX = {
     joinCall: (call: Call, activeCalls: Call[]) => Promise<void>;
     endCall: (call: Call, reason?: StreamRNVideoSDKEndCallReason) => Promise<void>;
     registerOutgoingCall: (call: Call) => Promise<void>;
+    wireAudioEngineSubscription: () => void;
+    unwireAudioEngineSubscription: () => void;
 };
 export type StreamRNVideoSDKGlobals = {
     callingX: StreamRNVideoSDKCallingX;
@@ -378,15 +387,15 @@ export type StreamRNVideoSDKGlobals = {
         /**
          * Sets up the in call manager.
          */
-        setup({ defaultDevice, isRingingTypeCall, }: StreamRNVideoSDKCallManagerSetupParams): void;
+        setup({ defaultDevice, isRingingTypeCall, cid, }: StreamRNVideoSDKCallManagerSetupParams): void;
         /**
          * Starts the in call manager.
          */
-        start({ isRingingTypeCall, }: StreamRNVideoSDKCallManagerRingingParams): void;
+        start({ isRingingTypeCall, cid, }: StreamRNVideoSDKCallManagerStartParams): void;
         /**
          * Stops the in call manager.
          */
-        stop({ isRingingTypeCall }: StreamRNVideoSDKCallManagerRingingParams): void;
+        stop({ isRingingTypeCall, shouldStopCallManager, }: StreamRNVideoSDKCallManagerStopParams): void;
         /**
          * iOS-only. Keeps the audio engine's microphone-input (voice-processing)
          * chain prepared while the mic is muted, so the `AVAudioEngine` stays full-duplex
@@ -423,5 +432,5 @@ declare global {
 /**
  * The options to pass to {@link Call.join} method.
  */
-export type JoinCallData = Omit<JoinCallRequest, 'location'>;
+export type JoinCallData = Omit<JoinCallRequest, 'location' | 'e2ee'>;
 export { AxiosError };

package/index.ts

@@ -11,6 +11,7 @@ export * from './src/stats/types';
 
 export * from './src/Call';
 export * from './src/CallType';
+export * from './src/rtc/mediaEngine';
 export * from './src/StreamVideoClient';
 export * from './src/StreamSfuClient';
 export * from './src/devices';
@@ -23,6 +24,8 @@ export * from './src/helpers/DynascaleManager';
 export * from './src/helpers/ViewportTracker';
 export * from './src/helpers/sound-detector';
 export * from './src/helpers/participantUtils';
+export * from './src/rtc/e2ee/E2EEManager';
+export * from './src/rtc/e2ee/EncryptionManager';
 export * as Browsers from './src/helpers/browsers';
 
 export * from './src/logger';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stream-io/video-client",
-  "version": "1.57.0",
+  "version": "1.58.0",
   "main": "dist/index.cjs.js",
   "module": "dist/index.es.js",
   "browser": "dist/index.browser.es.js",