@stream-io/video-client 1.60.0 → 1.61.1

package/dist/src/Call.d.ts

@@ -301,6 +301,10 @@ export declare 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: (args_0?: (JoinCallData & {
@@ -355,8 +359,9 @@ export declare 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: (data?: JoinCallData) => Promise<JoinCallResponse>;
+    doJoinRequest: (data?: JoinCallData) => Promise<JoinCallResponse | undefined>;
     /**
      * Whether the per-call media engine currently exists. True from join until leave.
      *
@@ -484,10 +489,11 @@ export declare 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.

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

@@ -37,6 +37,24 @@ export declare class Publisher extends BasePeerConnection {
      * Adds a new transceiver carrying the given track to the peer connection.
      */
     private addTransceiver;
+    /**
+     * 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.
+     */
+    private initEncryptedSender;
+    private setDegradationPreference;
+    /**
+     * 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.
+     */
+    private retireTransceiver;
     /**
      * Updates the transceiver with the given track and track type.
      */

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

@@ -14,6 +14,16 @@ export declare class TransceiverCache {
      * Adds a transceiver to the cache.
      */
     add: (bundle: PublishBundle) => void;
+    /**
+     * 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: RTCRtpTransceiver) => void;
     /**
      * Gets the transceiver for the given publish option.
      */

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

@@ -5,7 +5,16 @@
  * attaching their own encoded transform in these two methods.
  */
 export interface E2EEManager {
-    /** `trackType` only groups perf stats, keeping a camera and screen share apart. */
+    /**
+     * Synchronously attach a transform that encrypts the sender's outgoing frames.
+     * Must support a sender without a track, and throw if attachment fails.
+     *
+     * `sender.track` is always null here: the track is attached only after this
+     * returns, so implementations must not read it. Use `codec` and `trackType`
+     * instead.
+     *
+     * `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/types.d.ts

@@ -375,14 +375,43 @@ type StreamRNVideoSDKEndCallReason =
 /** Unknown or unspecified disconnect reason. */
  | 'unknown';
 type StreamRNVideoSDKCallingX = {
-    joinCall: (call: Call, activeCalls: Call[]) => Promise<void>;
+    /**
+     * @param isCancelled - polled around the bridge's waits: registration is
+     *   skipped, or undone, when it returns true. Supplied by the join attempt
+     *   because the call's own state cannot distinguish a fresh join starting
+     *   from `LEFT` from an abandoned one that reached `LEFT` while waiting.
+     */
+    joinCall: (call: Call, activeCalls: Call[], isCancelled?: () => boolean) => Promise<void>;
     endCall: (call: Call, reason?: StreamRNVideoSDKEndCallReason) => Promise<void>;
     registerOutgoingCall: (call: Call) => Promise<void>;
     wireAudioEngineSubscription: () => void;
     unwireAudioEngineSubscription: () => void;
 };
+/**
+ * React Native's preparation and cleanup for a ringing call's join.
+ *
+ * A ringing call is joined by the SDK rather than by app code, so there is no
+ * point at which the app holds the call and can still set it up. These are that
+ * point, and the matching release.
+ */
+type StreamRNVideoSDKRingingCallLifecycle = {
+    /**
+     * Runs the app's pre-join setup and resolves once it is done, bounded by a
+     * deadline. Rejecting fails the join closed rather than joining with nothing
+     * installed.
+     */
+    beforeJoin: (call: Call) => Promise<void>;
+    /**
+     * The join failed terminally. Ends the ringing flow and releases what the
+     * setup installed. Never rejects, so the original join error survives.
+     */
+    onJoinFailed: (call: Call) => Promise<void>;
+    /** The call has ended; release whatever the pre-join hook installed. */
+    onLeave: (call: Call) => void;
+};
 export type StreamRNVideoSDKGlobals = {
     callingX: StreamRNVideoSDKCallingX;
+    ringingCallLifecycle: StreamRNVideoSDKRingingCallLifecycle;
     callManager: {
         /**
          * Sets up the in call manager.

package/index.ts

@@ -26,6 +26,7 @@ export * from './src/helpers/sound-detector';
 export * from './src/helpers/loopback';
 export * from './src/helpers/MediaStreamRecorder';
 export * from './src/helpers/participantUtils';
+export * from './src/helpers/TypedEventEmitter';
 export * from './src/rtc/e2ee/E2EEManager';
 export * from './src/rtc/e2ee/EncryptionManager';
 export * as Browsers from './src/helpers/browsers';

package/package.json

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

package/src/Call.ts

@@ -794,6 +794,11 @@ export class Call {
       await this.dynascaleManager?.dispose();
 
       this.state.setCallingState(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();
 
@@ -983,12 +988,14 @@ export class Call {
     members_limit?: number;
     video?: boolean;
   }): Promise<GetCallResponse> => {
+    const getLeaveGeneration = this.leaveGeneration;
     await this.setup();
 
     const response = await this.streamClient.get<GetCallResponse>(
       this.streamClientBasePath,
       params,
     );
+    if (this.leaveGeneration !== getLeaveGeneration) return response;
 
     this.updateFromCallStateResponse(response);
 
@@ -1135,6 +1142,10 @@ export 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(
@@ -1154,10 +1165,19 @@ export class Call {
     } = {}): Promise<void> => {
       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 ([CallingState.JOINED, 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;
@@ -1166,35 +1186,67 @@ export class Call {
         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);
-      }
+      try {
+        if (ringingLifecycle) {
+          await ringingLifecycle.beforeJoin(this);
+          if (supersededByLeave()) {
+            this.logger.debug('Join superseded by leave; not joining');
+            return;
+          }
+        }
 
-      await this.setup();
+        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;
+          }
+        }
 
-      this.clientEventReporter.registerCall(this.cid, {
-        callType: this.type,
-        callId: this.id,
-        getCallSessionId: () => this.state.session?.id ?? '',
-        getSfuId: () => this.credentials?.server.edge_name ?? '',
-      });
+        await this.setup();
+        if (supersededByLeave()) {
+          this.logger.debug('Join superseded by leave; not registering');
+          return;
+        }
 
-      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<string, number>();
-      const joinData: JoinCallData = data;
-      maxJoinRetries = Math.max(maxJoinRetries, 1);
-      try {
+        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<string, number>();
+        const joinData: JoinCallData = 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);
@@ -1202,6 +1254,10 @@ export class Call {
                 delete joinData.migrating_from_list;
                 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) ||
@@ -1242,6 +1298,9 @@ export 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;
       }
     },
@@ -1270,6 +1329,10 @@ export 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) {
@@ -1297,10 +1360,17 @@ export class Call {
           '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 === CallingState.OFFLINE;
@@ -1355,6 +1425,10 @@ export 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
@@ -1388,6 +1462,12 @@ export class Call {
               source: ParticipantSource.WEBRTC_UNSPECIFIED,
             }),
           );
+        if (supersededByLeave()) {
+          this.logger.debug(
+            'Join superseded by leave; not applying SFU response',
+          );
+          return;
+        }
 
         this.currentPublishOptions = publishOptions;
         this.fastReconnectDeadlineSeconds = fastReconnectDeadlineSeconds;
@@ -1399,6 +1479,10 @@ export 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,
@@ -1410,8 +1494,8 @@ export class Call {
       }
     }
 
-    // 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;
@@ -1441,6 +1525,10 @@ export 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) {
@@ -1626,6 +1714,7 @@ export class Call {
     closePreviousInstances: boolean;
     unifiedSessionId: string;
   }) => {
+    const joinLeaveGeneration = this.leaveGeneration;
     const {
       sfuClient,
       connectionConfig,
@@ -1642,10 +1731,12 @@ export class Call {
     // 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: BasePeerConnectionOpts = {
@@ -1692,6 +1783,7 @@ export class Call {
     if (!isAnonymous) {
       if (closePreviousInstances && this.publisher) {
         await this.publisher.dispose();
+        if (this.leaveGeneration !== joinLeaveGeneration) return;
       }
       this.publisher = new Publisher(
         basePeerConnectionOptions,
@@ -1735,9 +1827,19 @@ export 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?: JoinCallData): Promise<JoinCallResponse> => {
+  doJoinRequest = async (
+    data?: JoinCallData,
+  ): Promise<JoinCallResponse | undefined> => {
+    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: JoinCallRequest = { ...data, location, e2ee };
     const joinResponse = await this.streamClient.post<
@@ -1745,6 +1847,13 @@ export class Call {
       JoinCallRequest
     >(`${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);
@@ -1759,6 +1868,7 @@ export 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()) {
@@ -1863,6 +1973,7 @@ export class Call {
       callingState === CallingState.JOINING ||
       callingState === CallingState.RECONNECTING ||
       callingState === CallingState.MIGRATING ||
+      callingState === CallingState.LEFT ||
       callingState === CallingState.RECONNECTING_FAILED
     )
       return;
@@ -1873,19 +1984,26 @@ export 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<string, number>();
 
       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(CallingState.RECONNECTING_FAILED);
+          if (!supersededByLeave()) {
+            this.state.setCallingState(CallingState.RECONNECTING_FAILED);
+          }
         }
       };
 
@@ -1955,6 +2073,7 @@ export class Call {
         try {
           // wait until the network is available
           await this.networkAvailableTask?.promise;
+          if (supersededByLeave()) return;
 
           this.logger.info(
             `[Reconnect] Reconnecting with strategy ${
@@ -2005,6 +2124,7 @@ export class Call {
           this.consecutiveNegotiationFailures = 0;
           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) {
@@ -2048,6 +2168,7 @@ export class Call {
 
           // exponential backoff with jitter, capped at 5 s
           await sleep(retryInterval(attempt));
+          if (supersededByLeave()) return;
 
           const wasMigrating =
             this.reconnectStrategy === WebsocketReconnectStrategy.MIGRATE;
@@ -2078,6 +2199,7 @@ export class Call {
           );
         }
       } while (
+        !supersededByLeave() &&
         this.state.callingState !== CallingState.JOINED &&
         this.state.callingState !== CallingState.RECONNECTING_FAILED &&
         this.state.callingState !== CallingState.LEFT
@@ -2091,10 +2213,12 @@ export class Call {
    * @internal
    */
   private reconnectFast = async () => {
+    const reconnectLeaveGeneration = this.leaveGeneration;
     const reconnectStartTime = Date.now();
     this.reconnectStrategy = WebsocketReconnectStrategy.FAST;
     this.state.setCallingState(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,
@@ -2107,6 +2231,7 @@ export class Call {
    * @internal
    */
   private reconnectRejoin = async () => {
+    const reconnectLeaveGeneration = this.leaveGeneration;
     const reconnectStartTime = Date.now();
     this.reconnectStrategy = WebsocketReconnectStrategy.REJOIN;
     this.state.setCallingState(CallingState.RECONNECTING);
@@ -2119,7 +2244,9 @@ export class Call {
       { 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,
@@ -2132,6 +2259,7 @@ export class Call {
    * @internal
    */
   private reconnectMigrate = async () => {
+    const reconnectLeaveGeneration = this.leaveGeneration;
     const reconnectStartTime = Date.now();
     const currentSfuClient = this.sfuClient;
     if (!currentSfuClient) {
@@ -2149,32 +2277,35 @@ export class Call {
     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;
-    }
+      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();
+      if (this.leaveGeneration !== reconnectLeaveGeneration) return;
+      await this.restorePublishedTracks();
+      if (this.leaveGeneration !== reconnectLeaveGeneration) return;
+      this.restoreSubscribedTracks();
 
-    try {
       // 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
@@ -2508,10 +2639,11 @@ export 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.