@stream-io/video-react-native-sdk 1.45.1 → 1.46.0

package/dist/typescript/modules/encryption/EncryptionManager.d.ts

@@ -0,0 +1,190 @@
+import { type E2EEEventMap, type E2EEManager, type EncryptionManagerOptions, type Listener } from '@stream-io/video-client';
+/**
+ * Distributes keys to the native encryption manager and attaches
+ * encrypt/decrypt transforms to RTCRtpSenders and RTCRtpReceivers.
+ *
+ * The public surface matches the web
+ * {@link https://github.com/GetStream/stream-video-js/blob/main/packages/client/src/rtc/e2ee/EncryptionManager.ts | EncryptionManager}
+ * method for method, so host code is portable between the two SDKs.
+ *
+ * The crypto itself lives in the WebRTC binary, not here: frames never cross
+ * the React Native bridge. This class carries key and attach commands over it,
+ * and diagnostic events back.
+ *
+ * Like the keys it installs, the manager is application-owned: create one per
+ * call, attach it before {@link https://github.com/GetStream/stream-video-js/blob/main/packages/client/src/Call.ts | Call}`.join()`,
+ * and {@link EncryptionManager.dispose | dispose} it when that call is done.
+ * Nothing in the SDK will do it for you, and on React Native the leak is native
+ * rather than collectable.
+ *
+ * @example
+ * ```ts
+ * if (EncryptionManager.isSupported()) {
+ *   const e2ee = await EncryptionManager.create(call.currentUserId);
+ *   e2ee.setSharedKey(0, keyBytes);
+ *   call.setE2EEManager(e2ee); // must happen before call.join()
+ * }
+ * ```
+ */
+export declare class EncryptionManager implements E2EEManager {
+    private readonly algorithm;
+    private readonly native;
+    private readonly events;
+    private readonly logger;
+    private readonly bridged;
+    private disposed;
+    private constructor();
+    private handleNativeEvent;
+    /**
+     * Whether E2EE can run here. Use it to guard UI, or to avoid calling
+     * {@link create} where it would throw.
+     *
+     * `false` means the installed `@stream-io/react-native-webrtc` predates E2EE
+     * support.
+     */
+    static isSupported: () => boolean;
+    /**
+     * Create an EncryptionManager and initialize the underlying native manager.
+     *
+     * Attach it with `call.setE2EEManager()` **before** `call.join()`: the join
+     * request carries the E2EE flag, and the peer connections are built with the
+     * transforms in place.
+     *
+     * Resolves rather than returning directly because every Stream SDK exposes
+     * this as a promise; nothing here is actually asynchronous, since a blocking
+     * native create is what keeps a sender from ever existing unencrypted.
+     *
+     * @param userId - The local user's ID, normally `call.currentUserId`.
+     * @param options - the create options.
+     * @throws {Error} If E2EE is unavailable. It never degrades to plaintext.
+     */
+    static create: (userId: string, options?: EncryptionManagerOptions) => Promise<EncryptionManager>;
+    /**
+     * Subscribe to an E2EE event.
+     *
+     * @returns a function that unsubscribes the listener.
+     */
+    on: <E extends keyof E2EEEventMap>(event: E, fn: Listener<E2EEEventMap[E]>) => (() => void);
+    /** Unsubscribe a listener registered with {@link on}. */
+    off: <E extends keyof E2EEEventMap>(event: E, fn: Listener<E2EEEventMap[E]>) => void;
+    /** Drop every listener, or every listener of one event. */
+    removeAllListeners: (event?: keyof E2EEEventMap) => void;
+    /**
+     * Set a per-user AES-GCM encryption key in the native 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;
+    /**
+     * 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 from the local key store, so later frames of
+     * theirs no longer decrypt.
+     *
+     * This is local cleanup, not remote revocation: it cannot stop that
+     * participant from decrypting anything, and a shared key still decrypts them.
+     * Revoking access means withholding future keys, which the application owns.
+     *
+     * To retire one rotated epoch instead, use {@link removeKey}.
+     */
+    removeAllKeys: (userId: string) => void;
+    /**
+     * Remove one shared-key epoch from the native 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;
+    /**
+     * Called by the Publisher when it adds a transceiver.
+     *
+     * Synchronous all the way to the native `SetFrameTransformer` call: were it
+     * async, the sender would exist before its transform did, which is a
+     * plaintext window. A failure throws instead of publishing cleartext.
+     *
+     * @param sender - The sender to encrypt.
+     * @param codec - Codec name, e.g. 'vp8', selecting the clear-byte rules.
+     * @param trackType - `TrackType` enum name, e.g. 'SCREEN_SHARE_AUDIO'.
+     * @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.
+     * @param trackType - `TrackType` enum name, e.g. 'SCREEN_SHARE_AUDIO'.
+     * @internal
+     */
+    decrypt: (receiver: RTCRtpReceiver, userId: string, trackType?: string) => void;
+    /**
+     * Toggle periodic performance reporting.
+     *
+     * While on, `e2ee.perf_report` is emitted once per second with per-track FPS
+     * and crypto timings. Useful for debugging throughput.
+     */
+    enablePerformanceReporting: (enabled: boolean) => void;
+    /**
+     * Request a snapshot of the installed keys. It arrives later as the
+     * `e2ee.key_state` event, listing fingerprints only, never key material.
+     */
+    requestKeyState: () => void;
+    /**
+     * Release the native manager and all resources.
+     *
+     * **The application owns this object's lifetime — the SDK never disposes it.**
+     * Nothing releases the native manager when a peer connection closes, and there
+     * is no detach API, so an undisposed manager keeps its transforms and its key
+     * material alive for the lifetime of the process. Dispose it together with the
+     * call instance whose flow has ended; a later flow gets a fresh call and a
+     * fresh manager (see `Call.setE2EEManager`).
+     *
+     * In-flight frames are dropped rather than drained.
+     *
+     * The manager is unusable afterwards and every key or attach method throws.
+     * Call {@link create} for a new one. Safe to call more than once.
+     */
+    dispose: () => void;
+    /**
+     * {@link dispose} releases the native manager, so an attached transform would
+     * point at nothing: frames would stall 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;
+    /**
+     * The caller keeps ownership of its buffer and may re-import the same bytes,
+     * so hand native a copy rather than a view onto memory that can change.
+     */
+    private copyKey;
+    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;
+}
+//# sourceMappingURL=EncryptionManager.d.ts.map

