@stream-io/video-client 1.60.0 → 1.61.0

package/dist/index.cjs.js

@@ -5101,7 +5101,7 @@ const toIceCandidate = (iceTrickle) => {
     }
 };
 
-const version = "1.60.0";
+const version = "1.61.0";
 const [major, minor, patch] = version.split('.');
 let sdkInfo = {
     type: SdkType.PLAIN_JAVASCRIPT,
@@ -9166,6 +9166,25 @@ class TransceiverCache {
         this.cache.push(bundle);
         this.transceiverOrder.push(bundle.transceiver);
     };
+    /**
+     * Retires a failed sender from the reusable cache.
+     *
+     * A transceiver that never reached an m-section also leaves the creation
+     * history: once stopped, it is left out of every later offer, so counting
+     * it would shift the `mid` index of every transceiver added after it. One
+     * that is already associated keeps its slot, since its m-section survives
+     * as a rejected one.
+     */
+    remove = (transceiver) => {
+        const index = this.cache.findIndex((b) => b.transceiver === transceiver);
+        if (index !== -1)
+            this.cache.splice(index, 1);
+        if (transceiver.mid)
+            return;
+        const orderIndex = this.transceiverOrder.indexOf(transceiver);
+        if (orderIndex !== -1)
+            this.transceiverOrder.splice(orderIndex, 1);
+    };
     /**
      * Gets the transceiver for the given publish option.
      */
@@ -9337,7 +9356,9 @@ class Publisher extends BasePeerConnection {
         const sendEncodings = isSvcCodec(publishOption.codec?.name)
             ? toSvcEncodings(encodings)
             : encodings;
-        const transceiver = this.pc.addTransceiver(track, {
+        // An E2EE sender must never have media before its transform is attached,
+        // including when another track or an ICE restart negotiates this PC.
+        const transceiver = this.pc.addTransceiver(this.e2ee ? track.kind : track, {
             direction: 'sendonly',
             sendEncodings,
         });
@@ -9347,16 +9368,63 @@ class Publisher extends BasePeerConnection {
         this.transceiverCache.add({ publishOption, transceiver, options });
         this.trackIdToTrackType.set(track.id, trackType);
         this.logger.debug(`Added ${TrackType[trackType]} transceiver`);
-        const params = transceiver.sender.getParameters();
+        if (this.e2ee) {
+            await this.initEncryptedSender(transceiver, track, publishOption);
+        }
+        else {
+            await this.setDegradationPreference(transceiver.sender, publishOption);
+        }
+        await this.negotiate();
+    };
+    /**
+     * Attaches the encryptor, applies sender parameters, then attaches the track.
+     *
+     * `encrypt` must run before the first await: Chrome short-circuits a sender
+     * whose encoded streams aren't created in the task that created it, and the
+     * track goes on last so the sender has no media until both steps succeed.
+     */
+    initEncryptedSender = async (transceiver, track, publishOption) => {
+        try {
+            const { sender } = transceiver;
+            const codec = publishOption.codec?.name.toLowerCase();
+            this.e2ee.encrypt(sender, codec, TrackType[publishOption.trackType]);
+            this.logger.debug('E2EE encryptor attached to sender');
+            await this.setDegradationPreference(sender, publishOption);
+            await sender.replaceTrack(track);
+        }
+        catch (err) {
+            this.retireTransceiver(transceiver, track);
+            throw err;
+        }
+    };
+    setDegradationPreference = async (sender, publishOption) => {
+        const params = sender.getParameters();
         params.degradationPreference =
             toRTCDegradationPreference(publishOption.degradationPreference) ??
                 'maintain-framerate';
-        await transceiver.sender.setParameters(params);
-        if (this.e2ee) {
-            this.e2ee.encrypt(transceiver.sender, publishOption.codec?.name.toLowerCase(), TrackType[publishOption.trackType]);
-            this.logger.debug('E2EE encryptor attached to sender');
+        await sender.setParameters(params);
+    };
+    /**
+     * Discards a sender whose E2EE initialization failed.
+     *
+     * A partially initialized sender may carry no transform, so publish() must
+     * not reuse it: retiring it from the cache is what keeps a later publish or
+     * ICE restart from putting cleartext on the wire. Cleanup cannot throw, so
+     * the initialization failure is what reaches the caller.
+     */
+    retireTransceiver = (transceiver, track) => {
+        this.transceiverCache.remove(transceiver);
+        this.trackIdToTrackType.delete(track.id);
+        // on React Native a clone shares its native source, so stopping it here
+        // would stop the track the caller passed in. dispose() releases it.
+        if (!isReactNative())
+            this.stopTrack(track);
+        try {
+            transceiver.stop();
+        }
+        catch (err) {
+            this.logger.debug('Failed to stop a retired transceiver', err);
         }
-        await this.negotiate();
     };
     /**
      * Updates the transceiver with the given track and track type.
@@ -15922,6 +15990,11 @@ class Call {
             this.audioBindingsWatchdog?.dispose();
             await this.dynascaleManager?.dispose();
             this.state.setCallingState(exports.CallingState.LEFT);
+            // `ringingSubject` is cleared further down, so this still reads true for
+            // a call that was ringing.
+            if (this.ringing) {
+                globalThis.streamRNVideoSDK?.ringingCallLifecycle?.onLeave(this);
+            }
             this.state.setParticipants([]);
             this.state.dispose();
             // Reset reconnect-related accumulators so a future `call.join()` on the
@@ -16090,8 +16163,11 @@ class Call {
      * @param params.video if set to true, in a ringing scenario, mobile SDKs will show "incoming video call", audio only otherwise.
      */
     get = async (params) => {
+        const getLeaveGeneration = this.leaveGeneration;
         await this.setup();
         const response = await this.streamClient.get(this.streamClientBasePath, params);
+        if (this.leaveGeneration !== getLeaveGeneration)
+            return response;
         this.updateFromCallStateResponse(response);
         if (params?.ring) {
             this.ringingSubject.next(true);
@@ -16196,42 +16272,80 @@ class Call {
     /**
      * Will start to watch for call related WebSocket events and initiate a call session with the server.
      *
+     * One instance is one call flow: discard it after leaving, cancelling, or a
+     * failed join, and create a fresh one for a later flow. Reconnection inside a
+     * live call is handled here and needs no new instance.
+     *
      * @returns a promise which resolves once the call join-flow has finished.
      */
     join = singleFlight(async ({ maxJoinRetries = 3, joinResponseTimeout, rpcRequestTimeout, allowOwnTracksLoopback = false, joinSource, ...data } = {}) => {
         const callingState = this.state.callingState;
+        // Ahead of the failure boundary below on purpose: a duplicate join on a
+        // live call is refused without tearing that call down.
         if ([exports.CallingState.JOINED, exports.CallingState.JOINING].includes(callingState)) {
             throw new Error(`Illegal State: call.join() shall be called only once`);
         }
+        // snapshot before the first await: a leave() landing at any point from
+        // here on supersedes this join, and the retry loop must bail out instead
+        // of resurrecting a call that leave() already tore down.
+        const joinLeaveGeneration = this.leaveGeneration;
+        const supersededByLeave = () => this.leaveGeneration !== joinLeaveGeneration;
         // we need this to be set before the callingx.joinCall() is
         // called to avoid registering the test call in the CallKit/Telecom
         this.allowOwnTracksLoopback = allowOwnTracksLoopback;
         if (data?.ring) {
             this.ringingSubject.next(true);
         }
+        // A ringing call is joined by the SDK rather than by app code, so React
+        // Native prepares it from in here - there is no earlier point at which the
+        // app holds the call. Read after `data.ring` above, which is what makes an
+        // outgoing call ringing in the first place.
+        const ringingLifecycle = this.ringing
+            ? globalThis.streamRNVideoSDK?.ringingCallLifecycle
+            : undefined;
         const callingX = globalThis.streamRNVideoSDK?.callingX;
-        if (callingX) {
-            // for Android/iOS, we need to start the call in the callingx library as soon as possible
-            await callingX.joinCall(this, this.clientStore.calls);
-        }
-        await this.setup();
-        this.clientEventReporter.registerCall(this.cid, {
-            callType: this.type,
-            callId: this.id,
-            getCallSessionId: () => this.state.session?.id ?? '',
-            getSfuId: () => this.credentials?.server.edge_name ?? '',
-        });
-        this.joinResponseTimeout = joinResponseTimeout;
-        this.rpcRequestTimeout = rpcRequestTimeout;
-        // we will count the number of join failures per SFU.
-        // once the number of failures reaches 2, we will piggyback on the `migrating_from`
-        // field to force the coordinator to provide us another SFU
-        const sfuJoinFailures = new Map();
-        const joinData = data;
-        maxJoinRetries = Math.max(maxJoinRetries, 1);
         try {
+            if (ringingLifecycle) {
+                await ringingLifecycle.beforeJoin(this);
+                if (supersededByLeave()) {
+                    this.logger.debug('Join superseded by leave; not joining');
+                    return;
+                }
+            }
+            if (callingX) {
+                // for Android/iOS, we need to start the call in the callingx library as soon as possible
+                await callingX.joinCall(this, this.clientStore.calls, supersededByLeave);
+                if (supersededByLeave()) {
+                    this.logger.debug('Join superseded by leave; not setting up');
+                    return;
+                }
+            }
+            await this.setup();
+            if (supersededByLeave()) {
+                this.logger.debug('Join superseded by leave; not registering');
+                return;
+            }
+            this.clientEventReporter.registerCall(this.cid, {
+                callType: this.type,
+                callId: this.id,
+                getCallSessionId: () => this.state.session?.id ?? '',
+                getSfuId: () => this.credentials?.server.edge_name ?? '',
+            });
+            this.joinResponseTimeout = joinResponseTimeout;
+            this.rpcRequestTimeout = rpcRequestTimeout;
+            // we will count the number of join failures per SFU.
+            // once the number of failures reaches 2, we will piggyback on the `migrating_from`
+            // field to force the coordinator to provide us another SFU
+            const sfuJoinFailures = new Map();
+            const joinData = data;
+            maxJoinRetries = Math.max(maxJoinRetries, 1);
             await this.clientEventReporter.withJoinLifecycle(this.cid, { joinReason: 'first-attempt', joinSource }, async () => {
                 for (let attempt = 0; attempt < maxJoinRetries; attempt++) {
+                    // Also covers a leave that lands during the backoff below.
+                    if (supersededByLeave()) {
+                        this.logger.debug('Join superseded by leave; not attempting');
+                        return;
+                    }
                     try {
                         this.logger.trace(`Joining call (${attempt})`, this.cid);
                         await this.doJoin(data);
@@ -16240,6 +16354,10 @@ class Call {
                         return;
                     }
                     catch (err) {
+                        if (supersededByLeave()) {
+                            this.logger.debug('Join superseded by leave; not retrying');
+                            return;
+                        }
                         this.logger.warn(`Failed to join call (${attempt})`, this.cid);
                         if ((err instanceof ErrorFromResponse && err.unrecoverable) ||
                             (err instanceof SfuJoinError && err.unrecoverable)) {
@@ -16269,6 +16387,9 @@ class Call {
         }
         catch (error) {
             callingX?.endCall(this, 'error');
+            // Ends the failed ringing flow and releases what its setup installed.
+            // Never rejects, so `error` is what the caller sees.
+            await ringingLifecycle?.onJoinFailed(this);
             throw error;
         }
     });
@@ -16291,6 +16412,10 @@ class Call {
         // globals resolve to the call's factory. Idempotent across
         // reconnect/migration attempts.
         await this.ensureMediaFactory();
+        if (supersededByLeave()) {
+            this.logger.debug('Join superseded by leave; not wiring media');
+            return;
+        }
         const callingX = globalThis.streamRNVideoSDK?.callingX;
         if (callingX) {
             callingX.wireAudioEngineSubscription();
@@ -16306,11 +16431,17 @@ class Call {
             data?.migrating_from) {
             try {
                 const joinResponse = await this.clientEventReporter.track(this.cid, 'CoordinatorJoin', () => this.doJoinRequest(data));
+                if (!joinResponse || supersededByLeave()) {
+                    this.logger.debug('Join superseded by leave; not creating SFU client');
+                    return;
+                }
                 this.credentials = joinResponse.credentials;
                 statsOptions = joinResponse.stats_options;
                 this.lastStatsOptions = statsOptions;
             }
             catch (error) {
+                if (supersededByLeave())
+                    return;
                 // prevent triggering reconnect flow if the state is OFFLINE
                 const avoidRestoreState = this.state.callingState === exports.CallingState.OFFLINE;
                 if (!avoidRestoreState) {
@@ -16358,6 +16489,10 @@ class Call {
                 getGenericSdp('recvonly', dangerouslyForceCodec, subscriberFmtpLine),
                 getGenericSdp('sendonly', dangerouslyForceCodec, fmtpLine),
             ]);
+            if (supersededByLeave()) {
+                this.logger.debug('Join superseded by leave; not joining SFU');
+                return;
+            }
             const isReconnecting = this.reconnectStrategy !== WebsocketReconnectStrategy.UNSPECIFIED;
             const reconnectDetails = isReconnecting
                 ? this.getReconnectDetails(previousSfuClient?.edgeName, previousSessionId)
@@ -16383,6 +16518,10 @@ class Call {
                     capabilities,
                     source: ParticipantSource.WEBRTC_UNSPECIFIED,
                 }));
+                if (supersededByLeave()) {
+                    this.logger.debug('Join superseded by leave; not applying SFU response');
+                    return;
+                }
                 this.currentPublishOptions = publishOptions;
                 this.fastReconnectDeadlineSeconds = fastReconnectDeadlineSeconds;
                 if (callState) {
@@ -16390,6 +16529,10 @@ class Call {
                 }
             }
             catch (error) {
+                if (supersededByLeave()) {
+                    this.logger.debug('Join superseded by leave; ignoring SFU failure');
+                    return;
+                }
                 this.logger.warn('Join SFU request failed', error);
                 sfuClient.close(StreamSfuClient.JOIN_FAILED, 'Join request failed, connection considered unhealthy');
                 // restore the previous call state if the join-flow fails
@@ -16397,8 +16540,8 @@ class Call {
                 throw error;
             }
         }
-        // If the user left while this join was in flight, bail before re-setting JOINED and before
-        // peer-connection setup below (both run synchronously after this, so one check covers them).
+        // If the user left while this join was in flight, bail before re-setting JOINED
+        // or starting peer-connection setup below.
         if (supersededByLeave()) {
             this.logger.debug('Join superseded by leave; aborting join flow');
             return;
@@ -16427,6 +16570,10 @@ class Call {
                 unifiedSessionId: this.unifiedSessionId,
             });
         }
+        if (supersededByLeave()) {
+            this.logger.debug('Join superseded by leave; not completing join flow');
+            return;
+        }
         // make sure we only track connection timing if we are not calling this method as part of a reconnection flow
         if (!performingRejoin && !performingFastReconnect && !performingMigration) {
             this.sfuStatsReporter?.sendConnectionTime((Date.now() - connectStartTime) / 1000);
@@ -16572,15 +16719,20 @@ class Call {
      * @internal
      */
     initPublisherAndSubscriber = async (opts) => {
+        const joinLeaveGeneration = this.leaveGeneration;
         const { sfuClient, connectionConfig, clientDetails, statsOptions, publishOptions, closePreviousInstances, unifiedSessionId, } = opts;
         const { enable_rtc_stats: enableTracing, reporting_interval_ms: reportingIntervalMs, } = statsOptions;
         // Flush the previous reporter's final sample while its peer connections are
         // still alive, before we dispose them below. Awaits only the sampling step.
         await this.sfuStatsReporter?.flush();
+        if (this.leaveGeneration !== joinLeaveGeneration)
+            return;
         this.sfuStatsReporter?.stop();
         this.sfuStatsReporter = undefined;
         if (closePreviousInstances && this.subscriber) {
             await this.subscriber.dispose();
+            if (this.leaveGeneration !== joinLeaveGeneration)
+                return;
             this.state.removeAllOrphanedTracks();
         }
         const basePeerConnectionOptions = {
@@ -16623,6 +16775,8 @@ class Call {
         if (!isAnonymous) {
             if (closePreviousInstances && this.publisher) {
                 await this.publisher.dispose();
+                if (this.leaveGeneration !== joinLeaveGeneration)
+                    return;
             }
             this.publisher = new Publisher(basePeerConnectionOptions, publishOptions, {
                 selfSubEnabled: this.allowOwnTracksLoopback,
@@ -16659,12 +16813,22 @@ class Call {
      *
      * @internal
      * @param data the join call data.
+     * @returns The coordinator response, or undefined if leave superseded the request before it was sent.
      */
     doJoinRequest = async (data) => {
+        const joinLeaveGeneration = this.leaveGeneration;
         const location = await this.streamClient.getLocationHint();
+        if (this.leaveGeneration !== joinLeaveGeneration) {
+            this.logger.debug('Join superseded by leave; not sending coordinator request');
+            return;
+        }
         const e2ee = !!this.e2eeManager;
         const request = { ...data, location, e2ee };
         const joinResponse = await this.streamClient.post(`${this.streamClientBasePath}/join`, request);
+        if (this.leaveGeneration !== joinLeaveGeneration) {
+            this.logger.debug('Join superseded by leave; not applying coordinator response');
+            return joinResponse;
+        }
         this.state.updateFromCallResponse(joinResponse.call);
         this.state.setMembers(joinResponse.members);
         this.state.setOwnCapabilities(joinResponse.own_capabilities);
@@ -16675,6 +16839,8 @@ class Call {
         if (!isReconnecting && this.ringing && !this.isCreatedByMe) {
             // signals other users that I have accepted the incoming call.
             await this.accept();
+            if (this.leaveGeneration !== joinLeaveGeneration)
+                return joinResponse;
         }
         if (this.streamClient._hasConnectionID()) {
             this.watching = true;
@@ -16764,6 +16930,7 @@ class Call {
         if (callingState === exports.CallingState.JOINING ||
             callingState === exports.CallingState.RECONNECTING ||
             callingState === exports.CallingState.MIGRATING ||
+            callingState === exports.CallingState.LEFT ||
             callingState === exports.CallingState.RECONNECTING_FAILED)
             return;
         // Drop redundant reconnect calls. If a reconnect is already queued or
@@ -16772,19 +16939,27 @@ class Call {
         // `POST /join` per entry) once the call is already healthy again.
         if (hasPending(this.reconnectConcurrencyTag))
             return;
+        const reconnectLeaveGeneration = this.leaveGeneration;
+        const supersededByLeave = () => this.leaveGeneration !== reconnectLeaveGeneration;
         return withoutConcurrency(this.reconnectConcurrencyTag, async () => {
+            if (supersededByLeave())
+                return;
             const reconnectStartTime = Date.now();
             this.reconnectStrategy = strategy;
             this.reconnectReason = reason;
             const sfuRejoinFailures = new Map();
             const markAsReconnectingFailed = async () => {
+                if (supersededByLeave())
+                    return;
                 try {
                     // attempt to fetch the call data from the server, as the call
                     // state might have changed while we were reconnecting or were offline
                     await this.get();
                 }
                 finally {
-                    this.state.setCallingState(exports.CallingState.RECONNECTING_FAILED);
+                    if (!supersededByLeave()) {
+                        this.state.setCallingState(exports.CallingState.RECONNECTING_FAILED);
+                    }
                 }
             };
             const giveUpAndLeave = async (message) => {
@@ -16840,6 +17015,8 @@ class Call {
                 try {
                     // wait until the network is available
                     await this.networkAvailableTask?.promise;
+                    if (supersededByLeave())
+                        return;
                     this.logger.info(`[Reconnect] Reconnecting with strategy ${WebsocketReconnectStrategy[this.reconnectStrategy]}`);
                     switch (this.reconnectStrategy) {
                         case WebsocketReconnectStrategy.UNSPECIFIED:
@@ -16879,6 +17056,8 @@ class Call {
                     break; // do-while loop, reconnection worked, exit the loop
                 }
                 catch (error) {
+                    if (supersededByLeave())
+                        return;
                     if (attemptedStrategy === WebsocketReconnectStrategy.REJOIN) {
                         const failedSfu = this.credentials?.server.edge_name;
                         if (failedSfu) {
@@ -16909,6 +17088,8 @@ class Call {
                     }
                     // exponential backoff with jitter, capped at 5 s
                     await sleep(retryInterval(attempt));
+                    if (supersededByLeave())
+                        return;
                     const wasMigrating = this.reconnectStrategy === WebsocketReconnectStrategy.MIGRATE;
                     const mustPerformRejoin = (Date.now() - reconnectStartTime) / 1000 >
                         this.fastReconnectDeadlineSeconds;
@@ -16927,7 +17108,8 @@ class Call {
                     this.reconnectStrategy = nextStrategy;
                     this.logger.info(`[Reconnect] ${currentStrategy} (${this.reconnectAttempts}) failed. Attempting with ${WebsocketReconnectStrategy[nextStrategy]}`, error);
                 }
-            } while (this.state.callingState !== exports.CallingState.JOINED &&
+            } while (!supersededByLeave() &&
+                this.state.callingState !== exports.CallingState.JOINED &&
                 this.state.callingState !== exports.CallingState.RECONNECTING_FAILED &&
                 this.state.callingState !== exports.CallingState.LEFT);
             this.logger.info('[Reconnect] Reconnection flow finished');
@@ -16938,10 +17120,13 @@ class Call {
      * @internal
      */
     reconnectFast = async () => {
+        const reconnectLeaveGeneration = this.leaveGeneration;
         const reconnectStartTime = Date.now();
         this.reconnectStrategy = WebsocketReconnectStrategy.FAST;
         this.state.setCallingState(exports.CallingState.RECONNECTING);
         await this.doJoin(this.joinCallData);
+        if (this.leaveGeneration !== reconnectLeaveGeneration)
+            return;
         await this.get(); // fetch the latest call state, as it might have changed
         this.sfuStatsReporter?.sendReconnectionTime(WebsocketReconnectStrategy.FAST, (Date.now() - reconnectStartTime) / 1000);
     };
@@ -16950,6 +17135,7 @@ class Call {
      * @internal
      */
     reconnectRejoin = async () => {
+        const reconnectLeaveGeneration = this.leaveGeneration;
         const reconnectStartTime = Date.now();
         this.reconnectStrategy = WebsocketReconnectStrategy.REJOIN;
         this.state.setCallingState(exports.CallingState.RECONNECTING);
@@ -16957,7 +17143,11 @@ class Call {
             ? 'network-available'
             : 'full-rejoin';
         await this.clientEventReporter.withJoinLifecycle(this.cid, { joinReason }, () => this.doJoin(this.joinCallData));
+        if (this.leaveGeneration !== reconnectLeaveGeneration)
+            return;
         await this.restorePublishedTracks();
+        if (this.leaveGeneration !== reconnectLeaveGeneration)
+            return;
         this.restoreSubscribedTracks();
         this.sfuStatsReporter?.sendReconnectionTime(WebsocketReconnectStrategy.REJOIN, (Date.now() - reconnectStartTime) / 1000);
     };
@@ -16966,6 +17156,7 @@ class Call {
      * @internal
      */
     reconnectMigrate = async () => {
+        const reconnectLeaveGeneration = this.leaveGeneration;
         const reconnectStartTime = Date.now();
         const currentSfuClient = this.sfuClient;
         if (!currentSfuClient) {
@@ -16979,26 +17170,32 @@ class Call {
         currentPublisher?.detachEventHandlers();
         const migrationTask = makeSafePromise(currentSfuClient.enterMigration());
         try {
-            const currentSfu = currentSfuClient.edgeName;
-            await this.clientEventReporter.withJoinLifecycle(this.cid, { joinReason: 'migration' }, () => this.doJoin({
-                ...this.joinCallData,
-                migrating_from: currentSfu,
-                migrating_from_list: [currentSfu],
-            }));
-        }
-        finally {
-            // cleanup the migration_from field after the migration is complete or failed
-            // as we don't want to keep dirty data in the join call data
-            delete this.joinCallData?.migrating_from;
-            delete this.joinCallData?.migrating_from_list;
-        }
-        await this.restorePublishedTracks();
-        this.restoreSubscribedTracks();
-        try {
+            try {
+                const currentSfu = currentSfuClient.edgeName;
+                await this.clientEventReporter.withJoinLifecycle(this.cid, { joinReason: 'migration' }, () => this.doJoin({
+                    ...this.joinCallData,
+                    migrating_from: currentSfu,
+                    migrating_from_list: [currentSfu],
+                }));
+            }
+            finally {
+                // cleanup the migration_from field after the migration is complete or failed
+                // as we don't want to keep dirty data in the join call data
+                delete this.joinCallData?.migrating_from;
+                delete this.joinCallData?.migrating_from_list;
+            }
+            if (this.leaveGeneration !== reconnectLeaveGeneration)
+                return;
+            await this.restorePublishedTracks();
+            if (this.leaveGeneration !== reconnectLeaveGeneration)
+                return;
+            this.restoreSubscribedTracks();
             // Wait for the migration to complete, then close the previous SFU client
             // and the peer connection instances. In case of failure, the migration
             // task would throw an error and REJOIN would be attempted.
             await migrationTask();
+            if (this.leaveGeneration !== reconnectLeaveGeneration)
+                return;
             // in MIGRATE, we can consider the call as joined only after
             // `participantMigrationComplete` event is received, signaled by
             // the `migrationTask`
@@ -17283,10 +17480,11 @@ class Call {
      * Must be called before {@link join} so the RTCPeerConnection can be
      * configured for E2EE.
      *
-     * The manager is kept across {@link leave} so a rejoin of this same instance
-     * stays encrypted: do not dispose it while this call may be joined again.
-     * A disposed manager throws from `encrypt`/`decrypt` rather than silently
-     * publishing nothing, so re-attach a fresh one instead of reusing it.
+     * The application owns the manager's lifetime - the SDK never disposes it, and
+     * closing the peer connections does not release it. Discard the manager
+     * together with this call instance once its flow has ended, and create a fresh
+     * pair for a later flow: a disposed manager throws from `encrypt`/`decrypt`
+     * rather than silently publishing nothing.
      *
      * @param e2ee - Any `E2EEManager`. Use `EncryptionManager.create()` for the
      *         built-in AES-GCM scheme, or pass your own implementation.
@@ -19453,11 +19651,11 @@ class StreamClient {
         return await this.wsConnection.connect(this.defaultWSTimeout);
     };
     getSdkVersion = () => this.options.clientAppIdentifier?.sdkVersion ||
-        "1.60.0";
+        "1.61.0";
     getUserAgent = () => {
         if (!this.cachedUserAgent) {
             const { clientAppIdentifier = {} } = this.options;
-            const { sdkName = 'js', sdkVersion = "1.60.0", ...extras } = clientAppIdentifier;
+            const { sdkName = 'js', sdkVersion = "1.61.0", ...extras } = clientAppIdentifier;
             this.cachedUserAgent = [
                 `stream-video-${sdkName}-v${sdkVersion}`,
                 ...Object.entries(extras).map(([key, value]) => `${key}=${value}`),
@@ -21166,9 +21364,9 @@ class EncryptionManager extends TypedEventEmitter {
         }
         if ((this.piped ??= new WeakSet()).has(target))
             return;
-        this.piped.add(target);
         // @ts-expect-error createEncodedStreams is not in the standard typedefs
         const { readable, writable } = target.createEncodedStreams();
+        this.piped.add(target);
         this.worker.postMessage({ type: 'cmd.setup_transform', ...options, readable, writable }, [readable, writable]);
     };
     /**
@@ -21336,6 +21534,7 @@ exports.TranscriptionSettingsResponseClosedCaptionModeEnum = TranscriptionSettin
 exports.TranscriptionSettingsResponseLanguageEnum = TranscriptionSettingsResponseLanguageEnum;
 exports.TranscriptionSettingsResponseModeEnum = TranscriptionSettingsResponseModeEnum;
 exports.TranslationSettingsLanguagesEnum = TranslationSettingsLanguagesEnum;
+exports.TypedEventEmitter = TypedEventEmitter;
 exports.UpdateUserPermissionsRequestGrantPermissionsEnum = UpdateUserPermissionsRequestGrantPermissionsEnum;
 exports.UpdateUserPermissionsRequestRevokePermissionsEnum = UpdateUserPermissionsRequestRevokePermissionsEnum;
 exports.VideoSettingsRequestCameraFacingEnum = VideoSettingsRequestCameraFacingEnum;