package/dist/typescript/modules/encryption/EncryptionManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EncryptionManager.d.ts","sourceRoot":"","sources":["../../../../src/modules/encryption/EncryptionManager.ts"],"names":[],"mappings":"AAKA,OAAO,EAIL,KAAK,YAAY,EACjB,KAAK,WAAW,EAChB,KAAK,wBAAwB,EAC7B,KAAK,QAAQ,EAEd,MAAM,yBAAyB,CAAC;AAQjC;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,qBAAa,iBAAkB,YAAW,WAAW;IACnD,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAgB;IAC1C,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAuB;IAC9C,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAkC;IACzD,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAe;IACtC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAEjB;IACP,OAAO,CAAC,QAAQ,CAAS;IAEzB,OAAO;IAaP,OAAO,CAAC,iBAAiB,CAIvB;IAEF;;;;;;OAMG;IACH,MAAM,CAAC,WAAW,QAAO,OAAO,CACe;IAE/C;;;;;;;;;;;;;;OAcG;IACH,MAAM,CAAC,MAAM,GACX,QAAQ,MAAM,EACd,UAAU,wBAAwB,KACjC,OAAO,CAAC,iBAAiB,CAAC,CAc3B;IAEF;;;;OAIG;IACH,EAAE,GAAI,CAAC,SAAS,MAAM,YAAY,EAChC,OAAO,CAAC,EACR,IAAI,QAAQ,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,KAC5B,CAAC,MAAM,IAAI,CAAC,CAA8B;IAE7C,yDAAyD;IACzD,GAAG,GAAI,CAAC,SAAS,MAAM,YAAY,EACjC,OAAO,CAAC,EACR,IAAI,QAAQ,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,KAC5B,IAAI,CAA+B;IAEtC,2DAA2D;IAC3D,kBAAkB,GAAI,QAAQ,MAAM,YAAY,KAAG,IAAI,CACf;IAExC;;;;;;;;;OASG;IACH,MAAM,GAAI,QAAQ,MAAM,EAAE,UAAU,MAAM,EAAE,QAAQ,WAAW,KAAG,IAAI,CAKpE;IAEF;;;;;;;;OAQG;IACH,YAAY,GAAI,UAAU,MAAM,EAAE,QAAQ,WAAW,KAAG,IAAI,CAK1D;IAEF;;;;;OAKG;IACH,SAAS,GAAI,QAAQ,MAAM,EAAE,UAAU,MAAM,KAAG,IAAI,CAIlD;IAEF;;;;;;;;;OASG;IACH,aAAa,GAAI,QAAQ,MAAM,KAAG,IAAI,CAGpC;IAEF;;;;;;;OAOG;IACH,eAAe,GAAI,UAAU,MAAM,KAAG,IAAI,CAIxC;IAEF;;;;;;;;;;;OAWG;IACH,OAAO,GACL,QAAQ,YAAY,EACpB,QAAQ,MAAM,EACd,YAAY,MAAM,KACjB,IAAI,CAGL;IAEF;;;;;;;OAOG;IACH,OAAO,GACL,UAAU,cAAc,EACxB,QAAQ,MAAM,EACd,YAAY,MAAM,KACjB,IAAI,CAOL;IAEF;;;;;OAKG;IACH,0BAA0B,GAAI,SAAS,OAAO,KAAG,IAAI,CASnD;IAEF;;;OAGG;IACH,eAAe,QAAO,IAAI,CAKxB;IAEF;;;;;;;;;;;;;;OAcG;IACH,OAAO,QAAO,IAAI,CAchB;IAEF;;;;;OAKG;IACH,OAAO,CAAC,YAAY,CAElB;IAEF;;;OAGG;IACH,OAAO,CAAC,OAAO,CAIb;IAEF,OAAO,CAAC,iBAAiB,CAQvB;IAEF;;;;OAIG;IACH,OAAO,CAAC,gBAAgB,CAMtB;CACH"}

package/dist/typescript/modules/encryption/eventMapping.d.ts

@@ -0,0 +1,38 @@
+import { RTCEncryptionAlgorithm, RTCEncryptionTrackType, type RTCEncryptionEventData } from '@stream-io/react-native-webrtc';
+import type { E2EEAlgorithm, E2EEEventMap } from '@stream-io/video-client';
+/**
+ * The core RTC layer labels tracks with the `TrackType` enum *name*
+ * (`SfuModels.TrackType[trackType]`), while the native manager takes a numeric
+ * enum. Screen-share audio is deliberately its own value: native keeps replay
+ * state per (userId, trackType), so folding it into `AUDIO` mis-groups it.
+ *
+ * These read the native enums inside the function body on purpose. This module
+ * is reachable from the SDK's public entry point, so an app whose
+ * `@stream-io/react-native-webrtc` predates E2EE would crash on import if the
+ * enums were dereferenced at module scope - even if it never touches E2EE.
+ */
+export declare const trackTypeToNative: (trackType?: string) => RTCEncryptionTrackType | undefined;
+/** Map a native track type back to the name the web events carry. */
+export declare const trackTypeFromNative: (trackType?: RTCEncryptionTrackType | number) => string | undefined;
+/** Map the public algorithm name to the native enum. */
+export declare const algorithmToNative: (algorithm: E2EEAlgorithm) => RTCEncryptionAlgorithm;
+/**
+ * Translate a native event into the payload the web manager emits, so a host
+ * can write one set of handlers for both platforms.
+ *
+ * Two things have to be reshaped rather than passed through: native track types
+ * are numeric, and native flattens `managerId`/`type`/`userId` alongside the
+ * payload of every event, including the two (`perf_report`, `key_state`) that
+ * are not about a single user. Fields the web types require but native leaves
+ * optional get an explicit default, so a handler never reads `undefined` where
+ * its type promises a value.
+ *
+ * @returns the mapped event, or `undefined` for an unrecognized event name.
+ */
+export declare const mapNativeEvent: <E extends keyof E2EEEventMap>(event: RTCEncryptionEventData) => {
+    type: E;
+    payload: E2EEEventMap[E];
+} | undefined;
+/** Every event the native manager emits, i.e. what the bridge subscribes to. */
+export declare const E2EE_EVENT_TYPES: readonly ["e2ee.decryption_failed", "e2ee.decryption_resumed", "e2ee.decryption_stalled", "e2ee.encryption_failed", "e2ee.missing_key", "e2ee.unencrypted_frame", "e2ee.unsupported_version", "e2ee.perf_report", "e2ee.key_state"];
+//# sourceMappingURL=eventMapping.d.ts.map

package/dist/typescript/modules/encryption/eventMapping.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"eventMapping.d.ts","sourceRoot":"","sources":["../../../../src/modules/encryption/eventMapping.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,sBAAsB,EACtB,sBAAsB,EACtB,KAAK,sBAAsB,EAE5B,MAAM,gCAAgC,CAAC;AACxC,OAAO,KAAK,EACV,aAAa,EACb,YAAY,EAEb,MAAM,yBAAyB,CAAC;AAEjC;;;;;;;;;;GAUG;AACH,eAAO,MAAM,iBAAiB,GAC5B,YAAY,MAAM,KACjB,sBAAsB,GAAG,SAe3B,CAAC;AAEF,qEAAqE;AACrE,eAAO,MAAM,mBAAmB,GAC9B,YAAY,sBAAsB,GAAG,MAAM,KAC1C,MAAM,GAAG,SAaX,CAAC;AAEF,wDAAwD;AACxD,eAAO,MAAM,iBAAiB,GAC5B,WAAW,aAAa,KACvB,sBAGqC,CAAC;AASzC;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,cAAc,GAAI,CAAC,SAAS,MAAM,YAAY,EACzD,OAAO,sBAAsB,KAC5B;IAAE,IAAI,EAAE,CAAC,CAAC;IAAC,OAAO,EAAE,YAAY,CAAC,CAAC,CAAC,CAAA;CAAE,GAAG,SA+C1C,CAAC;AAEF,gFAAgF;AAChF,eAAO,MAAM,gBAAgB,qOAUnB,CAAC"}

package/dist/typescript/modules/encryption/index.d.ts

@@ -0,0 +1,2 @@
+export { EncryptionManager } from './EncryptionManager';
+//# sourceMappingURL=index.d.ts.map

package/dist/typescript/modules/encryption/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/modules/encryption/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC"}

package/dist/typescript/modules/encryption/parity.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Compile-time proof that the React Native {@link EncryptionManager} exposes the
+ * same public surface as the web one in `@stream-io/video-client`.
+ *
+ * This file has no runtime output and is imported by nothing. It exists because
+ * the SDK's entry point deliberately *shadows* the client's `EncryptionManager`
+ * export with this platform's implementation: a host writing against the
+ * documented API gets whichever class its platform ships, so the two surfaces
+ * diverging would be a silent break for that host rather than a build error.
+ * Both directions are asserted, so adding a method to either manager fails the
+ * build until the other one follows. Keep it that way, or delete both managers'
+ * claim to a shared API.
+ *
+ * `test:types` and the `tsc` pass in `bob build` both cover `src`, so CI runs
+ * this whether or not anything imports it.
+ */
+import type { EncryptionManager as WebEncryptionManager } from '@stream-io/video-client';
+import type { EncryptionManager } from './EncryptionManager';
+/** Fails to compile unless `T` is exactly `true`. */
+type AssertTrue<T extends true> = T;
+/**
+ * Public members only.
+ *
+ * A class type carrying `private` members is nominal, so the two managers can
+ * never be compared as classes however identical their APIs. `keyof` yields
+ * public keys alone, which is also precisely the surface a host can touch.
+ */
+type PublicSurface<T> = {
+    [K in keyof T]: T[K];
+};
+/**
+ * `emit` is public on the web manager only because it extends the shared
+ * `TypedEventEmitter`. Dispatching a forged E2EE event is not part of the
+ * documented API — `SPEC.md` §2 lists `on`/`off` and nothing else — so it is
+ * excluded here rather than mirrored on this side.
+ */
+type WebSurface = Omit<PublicSurface<WebEncryptionManager>, 'emit'>;
+type NativeSurface = PublicSurface<EncryptionManager>;
+/** Every documented web member exists here, with a compatible signature. */
+export type NativeCoversWeb = AssertTrue<NativeSurface extends WebSurface ? true : false>;
+/**
+ * ...and nothing extra. A React Native-only method would compile fine but make
+ * host code silently unportable, which is the failure this file exists to catch.
+ */
+export type WebCoversNative = AssertTrue<WebSurface extends NativeSurface ? true : false>;
+/**
+ * The statics are checked by signature rather than by assignability: both
+ * `create`s return their own class, so comparing them whole would only ever
+ * restate that the two classes are nominally distinct.
+ */
+export type CreateAcceptsSameArguments = AssertTrue<Parameters<typeof EncryptionManager.create> extends Parameters<typeof WebEncryptionManager.create> ? Parameters<typeof WebEncryptionManager.create> extends Parameters<typeof EncryptionManager.create> ? true : false : false>;
+export type CreateResolvesAManager = AssertTrue<Awaited<ReturnType<typeof EncryptionManager.create>> extends NativeSurface ? true : false>;
+export type IsSupportedMatches = AssertTrue<typeof EncryptionManager.isSupported extends typeof WebEncryptionManager.isSupported ? typeof WebEncryptionManager.isSupported extends typeof EncryptionManager.isSupported ? true : false : false>;
+export {};
+//# sourceMappingURL=parity.d.ts.map

package/dist/typescript/modules/encryption/parity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parity.d.ts","sourceRoot":"","sources":["../../../../src/modules/encryption/parity.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,OAAO,KAAK,EAAE,iBAAiB,IAAI,oBAAoB,EAAE,MAAM,yBAAyB,CAAC;AACzF,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAE7D,qDAAqD;AACrD,KAAK,UAAU,CAAC,CAAC,SAAS,IAAI,IAAI,CAAC,CAAC;AAEpC;;;;;;GAMG;AACH,KAAK,aAAa,CAAC,CAAC,IAAI;KAAG,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;CAAE,CAAC;AAEjD;;;;;GAKG;AACH,KAAK,UAAU,GAAG,IAAI,CAAC,aAAa,CAAC,oBAAoB,CAAC,EAAE,MAAM,CAAC,CAAC;AACpE,KAAK,aAAa,GAAG,aAAa,CAAC,iBAAiB,CAAC,CAAC;AAEtD,4EAA4E;AAC5E,MAAM,MAAM,eAAe,GAAG,UAAU,CACtC,aAAa,SAAS,UAAU,GAAG,IAAI,GAAG,KAAK,CAChD,CAAC;AAEF;;;GAGG;AACH,MAAM,MAAM,eAAe,GAAG,UAAU,CACtC,UAAU,SAAS,aAAa,GAAG,IAAI,GAAG,KAAK,CAChD,CAAC;AAEF;;;;GAIG;AACH,MAAM,MAAM,0BAA0B,GAAG,UAAU,CACjD,UAAU,CAAC,OAAO,iBAAiB,CAAC,MAAM,CAAC,SAAS,UAAU,CAC5D,OAAO,oBAAoB,CAAC,MAAM,CACnC,GACG,UAAU,CAAC,OAAO,oBAAoB,CAAC,MAAM,CAAC,SAAS,UAAU,CAC/D,OAAO,iBAAiB,CAAC,MAAM,CAChC,GACC,IAAI,GACJ,KAAK,GACP,KAAK,CACV,CAAC;AAEF,MAAM,MAAM,sBAAsB,GAAG,UAAU,CAC7C,OAAO,CAAC,UAAU,CAAC,OAAO,iBAAiB,CAAC,MAAM,CAAC,CAAC,SAAS,aAAa,GACtE,IAAI,GACJ,KAAK,CACV,CAAC;AAEF,MAAM,MAAM,kBAAkB,GAAG,UAAU,CACzC,OAAO,iBAAiB,CAAC,WAAW,SAAS,OAAO,oBAAoB,CAAC,WAAW,GAChF,OAAO,oBAAoB,CAAC,WAAW,SAAS,OAAO,iBAAiB,CAAC,WAAW,GAClF,IAAI,GACJ,KAAK,GACP,KAAK,CACV,CAAC"}

package/dist/typescript/utils/StreamVideoRN/index.d.ts

@@ -1,4 +1,4 @@
-import type { StreamVideoConfig } from './types';
+import type { RingingCallLifecycleHooks, StreamVideoConfig } from './types';
 type DeepPartial<T> = {
     [P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P];
 };
@@ -47,6 +47,25 @@ export declare class StreamVideoRN {
      * AppRegistry.registerComponent('app', () => App);
      */
     static setPushConfig(pushConfig: NonNullable<StreamVideoConfig['push']>): void;
+    /**
+     * Register hooks that run around a ringing call's join, for every ringing path:
+     * accepted from the CallKit/Telecom UI, accepted inside the app, and outgoing.
+     *
+     * Call this at your application's entry point, alongside
+     * {@link StreamVideoRN.setPushConfig} and **outside** the React tree. A call
+     * accepted from a push notification can be created and joined before any
+     * component mounts, so hooks registered from inside React would be missed on
+     * exactly the path that most needs them.
+     *
+     * Calling it again replaces the previously registered hooks.
+     *
+     * @example // in index.js
+     * StreamVideoRN.setRingingCallLifecycleHooks({
+     *   onBeforeCallJoin: (call) => attachE2EEIfConfigured(call),
+     *   onAfterCallLeave: (call) => disposeE2EEManager(call),
+     * });
+     */
+    static setRingingCallLifecycleHooks: (hooks: RingingCallLifecycleHooks) => void;
     static getConfig(): StreamVideoConfig;
     /**
      * This is the function to be called when the push token must be removed.

package/dist/typescript/utils/StreamVideoRN/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/utils/StreamVideoRN/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC;AAajD,KAAK,WAAW,CAAC,CAAC,IAAI;KACnB,CAAC,IAAI,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,SAAS,MAAM,GAAG,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;CAChE,CAAC;AAgDF,qBAAa,aAAa;IACxB,OAAO,CAAC,MAAM,CAAC,MAAM,CAA+B;IAEpD;;;;OAIG;IACH,MAAM,CAAC,YAAY,CACjB,YAAY,EAAE,WAAW,CAAC,IAAI,CAAC,iBAAiB,EAAE,MAAM,CAAC,CAAC;IAK5D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAmCG;IACH,MAAM,CAAC,aAAa,CAAC,UAAU,EAAE,WAAW,CAAC,iBAAiB,CAAC,MAAM,CAAC,CAAC;IA0BvE,MAAM,CAAC,SAAS;IAIhB;;;OAGG;IACH,MAAM,CAAC,YAAY;IASnB,MAAM,CAAC,wBAAwB;IAI/B;;;;;;;;;;;OAWG;IACH,MAAM,CAAC,qCAAqC,CAAC,QAAQ,EAAE,OAAO;IAe9D;;OAEG;WACU,YAAY;IAIzB;;OAEG;WACU,YAAY;IAIzB;;;OAGG;WACU,6BAA6B,IAAI,OAAO,CAAC,OAAO,CAAC;IAQ9D;;;OAGG;WACU,4BAA4B,IAAI,OAAO,CAAC,OAAO,CAAC;IAQ7D;;;OAGG;WACU,wBAAwB,IAAI,OAAO,CAAC,OAAO,CAAC;CAO1D"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/utils/StreamVideoRN/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,yBAAyB,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC;AAc5E,KAAK,WAAW,CAAC,CAAC,IAAI;KACnB,CAAC,IAAI,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,SAAS,MAAM,GAAG,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;CAChE,CAAC;AAgDF,qBAAa,aAAa;IACxB,OAAO,CAAC,MAAM,CAAC,MAAM,CAA+B;IAEpD;;;;OAIG;IACH,MAAM,CAAC,YAAY,CACjB,YAAY,EAAE,WAAW,CAAC,IAAI,CAAC,iBAAiB,EAAE,MAAM,CAAC,CAAC;IAK5D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAmCG;IACH,MAAM,CAAC,aAAa,CAAC,UAAU,EAAE,WAAW,CAAC,iBAAiB,CAAC,MAAM,CAAC,CAAC;IA0BvE;;;;;;;;;;;;;;;;;OAiBG;IACH,MAAM,CAAC,4BAA4B,GAAI,OAAO,yBAAyB,UAErE;IAEF,MAAM,CAAC,SAAS;IAIhB;;;OAGG;IACH,MAAM,CAAC,YAAY;IASnB,MAAM,CAAC,wBAAwB;IAI/B;;;;;;;;;;;OAWG;IACH,MAAM,CAAC,qCAAqC,CAAC,QAAQ,EAAE,OAAO;IAe9D;;OAEG;WACU,YAAY;IAIzB;;OAEG;WACU,YAAY;IAIzB;;;OAGG;WACU,6BAA6B,IAAI,OAAO,CAAC,OAAO,CAAC;IAQ9D;;;OAGG;WACU,4BAA4B,IAAI,OAAO,CAAC,OAAO,CAAC;IAQ7D;;;OAGG;WACU,wBAAwB,IAAI,OAAO,CAAC,OAAO,CAAC;CAO1D"}

package/dist/typescript/utils/StreamVideoRN/types.d.ts

@@ -10,6 +10,73 @@ export type KeepAliveAndroidNotificationTexts = {
     body: string;
 };
 export type NonRingingPushEvent = 'call.live_started' | 'call.notification' | 'call.missed';
+/**
+ * Hooks that run around a ringing call's join, wherever that join is triggered.
+ *
+ * A ringing call is joined by the SDK, not by your code: the accept button joins
+ * internally, and an outgoing call joins itself once the callee answers. That
+ * leaves no moment in which app code holds the call and the join has not yet
+ * happened - which is a problem for anything that must be installed first, most
+ * notably `call.setE2EEManager()`, since it throws once a call has peer
+ * connections.
+ *
+ * These hooks are that moment. They run for every ringing path: accepted from the
+ * CallKit/Telecom UI, accepted inside the app, and outgoing.
+ *
+ * Register them with {@link StreamVideoRN.setRingingCallLifecycleHooks} at your app's
+ * entry point, next to `setPushConfig`. A call accepted from a push notification
+ * can be created and joined before any component mounts - the app may be launched
+ * from a killed state - so registering them from inside React is too late.
+ */
+export type RingingCallLifecycleHooks = {
+    /**
+     * Awaited by `Call.join()` for a ringing call, before any peer connection exists.
+     * **Throwing aborts the join** and the call is not entered.
+     *
+     * That is deliberate: joining without whatever this hook installs would, in the
+     * E2EE case, publish unencrypted media on a call the user believes is private.
+     * On the push path there is no UI to reveal it, so the join fails closed instead.
+     * A failed join also ends the call, so the `Call` it failed on is finished with -
+     * a later attempt happens on a new incoming call or a newly created one.
+     *
+     * Keep it fast. On the CallKit accept path it runs inside iOS's accept deadline
+     * (roughly 30s before the app is killed) and anything slower than five seconds is
+     * treated as a failure. Deriving a key locally is fine; fetching one over the
+     * network does not belong here.
+     *
+     * @example
+     * onBeforeCallJoin: async (call) => {
+     *   await attachE2EEIfConfigured(call);
+     * }
+     */
+    onBeforeCallJoin?: (call: Call) => Promise<void>;
+    /**
+     * Called once, when a ringing call is finished with - it left, whether because
+     * the user hung up, the other side ended it, or its join failed and the SDK
+     * ended the flow.
+     *
+     * Use it to free per-call resources the SDK does not own. An E2EE manager is the
+     * motivating case: it has no native detach, closing the peer connections does not
+     * free it, and on the push path the call can end while the app is still in the
+     * background, where no React cleanup ever runs.
+     *
+     * When an {@link onBeforeCallJoin} is also registered, this is only called for a
+     * call that hook actually entered, so it always pairs with a setup that happened -
+     * a call that rings and is then rejected, cancelled or missed was never set up and
+     * releases nothing. Registered on its own it has no such pairing to honour and is
+     * called for every ringing call that ends. Either way it is tied to the call
+     * ending rather than to any view's lifetime, so navigating away from a live call
+     * does not release it.
+     *
+     * If the setup hook is still running when the call ends - it timed out, say - the
+     * release waits for it to settle, so it cannot free something that hook is about
+     * to create.
+     *
+     * May return a promise; rejections are logged. Nothing is gated on it, so do not
+     * rely on it completing before the OS suspends the app.
+     */
+    onAfterCallLeave?: (call: Call) => void | Promise<void>;
+};
 export type StreamVideoConfig = {
     /**
      * The configuration to be used for push notifications.

package/dist/typescript/utils/StreamVideoRN/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/utils/StreamVideoRN/types.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,oBAAoB,EACzB,iBAAiB,EACjB,KAAK,IAAI,EACV,MAAM,yBAAyB,CAAC;AAEjC,MAAM,MAAM,oBAAoB,GAAG;IACjC,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB,CAAC;AAEF,MAAM,MAAM,iCAAiC,GAAG;IAC9C,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAC7B,mBAAmB,GAAG,mBAAmB,GAAG,aAAa,CAAC;AAE5D,MAAM,MAAM,iBAAiB,GAAG;IAC9B;;;;OAIG;IACH,IAAI,CAAC,EAAE;QACL;;WAEG;QACH,MAAM,CAAC,EAAE,OAAO,CAAC;QACjB;;;;WAIG;QACH,cAAc,CAAC,EAAE,oBAAoB,CAAC;QAEtC,GAAG,CAAC,EAAE;YACJ;;;;eAIG;YACH,gBAAgB,CAAC,EAAE,MAAM,CAAC;YAC1B,aAAa,CAAC,EAAE,OAAO,CAAC;YACxB;;;eAGG;YACH,KAAK,CAAC,EAAE,MAAM,CAAC;YACf;;;eAGG;YACH,SAAS,CAAC,EAAE,MAAM,CAAC;YACnB;;;eAGG;YACH,YAAY,CAAC,EAAE,OAAO,CAAC;YACvB;;;eAGG;YACH,kBAAkB,CAAC,EAAE,MAAM,CAAC;YAC5B;;;eAGG;YACH,kBAAkB,CAAC,EAAE,OAAO,CAAC;YAC7B;;;;;;eAMG;YACH,4BAA4B,CAAC,EAAE,OAAO,CAAC;YACvC;;;;;eAKG;YACH,yBAAyB,CAAC,EAAE,SAAS,GAAG,UAAU,CAAC;SACpD,CAAC;QACF,OAAO,CAAC,EAAE;YACR;;;;eAIG;YACH,SAAS,CAAC,EAAE,MAAM,CAAC;YACnB;;;;eAIG;YACH,gBAAgB,CAAC,EAAE,MAAM,CAAC;YAC1B;;;;;;;;;eASG;YACH,eAAe,CAAC,EAAE,oBAAoB,CAAC;YACvC;;;;;;;;eAQG;YACH,iBAAiB,CAAC,EAAE;gBAClB,SAAS,CAAC,EAAE,MAAM,CAAC;gBACnB,SAAS,CAAC,EAAE,MAAM,CAAC;aACpB,CAAC;YACF;;eAEG;YACH,gBAAgB,CAAC,EAAE,CAAC,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,OAAO,KAAK,MAAM,CAAC;YACrE,kBAAkB,CAAC,EAAE,OAAO,CAAC;YAC7B;;;;eAIG;YACH,4BAA4B,CAAC,EAAE,OAAO,CAAC;YACvC;;;eAGG;YACH,yBAAyB,CAAC,EAAE,SAAS,GAAG,UAAU,CAAC;SACpD,CAAC;QACF;;;WAGG;QACH,wBAAwB,CAAC,EAAE,OAAO,CAAC;QACnC;;;;;;;;;;;;;;;;;WAiBG;QACH,uBAAuB,EAAE,MAAM,OAAO,CAAC,iBAAiB,GAAG,SAAS,CAAC,CAAC;KACvE,CAAC;IACF,iBAAiB,EAAE;QACjB,OAAO,EAAE;YACP;;eAEG;YACH,OAAO,EAAE,IAAI,CAAC,oBAAoB,EAAE,OAAO,GAAG,WAAW,CAAC,CAAC;YAC3D;;eAEG;YACH,iBAAiB,EAAE,iCAAiC,CAAC;YACrD;;eAEG;YACH,SAAS,EAAE,CAAC,IAAI,EAAE,IAAI,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;SAC1C,CAAC;KACH,CAAC;CACH,CAAC"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/utils/StreamVideoRN/types.ts"],"names":[],"mappings":"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"}

package/dist/typescript/utils/internal/callingx/callingx.d.ts

@@ -13,7 +13,7 @@ export declare function registerOutgoingCall(call: Call): Promise<void>;
  * 2. Displays the incoming call in the callingx library
  * 3. Optionally for non-ringing calls also when ongoing calls are enabled.
  */
-export declare function joinCallingxCall(call: Call, activeCalls: Call[]): Promise<void>;
+export declare function joinCallingxCall(call: Call, activeCalls: Call[], isCancelled?: () => boolean): Promise<void>;
 export declare function endCallingxCall(call: Call, reason?: EndCallReason): Promise<void>;
 export declare function wireAudioEngineSubscription(): Promise<void>;
 export declare function unwireAudioEngineSubscription(): void;

package/dist/typescript/utils/internal/callingx/callingx.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"callingx.d.ts","sourceRoot":"","sources":["../../../../../src/utils/internal/callingx/callingx.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kCAAkC,CAAC;AAEtE,OAAO,KAAK,EACV,IAAI,EACJ,cAAc,EACd,sBAAsB,EACvB,MAAM,yBAAyB,CAAC;AAKjC;;GAEG;AACH,wBAAgB,kBAAkB,CAChC,WAAW,EAAE,cAAc,EAAE,GAAG,SAAS,EACzC,YAAY,EAAE,sBAAsB,EAAE,GAAG,SAAS,EAClD,aAAa,EAAE,MAAM,GAAG,SAAS,GAChC,MAAM,CAgCR;AAsBD,wBAAsB,oBAAoB,CAAC,IAAI,EAAE,IAAI,iBAyBpD;AAED;;;;;;;GAOG;AACH,wBAAsB,gBAAgB,CAAC,IAAI,EAAE,IAAI,EAAE,WAAW,EAAE,IAAI,EAAE,iBAoDrE;AAED,wBAAsB,eAAe,CAAC,IAAI,EAAE,IAAI,EAAE,MAAM,CAAC,EAAE,aAAa,iBAmBvE;AAED,wBAAsB,2BAA2B,kBAehD;AAED,wBAAgB,6BAA6B,SAe5C"}
+{"version":3,"file":"callingx.d.ts","sourceRoot":"","sources":["../../../../../src/utils/internal/callingx/callingx.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kCAAkC,CAAC;AAEtE,OAAO,KAAK,EACV,IAAI,EACJ,cAAc,EACd,sBAAsB,EACvB,MAAM,yBAAyB,CAAC;AAKjC;;GAEG;AACH,wBAAgB,kBAAkB,CAChC,WAAW,EAAE,cAAc,EAAE,GAAG,SAAS,EACzC,YAAY,EAAE,sBAAsB,EAAE,GAAG,SAAS,EAClD,aAAa,EAAE,MAAM,GAAG,SAAS,GAChC,MAAM,CAgCR;AA2BD,wBAAsB,oBAAoB,CAAC,IAAI,EAAE,IAAI,iBAyBpD;AAED;;;;;;;GAOG;AACH,wBAAsB,gBAAgB,CACpC,IAAI,EAAE,IAAI,EACV,WAAW,EAAE,IAAI,EAAE,EACnB,WAAW,CAAC,EAAE,MAAM,OAAO,iBA+E5B;AAED,wBAAsB,eAAe,CAAC,IAAI,EAAE,IAAI,EAAE,MAAM,CAAC,EAAE,aAAa,iBAmBvE;AAED,wBAAsB,2BAA2B,kBAehD;AAED,wBAAgB,6BAA6B,SAe5C"}

package/dist/typescript/utils/internal/iosPipTrack.d.ts

@@ -0,0 +1,9 @@
+import { type Call, type VideoTrackType } from '@stream-io/video-client';
+import { BehaviorSubject } from 'rxjs';
+export type PipTrack = {
+    sessionId: string;
+    trackType: VideoTrackType;
+};
+export declare const getIosPipTrack$: (call: Call) => BehaviorSubject<PipTrack | undefined>;
+export declare const setIosPipTrack: (call: Call, track: PipTrack | undefined) => void;
+//# sourceMappingURL=iosPipTrack.d.ts.map

package/dist/typescript/utils/internal/iosPipTrack.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"iosPipTrack.d.ts","sourceRoot":"","sources":["../../../../src/utils/internal/iosPipTrack.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,IAAI,EAET,KAAK,cAAc,EACpB,MAAM,yBAAyB,CAAC;AACjC,OAAO,EAAE,eAAe,EAAE,MAAM,MAAM,CAAC;AAEvC,MAAM,MAAM,QAAQ,GAAG;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,cAAc,CAAA;CAAE,CAAC;AASxE,eAAO,MAAM,eAAe,GAAI,MAAM,IAAI,0CAOzC,CAAC;AAEF,eAAO,MAAM,cAAc,GAAI,MAAM,IAAI,EAAE,OAAO,QAAQ,GAAG,SAAS,SAarE,CAAC"}

package/dist/typescript/utils/internal/registerSDKGlobals.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"registerSDKGlobals.d.ts","sourceRoot":"","sources":["../../../../src/utils/internal/registerSDKGlobals.ts"],"names":[],"mappings":"AA8OA,wBAAgB,kBAAkB,SAMjC"}
+{"version":3,"file":"registerSDKGlobals.d.ts","sourceRoot":"","sources":["../../../../src/utils/internal/registerSDKGlobals.ts"],"names":[],"mappings":"AAgPA,wBAAgB,kBAAkB,SAMjC"}

package/dist/typescript/utils/internal/ringingCallLifecycle.d.ts

@@ -0,0 +1,27 @@
+import { type Call } from '@stream-io/video-client';
+import type { RingingCallLifecycleHooks } from '../StreamVideoRN/types';
+export declare const setRingingCallLifecycleHooks: (next: RingingCallLifecycleHooks) => void;
+/**
+ * Runs the app's pre-join setup, bounded by the deadline.
+ *
+ * Rejecting fails the join closed - joining without whatever this installs would
+ * publish unencrypted media on a call the user believes is private.
+ */
+export declare const beforeJoin: (call: Call) => Promise<void>;
+/**
+ * The join failed and will not be retried on this call.
+ *
+ * Ends the ringing flow rather than leaving the call sitting in `RINGING`: one
+ * `Call` is one call flow, so the accept button must not be able to offer this
+ * instance again. Never rejects, so the original join error survives.
+ */
+export declare const onJoinFailed: (call: Call) => Promise<void>;
+/**
+ * The call has ended.
+ *
+ * Releases what the setup hook installed, once the hook has actually settled -
+ * a hook still running may yet install something, and releasing before it
+ * finishes would strand that.
+ */
+export declare const onLeave: (call: Call) => void;
+//# sourceMappingURL=ringingCallLifecycle.d.ts.map

package/dist/typescript/utils/internal/ringingCallLifecycle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ringingCallLifecycle.d.ts","sourceRoot":"","sources":["../../../../src/utils/internal/ringingCallLifecycle.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,IAAI,EACV,MAAM,yBAAyB,CAAC;AACjC,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,wBAAwB,CAAC;AAuBxE,eAAO,MAAM,4BAA4B,GACvC,MAAM,yBAAyB,SAGhC,CAAC;AAmCF;;;;;GAKG;AACH,eAAO,MAAM,UAAU,GAAI,MAAM,IAAI,KAAG,OAAO,CAAC,IAAI,CAiCnD,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,YAAY,GAAU,MAAM,IAAI,KAAG,OAAO,CAAC,IAAI,CAc3D,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,OAAO,GAAI,MAAM,IAAI,KAAG,IASpC,CAAC"}

package/dist/typescript/utils/push/internal/utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../../../src/utils/push/internal/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,IAAI,EAIL,MAAM,yBAAyB,CAAC;AACjC,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAKnE,KAAK,UAAU,GAAG,WAAW,CAAC,iBAAiB,CAAC,MAAM,CAAC,CAAC,CAAC;AAGzD,KAAK,4BAA4B,GAAG;IAAE,OAAO,EAAE,OAAO,CAAA;CAAE,CAAC;AAEzD;;;GAGG;AACH,eAAO,MAAM,iBAAiB,GAC5B,cAAc,IAAI,EAClB,eAAe,MAAM,GAAG,SAAS,EACjC,aAAa,MAAM,GAAG,SAAS;;;CAoChC,CAAC;AAMF,eAAO,MAAM,+BAA+B,GAC1C,YAAY,UAAU,EACtB,UAAU,MAAM,EAChB,QAAQ,QAAQ,GAAG,SAAS,GAAG,SAAS,GAAG,qBAAqB;AAChE;;;;;GAKG;AACH,2BAA2B,CAAC,OAAO,EAAE,OAAO,KAAK,IAAI,kBAmFtD,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,6BAA6B,GAAI,UAAU,MAAM,SAM7D,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,4BAA4B,EAAE,4BAE1C,CAAC;AAEF,eAAO,MAAM,aAAa,eACkD,CAAC;AAE7E,eAAO,MAAM,kBAAkB,GAC7B,MAAM,IAAI,EACV,UAAU;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,CAAA;CAAE;;;CAW7C,CAAC"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../../../src/utils/push/internal/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,IAAI,EAIL,MAAM,yBAAyB,CAAC;AACjC,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAKnE,KAAK,UAAU,GAAG,WAAW,CAAC,iBAAiB,CAAC,MAAM,CAAC,CAAC,CAAC;AAGzD,KAAK,4BAA4B,GAAG;IAAE,OAAO,EAAE,OAAO,CAAA;CAAE,CAAC;AAEzD;;;GAGG;AACH,eAAO,MAAM,iBAAiB,GAC5B,cAAc,IAAI,EAClB,eAAe,MAAM,GAAG,SAAS,EACjC,aAAa,MAAM,GAAG,SAAS;;;CAoChC,CAAC;AAMF,eAAO,MAAM,+BAA+B,GAC1C,YAAY,UAAU,EACtB,UAAU,MAAM,EAChB,QAAQ,QAAQ,GAAG,SAAS,GAAG,SAAS,GAAG,qBAAqB;AAChE;;;;;GAKG;AACH,2BAA2B,CAAC,OAAO,EAAE,OAAO,KAAK,IAAI,kBAuFtD,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,6BAA6B,GAAI,UAAU,MAAM,SAM7D,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,4BAA4B,EAAE,4BAE1C,CAAC;AAEF,eAAO,MAAM,aAAa,eACkD,CAAC;AAE7E,eAAO,MAAM,kBAAkB,GAC7B,MAAM,IAAI,EACV,UAAU;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,CAAA;CAAE;;;CAW7C,CAAC"}

package/dist/typescript/version.d.ts

@@ -1,2 +1,2 @@
-export declare const version = "1.45.1";
+export declare const version = "1.46.0";
 //# sourceMappingURL=version.d.ts.map

package/ios/RTCViewPip.swift

@@ -17,6 +17,9 @@ class RTCViewPip: UIView {
     weak var manager: RTCViewPipManager?
 
     @objc var onPiPChange: RCTBubblingEventBlock?
+    /// Actual PiP window bounds in logical points.
+    @objc var onPiPBoundsChange: RCTBubblingEventBlock?
+    private var lastEmittedBounds: CGSize?
 
     // MARK: - Avatar Placeholder Properties
 
@@ -156,8 +159,11 @@ class RTCViewPip: UIView {
     @objc
     func onCallClosed() {
         PictureInPictureLogger.log("pictureInPictureController cleanup called")
+        self.pictureInPictureController?.onPiPStateChange = nil
+        self.pictureInPictureController?.onSizeUpdate = nil
         self.pictureInPictureController?.cleanup()
         self.pictureInPictureController = nil
+        self.lastEmittedBounds = nil
     }
     
     @objc
@@ -191,9 +197,8 @@ class RTCViewPip: UIView {
                 }
                 self.pictureInPictureController?.sourceView = self
                 self.pictureInPictureController?.isMirrored = self.mirror
-                // Set up PiP state change callback
-                self.pictureInPictureController?.onPiPStateChange = { [weak self] isActive in
-                    self?.sendPiPChangeEvent(isActive: isActive)
+                if let controller = self.pictureInPictureController {
+                    self.installCallbacks(on: controller)
                 }
                 if let reactTag = self.reactTag,
                    let size = self.manager?.getCachedSize(for: reactTag) {
@@ -277,12 +282,32 @@ class RTCViewPip: UIView {
         }
     }
     
-    private func sendPiPChangeEvent(isActive: Bool) {
-        guard let onPiPChange = onPiPChange else {
-            return
+    // MARK: - Picture in Picture Events
+
+    /// Ignore callbacks from a controller that has already been disposed.
+    private func installCallbacks(on controller: StreamPictureInPictureController) {
+        controller.onPiPStateChange = { [weak self, weak controller] isActive in
+            guard let self, let controller,
+                  self.pictureInPictureController === controller else { return }
+            self.onPiPChange?(["active": isActive])
+        }
+        controller.onSizeUpdate = { [weak self, weak controller] size in
+            guard let self, let controller,
+                  self.pictureInPictureController === controller else { return }
+            self.handleSizeUpdate(size)
         }
+    }
 
-        PictureInPictureLogger.log("Sending PiP state change event: \(isActive)")
-        onPiPChange(["active": isActive])
+    private func handleSizeUpdate(_ size: CGSize) {
+        guard size.width.isFinite, size.height.isFinite else { return }
+        // truncated to match the integer dimensions the inline views report.
+        let bounds = CGSize(
+            width: size.width.rounded(.towardZero),
+            height: size.height.rounded(.towardZero)
+        )
+        guard bounds.width > 0, bounds.height > 0 else { return }
+        guard let onPiPBoundsChange, lastEmittedBounds != bounds else { return }
+        lastEmittedBounds = bounds
+        onPiPBoundsChange(["width": bounds.width, "height": bounds.height])
     }
 }

package/ios/RTCViewPipManager.mm

@@ -13,6 +13,7 @@
 RCT_EXPORT_VIEW_PROPERTY(streamURL, NSString)
 RCT_EXPORT_VIEW_PROPERTY(mirror, BOOL)
 RCT_EXPORT_VIEW_PROPERTY(onPiPChange, RCTBubblingEventBlock)
+RCT_EXPORT_VIEW_PROPERTY(onPiPBoundsChange, RCTBubblingEventBlock)
 RCT_EXPORT_VIEW_PROPERTY(participantName, NSString)
 RCT_EXPORT_VIEW_PROPERTY(participantImageURL, NSString)
 RCT_EXPORT_VIEW_PROPERTY(isReconnecting, BOOL)