@stream-io/video-client 1.5.0 → 1.6.0-0

package/dist/index.cjs.js

@@ -8,8 +8,8 @@ var twirpTransport = require('@protobuf-ts/twirp-transport');
 var rxjs = require('rxjs');
 var SDP = require('sdp-transform');
 var uaParserJs = require('ua-parser-js');
-var WebSocket = require('isomorphic-ws');
 var https = require('https');
+var WebSocket$1 = require('isomorphic-ws');
 var base64Js = require('base64-js');
 
 function _interopNamespaceDefault(e) {
@@ -1035,6 +1035,10 @@ var CallEndedReason;
      * @generated from protobuf enum value: CALL_ENDED_REASON_KICKED = 3;
      */
     CallEndedReason[CallEndedReason["KICKED"] = 3] = "KICKED";
+    /**
+     * @generated from protobuf enum value: CALL_ENDED_REASON_SESSION_ENDED = 4;
+     */
+    CallEndedReason[CallEndedReason["SESSION_ENDED"] = 4] = "SESSION_ENDED";
 })(CallEndedReason || (CallEndedReason = {}));
 /**
  * WebsocketReconnectStrategy defines the ws strategies available for handling reconnections.
@@ -1048,7 +1052,7 @@ var WebsocketReconnectStrategy;
      */
     WebsocketReconnectStrategy[WebsocketReconnectStrategy["UNSPECIFIED"] = 0] = "UNSPECIFIED";
     /**
-     * Sent after reaching the maximum reconnection attempts, leading to permanent disconnect.
+     * Sent after reaching the maximum reconnection attempts, or any other unrecoverable error leading to permanent disconnect.
      *
      * @generated from protobuf enum value: WEBSOCKET_RECONNECT_STRATEGY_DISCONNECT = 1;
      */
@@ -1061,25 +1065,18 @@ var WebsocketReconnectStrategy;
      */
     WebsocketReconnectStrategy[WebsocketReconnectStrategy["FAST"] = 2] = "FAST";
     /**
-     * SDK should drop existing pc instances and creates a fresh WebSocket connection,
-     * ensuring a clean state for the reconnection.
-     *
-     * @generated from protobuf enum value: WEBSOCKET_RECONNECT_STRATEGY_CLEAN = 3;
-     */
-    WebsocketReconnectStrategy[WebsocketReconnectStrategy["CLEAN"] = 3] = "CLEAN";
-    /**
-     * SDK should obtain new credentials from the coordinator, drops existing pc instances, and initializes
+     * SDK should obtain new credentials from the coordinator, drops existing pc instances, set a new session_id and initializes
      * a completely new WebSocket connection, ensuring a comprehensive reset.
      *
-     * @generated from protobuf enum value: WEBSOCKET_RECONNECT_STRATEGY_FULL = 4;
+     * @generated from protobuf enum value: WEBSOCKET_RECONNECT_STRATEGY_REJOIN = 3;
      */
-    WebsocketReconnectStrategy[WebsocketReconnectStrategy["FULL"] = 4] = "FULL";
+    WebsocketReconnectStrategy[WebsocketReconnectStrategy["REJOIN"] = 3] = "REJOIN";
     /**
      * SDK should migrate to a new SFU instance
      *
-     * @generated from protobuf enum value: WEBSOCKET_RECONNECT_STRATEGY_MIGRATE = 5;
+     * @generated from protobuf enum value: WEBSOCKET_RECONNECT_STRATEGY_MIGRATE = 4;
      */
-    WebsocketReconnectStrategy[WebsocketReconnectStrategy["MIGRATE"] = 5] = "MIGRATE";
+    WebsocketReconnectStrategy[WebsocketReconnectStrategy["MIGRATE"] = 4] = "MIGRATE";
 })(WebsocketReconnectStrategy || (WebsocketReconnectStrategy = {}));
 // @generated message type with reflection information, may provide speed optimized methods
 class CallState$Type extends runtime.MessageType {
@@ -1881,6 +1878,7 @@ class TrackInfo$Type extends runtime.MessageType {
             { no: 7, name: 'dtx', kind: 'scalar', T: 8 /*ScalarType.BOOL*/ },
             { no: 8, name: 'stereo', kind: 'scalar', T: 8 /*ScalarType.BOOL*/ },
             { no: 9, name: 'red', kind: 'scalar', T: 8 /*ScalarType.BOOL*/ },
+            { no: 10, name: 'muted', kind: 'scalar', T: 8 /*ScalarType.BOOL*/ },
         ]);
     }
     create(value) {
@@ -1892,6 +1890,7 @@ class TrackInfo$Type extends runtime.MessageType {
         message.dtx = false;
         message.stereo = false;
         message.red = false;
+        message.muted = false;
         if (value !== undefined)
             runtime.reflectionMergePartial(this, message, value);
         return message;
@@ -1922,6 +1921,9 @@ class TrackInfo$Type extends runtime.MessageType {
                 case /* bool red */ 9:
                     message.red = reader.bool();
                     break;
+                case /* bool muted */ 10:
+                    message.muted = reader.bool();
+                    break;
                 default:
                     let u = options.readUnknownField;
                     if (u === 'throw')
@@ -1955,6 +1957,9 @@ class TrackInfo$Type extends runtime.MessageType {
         /* bool red = 9; */
         if (message.red !== false)
             writer.tag(9, runtime.WireType.Varint).bool(message.red);
+        /* bool muted = 10; */
+        if (message.muted !== false)
+            writer.tag(10, runtime.WireType.Varint).bool(message.muted);
         let u = options.writeUnknownFields;
         if (u !== false)
             (u == true ? runtime.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
@@ -1966,108 +1971,6 @@ class TrackInfo$Type extends runtime.MessageType {
  */
 const TrackInfo = new TrackInfo$Type();
 // @generated message type with reflection information, may provide speed optimized methods
-class Call$Type extends runtime.MessageType {
-    constructor() {
-        super('stream.video.sfu.models.Call', [
-            { no: 1, name: 'type', kind: 'scalar', T: 9 /*ScalarType.STRING*/ },
-            { no: 2, name: 'id', kind: 'scalar', T: 9 /*ScalarType.STRING*/ },
-            {
-                no: 3,
-                name: 'created_by_user_id',
-                kind: 'scalar',
-                T: 9 /*ScalarType.STRING*/,
-            },
-            {
-                no: 4,
-                name: 'host_user_id',
-                kind: 'scalar',
-                T: 9 /*ScalarType.STRING*/,
-            },
-            { no: 5, name: 'custom', kind: 'message', T: () => Struct },
-            { no: 6, name: 'created_at', kind: 'message', T: () => Timestamp },
-            { no: 7, name: 'updated_at', kind: 'message', T: () => Timestamp },
-        ]);
-    }
-    create(value) {
-        const message = globalThis.Object.create(this.messagePrototype);
-        message.type = '';
-        message.id = '';
-        message.createdByUserId = '';
-        message.hostUserId = '';
-        if (value !== undefined)
-            runtime.reflectionMergePartial(this, message, value);
-        return message;
-    }
-    internalBinaryRead(reader, length, options, target) {
-        let message = target ?? this.create(), end = reader.pos + length;
-        while (reader.pos < end) {
-            let [fieldNo, wireType] = reader.tag();
-            switch (fieldNo) {
-                case /* string type */ 1:
-                    message.type = reader.string();
-                    break;
-                case /* string id */ 2:
-                    message.id = reader.string();
-                    break;
-                case /* string created_by_user_id */ 3:
-                    message.createdByUserId = reader.string();
-                    break;
-                case /* string host_user_id */ 4:
-                    message.hostUserId = reader.string();
-                    break;
-                case /* google.protobuf.Struct custom */ 5:
-                    message.custom = Struct.internalBinaryRead(reader, reader.uint32(), options, message.custom);
-                    break;
-                case /* google.protobuf.Timestamp created_at */ 6:
-                    message.createdAt = Timestamp.internalBinaryRead(reader, reader.uint32(), options, message.createdAt);
-                    break;
-                case /* google.protobuf.Timestamp updated_at */ 7:
-                    message.updatedAt = Timestamp.internalBinaryRead(reader, reader.uint32(), options, message.updatedAt);
-                    break;
-                default:
-                    let u = options.readUnknownField;
-                    if (u === 'throw')
-                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
-                    let d = reader.skip(wireType);
-                    if (u !== false)
-                        (u === true ? runtime.UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
-            }
-        }
-        return message;
-    }
-    internalBinaryWrite(message, writer, options) {
-        /* string type = 1; */
-        if (message.type !== '')
-            writer.tag(1, runtime.WireType.LengthDelimited).string(message.type);
-        /* string id = 2; */
-        if (message.id !== '')
-            writer.tag(2, runtime.WireType.LengthDelimited).string(message.id);
-        /* string created_by_user_id = 3; */
-        if (message.createdByUserId !== '')
-            writer.tag(3, runtime.WireType.LengthDelimited).string(message.createdByUserId);
-        /* string host_user_id = 4; */
-        if (message.hostUserId !== '')
-            writer.tag(4, runtime.WireType.LengthDelimited).string(message.hostUserId);
-        /* google.protobuf.Struct custom = 5; */
-        if (message.custom)
-            Struct.internalBinaryWrite(message.custom, writer.tag(5, runtime.WireType.LengthDelimited).fork(), options).join();
-        /* google.protobuf.Timestamp created_at = 6; */
-        if (message.createdAt)
-            Timestamp.internalBinaryWrite(message.createdAt, writer.tag(6, runtime.WireType.LengthDelimited).fork(), options).join();
-        /* google.protobuf.Timestamp updated_at = 7; */
-        if (message.updatedAt)
-            Timestamp.internalBinaryWrite(message.updatedAt, writer.tag(7, runtime.WireType.LengthDelimited).fork(), options).join();
-        let u = options.writeUnknownFields;
-        if (u !== false)
-            (u == true ? runtime.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
-        return writer;
-    }
-}
-/**
- * @generated MessageType for protobuf message stream.video.sfu.models.Call
- */
-const Call$1 = new Call$Type();
-// @generated message type with reflection information, may provide speed optimized methods
 let Error$Type$1 = class Error$Type extends runtime.MessageType {
     constructor() {
         super('stream.video.sfu.models.Error', [
@@ -2461,6 +2364,108 @@ class Device$Type extends runtime.MessageType {
  */
 const Device = new Device$Type();
 // @generated message type with reflection information, may provide speed optimized methods
+class Call$Type extends runtime.MessageType {
+    constructor() {
+        super('stream.video.sfu.models.Call', [
+            { no: 1, name: 'type', kind: 'scalar', T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: 'id', kind: 'scalar', T: 9 /*ScalarType.STRING*/ },
+            {
+                no: 3,
+                name: 'created_by_user_id',
+                kind: 'scalar',
+                T: 9 /*ScalarType.STRING*/,
+            },
+            {
+                no: 4,
+                name: 'host_user_id',
+                kind: 'scalar',
+                T: 9 /*ScalarType.STRING*/,
+            },
+            { no: 5, name: 'custom', kind: 'message', T: () => Struct },
+            { no: 6, name: 'created_at', kind: 'message', T: () => Timestamp },
+            { no: 7, name: 'updated_at', kind: 'message', T: () => Timestamp },
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create(this.messagePrototype);
+        message.type = '';
+        message.id = '';
+        message.createdByUserId = '';
+        message.hostUserId = '';
+        if (value !== undefined)
+            runtime.reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* string type */ 1:
+                    message.type = reader.string();
+                    break;
+                case /* string id */ 2:
+                    message.id = reader.string();
+                    break;
+                case /* string created_by_user_id */ 3:
+                    message.createdByUserId = reader.string();
+                    break;
+                case /* string host_user_id */ 4:
+                    message.hostUserId = reader.string();
+                    break;
+                case /* google.protobuf.Struct custom */ 5:
+                    message.custom = Struct.internalBinaryRead(reader, reader.uint32(), options, message.custom);
+                    break;
+                case /* google.protobuf.Timestamp created_at */ 6:
+                    message.createdAt = Timestamp.internalBinaryRead(reader, reader.uint32(), options, message.createdAt);
+                    break;
+                case /* google.protobuf.Timestamp updated_at */ 7:
+                    message.updatedAt = Timestamp.internalBinaryRead(reader, reader.uint32(), options, message.updatedAt);
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === 'throw')
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? runtime.UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* string type = 1; */
+        if (message.type !== '')
+            writer.tag(1, runtime.WireType.LengthDelimited).string(message.type);
+        /* string id = 2; */
+        if (message.id !== '')
+            writer.tag(2, runtime.WireType.LengthDelimited).string(message.id);
+        /* string created_by_user_id = 3; */
+        if (message.createdByUserId !== '')
+            writer.tag(3, runtime.WireType.LengthDelimited).string(message.createdByUserId);
+        /* string host_user_id = 4; */
+        if (message.hostUserId !== '')
+            writer.tag(4, runtime.WireType.LengthDelimited).string(message.hostUserId);
+        /* google.protobuf.Struct custom = 5; */
+        if (message.custom)
+            Struct.internalBinaryWrite(message.custom, writer.tag(5, runtime.WireType.LengthDelimited).fork(), options).join();
+        /* google.protobuf.Timestamp created_at = 6; */
+        if (message.createdAt)
+            Timestamp.internalBinaryWrite(message.createdAt, writer.tag(6, runtime.WireType.LengthDelimited).fork(), options).join();
+        /* google.protobuf.Timestamp updated_at = 7; */
+        if (message.updatedAt)
+            Timestamp.internalBinaryWrite(message.updatedAt, writer.tag(7, runtime.WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? runtime.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message stream.video.sfu.models.Call
+ */
+const Call$1 = new Call$Type();
+// @generated message type with reflection information, may provide speed optimized methods
 class CallGrants$Type extends runtime.MessageType {
     constructor() {
         super('stream.video.sfu.models.CallGrants', [
@@ -3991,6 +3996,13 @@ class SfuEvent$Type extends runtime.MessageType {
                 oneof: 'eventPayload',
                 T: () => ParticipantUpdated,
             },
+            {
+                no: 25,
+                name: 'participant_migration_complete',
+                kind: 'message',
+                oneof: 'eventPayload',
+                T: () => ParticipantMigrationComplete,
+            },
         ]);
     }
     create(value) {
@@ -4125,6 +4137,12 @@ class SfuEvent$Type extends runtime.MessageType {
                         participantUpdated: ParticipantUpdated.internalBinaryRead(reader, reader.uint32(), options, message.eventPayload.participantUpdated),
                     };
                     break;
+                case /* stream.video.sfu.event.ParticipantMigrationComplete participant_migration_complete */ 25:
+                    message.eventPayload = {
+                        oneofKind: 'participantMigrationComplete',
+                        participantMigrationComplete: ParticipantMigrationComplete.internalBinaryRead(reader, reader.uint32(), options, message.eventPayload.participantMigrationComplete),
+                    };
+                    break;
                 default:
                     let u = options.readUnknownField;
                     if (u === 'throw')
@@ -4197,6 +4215,9 @@ class SfuEvent$Type extends runtime.MessageType {
         /* stream.video.sfu.event.ParticipantUpdated participant_updated = 24; */
         if (message.eventPayload.oneofKind === 'participantUpdated')
             ParticipantUpdated.internalBinaryWrite(message.eventPayload.participantUpdated, writer.tag(24, runtime.WireType.LengthDelimited).fork(), options).join();
+        /* stream.video.sfu.event.ParticipantMigrationComplete participant_migration_complete = 25; */
+        if (message.eventPayload.oneofKind === 'participantMigrationComplete')
+            ParticipantMigrationComplete.internalBinaryWrite(message.eventPayload.participantMigrationComplete, writer.tag(25, runtime.WireType.LengthDelimited).fork(), options).join();
         let u = options.writeUnknownFields;
         if (u !== false)
             (u == true ? runtime.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
@@ -4208,6 +4229,31 @@ class SfuEvent$Type extends runtime.MessageType {
  */
 const SfuEvent = new SfuEvent$Type();
 // @generated message type with reflection information, may provide speed optimized methods
+class ParticipantMigrationComplete$Type extends runtime.MessageType {
+    constructor() {
+        super('stream.video.sfu.event.ParticipantMigrationComplete', []);
+    }
+    create(value) {
+        const message = globalThis.Object.create(this.messagePrototype);
+        if (value !== undefined)
+            runtime.reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        return target ?? this.create();
+    }
+    internalBinaryWrite(message, writer, options) {
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? runtime.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message stream.video.sfu.event.ParticipantMigrationComplete
+ */
+const ParticipantMigrationComplete = new ParticipantMigrationComplete$Type();
+// @generated message type with reflection information, may provide speed optimized methods
 class PinsChanged$Type extends runtime.MessageType {
     constructor() {
         super('stream.video.sfu.event.PinsChanged', [
@@ -4458,6 +4504,13 @@ class SfuRequest$Type extends runtime.MessageType {
                 oneof: 'requestPayload',
                 T: () => HealthCheckRequest,
             },
+            {
+                no: 3,
+                name: 'leave_call_request',
+                kind: 'message',
+                oneof: 'requestPayload',
+                T: () => LeaveCallRequest,
+            },
         ]);
     }
     create(value) {
@@ -4484,6 +4537,12 @@ class SfuRequest$Type extends runtime.MessageType {
                         healthCheckRequest: HealthCheckRequest.internalBinaryRead(reader, reader.uint32(), options, message.requestPayload.healthCheckRequest),
                     };
                     break;
+                case /* stream.video.sfu.event.LeaveCallRequest leave_call_request */ 3:
+                    message.requestPayload = {
+                        oneofKind: 'leaveCallRequest',
+                        leaveCallRequest: LeaveCallRequest.internalBinaryRead(reader, reader.uint32(), options, message.requestPayload.leaveCallRequest),
+                    };
+                    break;
                 default:
                     let u = options.readUnknownField;
                     if (u === 'throw')
@@ -4502,6 +4561,9 @@ class SfuRequest$Type extends runtime.MessageType {
         /* stream.video.sfu.event.HealthCheckRequest health_check_request = 2; */
         if (message.requestPayload.oneofKind === 'healthCheckRequest')
             HealthCheckRequest.internalBinaryWrite(message.requestPayload.healthCheckRequest, writer.tag(2, runtime.WireType.LengthDelimited).fork(), options).join();
+        /* stream.video.sfu.event.LeaveCallRequest leave_call_request = 3; */
+        if (message.requestPayload.oneofKind === 'leaveCallRequest')
+            LeaveCallRequest.internalBinaryWrite(message.requestPayload.leaveCallRequest, writer.tag(3, runtime.WireType.LengthDelimited).fork(), options).join();
         let u = options.writeUnknownFields;
         if (u !== false)
             (u == true ? runtime.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
@@ -4513,19 +4575,74 @@ class SfuRequest$Type extends runtime.MessageType {
  */
 const SfuRequest = new SfuRequest$Type();
 // @generated message type with reflection information, may provide speed optimized methods
-class HealthCheckRequest$Type extends runtime.MessageType {
+class LeaveCallRequest$Type extends runtime.MessageType {
     constructor() {
-        super('stream.video.sfu.event.HealthCheckRequest', []);
+        super('stream.video.sfu.event.LeaveCallRequest', [
+            { no: 1, name: 'session_id', kind: 'scalar', T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: 'reason', kind: 'scalar', T: 9 /*ScalarType.STRING*/ },
+        ]);
     }
     create(value) {
         const message = globalThis.Object.create(this.messagePrototype);
+        message.sessionId = '';
+        message.reason = '';
         if (value !== undefined)
             runtime.reflectionMergePartial(this, message, value);
         return message;
     }
     internalBinaryRead(reader, length, options, target) {
-        return target ?? this.create();
-    }
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* string session_id */ 1:
+                    message.sessionId = reader.string();
+                    break;
+                case /* string reason */ 2:
+                    message.reason = reader.string();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === 'throw')
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? runtime.UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* string session_id = 1; */
+        if (message.sessionId !== '')
+            writer.tag(1, runtime.WireType.LengthDelimited).string(message.sessionId);
+        /* string reason = 2; */
+        if (message.reason !== '')
+            writer.tag(2, runtime.WireType.LengthDelimited).string(message.reason);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? runtime.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message stream.video.sfu.event.LeaveCallRequest
+ */
+const LeaveCallRequest = new LeaveCallRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class HealthCheckRequest$Type extends runtime.MessageType {
+    constructor() {
+        super('stream.video.sfu.event.HealthCheckRequest', []);
+    }
+    create(value) {
+        const message = globalThis.Object.create(this.messagePrototype);
+        if (value !== undefined)
+            runtime.reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        return target ?? this.create();
+    }
     internalBinaryWrite(message, writer, options) {
         let u = options.writeUnknownFields;
         if (u !== false)
@@ -4788,6 +4905,12 @@ class JoinRequest$Type extends runtime.MessageType {
                 kind: 'scalar',
                 T: 8 /*ScalarType.BOOL*/,
             },
+            {
+                no: 7,
+                name: 'reconnect_details',
+                kind: 'message',
+                T: () => ReconnectDetails,
+            },
         ]);
     }
     create(value) {
@@ -4817,12 +4940,15 @@ class JoinRequest$Type extends runtime.MessageType {
                 case /* stream.video.sfu.models.ClientDetails client_details */ 4:
                     message.clientDetails = ClientDetails.internalBinaryRead(reader, reader.uint32(), options, message.clientDetails);
                     break;
-                case /* stream.video.sfu.event.Migration migration */ 5:
+                case /* stream.video.sfu.event.Migration migration = 5 [deprecated = true];*/ 5:
                     message.migration = Migration.internalBinaryRead(reader, reader.uint32(), options, message.migration);
                     break;
-                case /* bool fast_reconnect */ 6:
+                case /* bool fast_reconnect = 6 [deprecated = true];*/ 6:
                     message.fastReconnect = reader.bool();
                     break;
+                case /* stream.video.sfu.event.ReconnectDetails reconnect_details */ 7:
+                    message.reconnectDetails = ReconnectDetails.internalBinaryRead(reader, reader.uint32(), options, message.reconnectDetails);
+                    break;
                 default:
                     let u = options.readUnknownField;
                     if (u === 'throw')
@@ -4847,12 +4973,15 @@ class JoinRequest$Type extends runtime.MessageType {
         /* stream.video.sfu.models.ClientDetails client_details = 4; */
         if (message.clientDetails)
             ClientDetails.internalBinaryWrite(message.clientDetails, writer.tag(4, runtime.WireType.LengthDelimited).fork(), options).join();
-        /* stream.video.sfu.event.Migration migration = 5; */
+        /* stream.video.sfu.event.Migration migration = 5 [deprecated = true]; */
         if (message.migration)
             Migration.internalBinaryWrite(message.migration, writer.tag(5, runtime.WireType.LengthDelimited).fork(), options).join();
-        /* bool fast_reconnect = 6; */
+        /* bool fast_reconnect = 6 [deprecated = true]; */
         if (message.fastReconnect !== false)
             writer.tag(6, runtime.WireType.Varint).bool(message.fastReconnect);
+        /* stream.video.sfu.event.ReconnectDetails reconnect_details = 7; */
+        if (message.reconnectDetails)
+            ReconnectDetails.internalBinaryWrite(message.reconnectDetails, writer.tag(7, runtime.WireType.LengthDelimited).fork(), options).join();
         let u = options.writeUnknownFields;
         if (u !== false)
             (u == true ? runtime.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
@@ -4864,6 +4993,129 @@ class JoinRequest$Type extends runtime.MessageType {
  */
 const JoinRequest = new JoinRequest$Type();
 // @generated message type with reflection information, may provide speed optimized methods
+class ReconnectDetails$Type extends runtime.MessageType {
+    constructor() {
+        super('stream.video.sfu.event.ReconnectDetails', [
+            {
+                no: 1,
+                name: 'strategy',
+                kind: 'enum',
+                T: () => [
+                    'stream.video.sfu.models.WebsocketReconnectStrategy',
+                    WebsocketReconnectStrategy,
+                    'WEBSOCKET_RECONNECT_STRATEGY_',
+                ],
+            },
+            {
+                no: 3,
+                name: 'announced_tracks',
+                kind: 'message',
+                repeat: 1 /*RepeatType.PACKED*/,
+                T: () => TrackInfo,
+            },
+            {
+                no: 4,
+                name: 'subscriptions',
+                kind: 'message',
+                repeat: 1 /*RepeatType.PACKED*/,
+                T: () => TrackSubscriptionDetails,
+            },
+            {
+                no: 5,
+                name: 'reconnect_attempt',
+                kind: 'scalar',
+                T: 13 /*ScalarType.UINT32*/,
+            },
+            {
+                no: 6,
+                name: 'from_sfu_id',
+                kind: 'scalar',
+                T: 9 /*ScalarType.STRING*/,
+            },
+            {
+                no: 7,
+                name: 'previous_session_id',
+                kind: 'scalar',
+                T: 9 /*ScalarType.STRING*/,
+            },
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create(this.messagePrototype);
+        message.strategy = 0;
+        message.announcedTracks = [];
+        message.subscriptions = [];
+        message.reconnectAttempt = 0;
+        message.fromSfuId = '';
+        message.previousSessionId = '';
+        if (value !== undefined)
+            runtime.reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* stream.video.sfu.models.WebsocketReconnectStrategy strategy */ 1:
+                    message.strategy = reader.int32();
+                    break;
+                case /* repeated stream.video.sfu.models.TrackInfo announced_tracks */ 3:
+                    message.announcedTracks.push(TrackInfo.internalBinaryRead(reader, reader.uint32(), options));
+                    break;
+                case /* repeated stream.video.sfu.signal.TrackSubscriptionDetails subscriptions */ 4:
+                    message.subscriptions.push(TrackSubscriptionDetails.internalBinaryRead(reader, reader.uint32(), options));
+                    break;
+                case /* uint32 reconnect_attempt */ 5:
+                    message.reconnectAttempt = reader.uint32();
+                    break;
+                case /* string from_sfu_id */ 6:
+                    message.fromSfuId = reader.string();
+                    break;
+                case /* string previous_session_id */ 7:
+                    message.previousSessionId = reader.string();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === 'throw')
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? runtime.UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* stream.video.sfu.models.WebsocketReconnectStrategy strategy = 1; */
+        if (message.strategy !== 0)
+            writer.tag(1, runtime.WireType.Varint).int32(message.strategy);
+        /* repeated stream.video.sfu.models.TrackInfo announced_tracks = 3; */
+        for (let i = 0; i < message.announcedTracks.length; i++)
+            TrackInfo.internalBinaryWrite(message.announcedTracks[i], writer.tag(3, runtime.WireType.LengthDelimited).fork(), options).join();
+        /* repeated stream.video.sfu.signal.TrackSubscriptionDetails subscriptions = 4; */
+        for (let i = 0; i < message.subscriptions.length; i++)
+            TrackSubscriptionDetails.internalBinaryWrite(message.subscriptions[i], writer.tag(4, runtime.WireType.LengthDelimited).fork(), options).join();
+        /* uint32 reconnect_attempt = 5; */
+        if (message.reconnectAttempt !== 0)
+            writer.tag(5, runtime.WireType.Varint).uint32(message.reconnectAttempt);
+        /* string from_sfu_id = 6; */
+        if (message.fromSfuId !== '')
+            writer.tag(6, runtime.WireType.LengthDelimited).string(message.fromSfuId);
+        /* string previous_session_id = 7; */
+        if (message.previousSessionId !== '')
+            writer.tag(7, runtime.WireType.LengthDelimited).string(message.previousSessionId);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? runtime.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message stream.video.sfu.event.ReconnectDetails
+ */
+const ReconnectDetails = new ReconnectDetails$Type();
+// @generated message type with reflection information, may provide speed optimized methods
 class Migration$Type extends runtime.MessageType {
     constructor() {
         super('stream.video.sfu.event.Migration', [
@@ -4949,11 +5201,18 @@ class JoinResponse$Type extends runtime.MessageType {
         super('stream.video.sfu.event.JoinResponse', [
             { no: 1, name: 'call_state', kind: 'message', T: () => CallState$1 },
             { no: 2, name: 'reconnected', kind: 'scalar', T: 8 /*ScalarType.BOOL*/ },
+            {
+                no: 3,
+                name: 'fast_reconnect_deadline_seconds',
+                kind: 'scalar',
+                T: 5 /*ScalarType.INT32*/,
+            },
         ]);
     }
     create(value) {
         const message = globalThis.Object.create(this.messagePrototype);
         message.reconnected = false;
+        message.fastReconnectDeadlineSeconds = 0;
         if (value !== undefined)
             runtime.reflectionMergePartial(this, message, value);
         return message;
@@ -4969,6 +5228,9 @@ class JoinResponse$Type extends runtime.MessageType {
                 case /* bool reconnected */ 2:
                     message.reconnected = reader.bool();
                     break;
+                case /* int32 fast_reconnect_deadline_seconds */ 3:
+                    message.fastReconnectDeadlineSeconds = reader.int32();
+                    break;
                 default:
                     let u = options.readUnknownField;
                     if (u === 'throw')
@@ -4987,6 +5249,11 @@ class JoinResponse$Type extends runtime.MessageType {
         /* bool reconnected = 2; */
         if (message.reconnected !== false)
             writer.tag(2, runtime.WireType.Varint).bool(message.reconnected);
+        /* int32 fast_reconnect_deadline_seconds = 3; */
+        if (message.fastReconnectDeadlineSeconds !== 0)
+            writer
+                .tag(3, runtime.WireType.Varint)
+                .int32(message.fastReconnectDeadlineSeconds);
         let u = options.writeUnknownFields;
         if (u !== false)
             (u == true ? runtime.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
@@ -6187,12 +6454,15 @@ var events = /*#__PURE__*/Object.freeze({
     ICETrickle: ICETrickle,
     JoinRequest: JoinRequest,
     JoinResponse: JoinResponse,
+    LeaveCallRequest: LeaveCallRequest,
     Migration: Migration,
     ParticipantJoined: ParticipantJoined,
     ParticipantLeft: ParticipantLeft,
+    ParticipantMigrationComplete: ParticipantMigrationComplete,
     ParticipantUpdated: ParticipantUpdated,
     PinsChanged: PinsChanged,
     PublisherAnswer: PublisherAnswer,
+    ReconnectDetails: ReconnectDetails,
     SfuEvent: SfuEvent,
     SfuRequest: SfuRequest,
     SubscriberOffer: SubscriberOffer,
@@ -6318,6 +6588,17 @@ const withHeaders = (headers) => {
         },
     };
 };
+const withRequestLogger = (logger, level) => {
+    return {
+        interceptUnary: (next, method, input, options) => {
+            logger(level, `Calling SFU RPC method ${method.name}`, {
+                input,
+                options,
+            });
+            return next(method, input, options);
+        },
+    };
+};
 /**
  * Creates new SignalServerClient instance.
  *
@@ -6331,68 +6612,196 @@ const createSignalClient = (options) => {
     return new SignalServerClient(transport);
 };
 
+const sleep = (m) => new Promise((r) => setTimeout(r, m));
+function isFunction(value) {
+    return (value &&
+        (Object.prototype.toString.call(value) === '[object Function]' ||
+            'function' === typeof value ||
+            value instanceof Function));
+}
 /**
- * Checks whether we are using React Native
+ * A map of known error codes.
  */
-const isReactNative = () => {
-    if (typeof navigator === 'undefined')
-        return false;
-    return navigator.product?.toLowerCase() === 'reactnative';
+const KnownCodes = {
+    TOKEN_EXPIRED: 40,
+    WS_CLOSED_SUCCESS: 1000,
+    WS_CLOSED_ABRUPTLY: 1006,
+    WS_POLICY_VIOLATION: 1008,
 };
-
-// log levels, sorted by verbosity
-const logLevels = Object.freeze({
-    trace: 0,
-    debug: 1,
-    info: 2,
-    warn: 3,
-    error: 4,
-});
-let logger$4;
-let level = 'info';
-const logToConsole = (logLevel, message, ...args) => {
-    let logMethod;
-    switch (logLevel) {
-        case 'error':
-            if (isReactNative()) {
-                message = `ERROR: ${message}`;
-                logMethod = console.info;
-                break;
-            }
-            logMethod = console.error;
-            break;
-        case 'warn':
-            if (isReactNative()) {
-                message = `WARN: ${message}`;
-                logMethod = console.info;
-                break;
-            }
-            logMethod = console.warn;
-            break;
-        case 'info':
-            logMethod = console.info;
-            break;
-        case 'trace':
-            logMethod = console.trace;
-            break;
-        default:
-            logMethod = console.log;
-            break;
+/**
+ * retryInterval - A retry interval which increases acc to number of failures
+ *
+ * @return {number} Duration to wait in milliseconds
+ */
+function retryInterval(numberOfFailures) {
+    // try to reconnect in 0.25-5 seconds (random to spread out the load from failures)
+    const max = Math.min(500 + numberOfFailures * 2000, 5000);
+    const min = Math.min(Math.max(250, (numberOfFailures - 1) * 2000), 5000);
+    return Math.floor(Math.random() * (max - min) + min);
+}
+function randomId() {
+    return generateUUIDv4();
+}
+function hex(bytes) {
+    let s = '';
+    for (let i = 0; i < bytes.length; i++) {
+        s += bytes[i].toString(16).padStart(2, '0');
     }
-    logMethod(message, ...args);
-};
-const setLogger = (l, lvl) => {
-    logger$4 = l;
-    if (lvl) {
-        setLogLevel(lvl);
+    return s;
+}
+// https://tools.ietf.org/html/rfc4122
+function generateUUIDv4() {
+    const bytes = getRandomBytes(16);
+    bytes[6] = (bytes[6] & 0x0f) | 0x40; // version
+    bytes[8] = (bytes[8] & 0xbf) | 0x80; // variant
+    return (hex(bytes.subarray(0, 4)) +
+        '-' +
+        hex(bytes.subarray(4, 6)) +
+        '-' +
+        hex(bytes.subarray(6, 8)) +
+        '-' +
+        hex(bytes.subarray(8, 10)) +
+        '-' +
+        hex(bytes.subarray(10, 16)));
+}
+function getRandomValuesWithMathRandom(bytes) {
+    const max = Math.pow(2, (8 * bytes.byteLength) / bytes.length);
+    for (let i = 0; i < bytes.length; i++) {
+        bytes[i] = Math.random() * max;
     }
-};
-const setLogLevel = (l) => {
-    level = l;
-};
+}
+const getRandomValues = (() => {
+    if (typeof crypto !== 'undefined' &&
+        typeof crypto?.getRandomValues !== 'undefined') {
+        return crypto.getRandomValues.bind(crypto);
+    }
+    else if (typeof msCrypto !== 'undefined') {
+        return msCrypto.getRandomValues.bind(msCrypto);
+    }
+    else {
+        return getRandomValuesWithMathRandom;
+    }
+})();
+function getRandomBytes(length) {
+    const bytes = new Uint8Array(length);
+    getRandomValues(bytes);
+    return bytes;
+}
+function convertErrorToJson(err) {
+    const jsonObj = {};
+    if (!err)
+        return jsonObj;
+    try {
+        Object.getOwnPropertyNames(err).forEach((key) => {
+            jsonObj[key] = Object.getOwnPropertyDescriptor(err, key);
+        });
+    }
+    catch (_) {
+        return {
+            error: 'failed to serialize the error',
+        };
+    }
+    return jsonObj;
+}
+/**
+ * isOnline safely return the navigator.online value for browser env
+ * if navigator is not in global object, it always return true
+ */
+function isOnline(logger) {
+    const nav = typeof navigator !== 'undefined'
+        ? navigator
+        : typeof window !== 'undefined' && window.navigator
+            ? window.navigator
+            : undefined;
+    if (!nav) {
+        logger('warn', 'isOnline failed to access window.navigator and assume browser is online');
+        return true;
+    }
+    // RN navigator has undefined for onLine
+    if (typeof nav.onLine !== 'boolean') {
+        return true;
+    }
+    return nav.onLine;
+}
+/**
+ * listenForConnectionChanges - Adds an event listener fired on browser going online or offline
+ */
+function addConnectionEventListeners(cb) {
+    if (typeof window !== 'undefined' && window.addEventListener) {
+        window.addEventListener('offline', cb);
+        window.addEventListener('online', cb);
+    }
+}
+function removeConnectionEventListeners(cb) {
+    if (typeof window !== 'undefined' && window.removeEventListener) {
+        window.removeEventListener('offline', cb);
+        window.removeEventListener('online', cb);
+    }
+}
+
+/**
+ * Checks whether we are using React Native
+ */
+const isReactNative = () => {
+    if (typeof navigator === 'undefined')
+        return false;
+    return navigator.product?.toLowerCase() === 'reactnative';
+};
+
+// log levels, sorted by verbosity
+const logLevels = Object.freeze({
+    trace: 0,
+    debug: 1,
+    info: 2,
+    warn: 3,
+    error: 4,
+});
+let logger$2;
+let level = 'info';
+const logToConsole = (logLevel, message, ...args) => {
+    let logMethod;
+    switch (logLevel) {
+        case 'error':
+            if (isReactNative()) {
+                message = `ERROR: ${message}`;
+                logMethod = console.info;
+                break;
+            }
+            logMethod = console.error;
+            break;
+        case 'warn':
+            if (isReactNative()) {
+                message = `WARN: ${message}`;
+                logMethod = console.info;
+                break;
+            }
+            logMethod = console.warn;
+            break;
+        case 'info':
+            logMethod = console.info;
+            break;
+        case 'trace':
+            logMethod = console.trace;
+            break;
+        default:
+            logMethod = console.log;
+            break;
+    }
+    logMethod(message, ...args);
+};
+const setLogger = (l, lvl) => {
+    logger$2 = l;
+    if (lvl) {
+        setLogLevel(lvl);
+    }
+};
+const setLogLevel = (l) => {
+    level = l;
+};
+const getLogLevel = () => level;
 const getLogger = (withTags) => {
-    const loggerMethod = logger$4 || logToConsole;
-    const tags = (withTags || []).join(':');
+    const loggerMethod = logger$2 || logToConsole;
+    const tags = (withTags || []).filter(Boolean).join(':');
     const result = (logLevel, message, ...args) => {
         if (logLevels[logLevel] >= logLevels[level]) {
             loggerMethod(logLevel, `[${tags}]: ${message}`, ...args);
@@ -6401,6 +6810,37 @@ const getLogger = (withTags) => {
     return result;
 };
 
+/**
+ * Creates a closure which wraps the given RPC call and retries invoking
+ * the RPC until it succeeds or the maximum number of retries is reached.
+ *
+ * For each retry, there would be a delay to avoid request bursts toward the SFU.
+ *
+ * @param rpc the closure around the RPC call to execute.
+ * @param signal the signal to abort the RPC call and retries loop.
+ */
+const retryable = async (rpc, signal) => {
+    let attempt = 0;
+    let result = undefined;
+    do {
+        if (attempt > 0)
+            await sleep(retryInterval(attempt));
+        try {
+            result = await rpc();
+        }
+        catch (err) {
+            const isRequestCancelled = err instanceof runtimeRpc.RpcError &&
+                err.code === twirpTransport.TwirpErrorCode[twirpTransport.TwirpErrorCode.cancelled];
+            const isAborted = signal?.aborted ?? false;
+            if (isRequestCancelled || isAborted)
+                throw err;
+            getLogger(['sfu-client', 'rpc'])('debug', `rpc failed (${attempt})`, err);
+            attempt++;
+        }
+    } while (!result || result.response.error?.shouldRetry);
+    return result;
+};
+
 const getPreferredCodecs = (kind, preferredCodec, codecToRemove) => {
     const logger = getLogger(['codecs']);
     if (!('getCapabilities' in RTCRtpReceiver)) {
@@ -6473,6 +6913,7 @@ const sfuEventKinds = {
     pinsUpdated: undefined,
     callEnded: undefined,
     participantUpdated: undefined,
+    participantMigrationComplete: undefined,
 };
 const isSfuEvent = (eventName) => {
     return Object.prototype.hasOwnProperty.call(sfuEventKinds, eventName);
@@ -6481,12 +6922,12 @@ class Dispatcher {
     constructor() {
         this.logger = getLogger(['Dispatcher']);
         this.subscribers = {};
-        this.dispatch = (message) => {
+        this.dispatch = (message, logTag) => {
             const eventKind = message.eventPayload.oneofKind;
             if (!eventKind)
                 return;
             const payload = message.eventPayload[eventKind];
-            this.logger('debug', `Dispatching ${eventKind}`, payload);
+            this.logger('debug', `Dispatching ${eventKind}, tag=${logTag}`, payload);
             const listeners = this.subscribers[eventKind];
             if (!listeners)
                 return;
@@ -6528,7 +6969,6 @@ class IceTrickleBuffer {
     constructor() {
         this.subscriberCandidates = new rxjs.ReplaySubject();
         this.publisherCandidates = new rxjs.ReplaySubject();
-        this.logger = getLogger(['sfu-client']);
         this.push = (iceTrickle) => {
             if (iceTrickle.peerType === PeerType.SUBSCRIBER) {
                 this.subscriberCandidates.next(iceTrickle);
@@ -6537,7 +6977,8 @@ class IceTrickleBuffer {
                 this.publisherCandidates.next(iceTrickle);
             }
             else {
-                this.logger('warn', `ICETrickle, Unknown peer type`, iceTrickle);
+                const logger = getLogger(['sfu-client']);
+                logger('warn', `ICETrickle, Unknown peer type`, iceTrickle);
             }
         };
     }
@@ -6556,72 +6997,6 @@ function getIceCandidate(candidate) {
     }
 }
 
-const version = "1.5.0" ;
-const [major, minor, patch] = version.split('.');
-let sdkInfo = {
-    type: SdkType.PLAIN_JAVASCRIPT,
-    major,
-    minor,
-    patch,
-};
-let osInfo;
-let deviceInfo;
-let webRtcInfo;
-const setSdkInfo = (info) => {
-    sdkInfo = info;
-};
-const getSdkInfo = () => {
-    return sdkInfo;
-};
-const setOSInfo = (info) => {
-    osInfo = info;
-};
-const getOSInfo = () => {
-    return osInfo;
-};
-const setDeviceInfo = (info) => {
-    deviceInfo = info;
-};
-const getDeviceInfo = () => {
-    return deviceInfo;
-};
-const getWebRTCInfo = () => {
-    return webRtcInfo;
-};
-const setWebRTCInfo = (info) => {
-    webRtcInfo = info;
-};
-const getClientDetails = () => {
-    if (isReactNative()) {
-        // Since RN doesn't support web, sharing browser info is not required
-        return {
-            sdk: getSdkInfo(),
-            os: getOSInfo(),
-            device: getDeviceInfo(),
-        };
-    }
-    const userAgent = new uaParserJs.UAParser(navigator.userAgent);
-    const { browser, os, device, cpu } = userAgent.getResult();
-    return {
-        sdk: getSdkInfo(),
-        browser: {
-            name: browser.name || navigator.userAgent,
-            version: browser.version || '',
-        },
-        os: {
-            name: os.name || '',
-            version: os.version || '',
-            architecture: cpu.architecture || '',
-        },
-        device: {
-            name: [device.vendor, device.model, device.type]
-                .filter(Boolean)
-                .join(' '),
-            version: '',
-        },
-    };
-};
-
 const DEFAULT_BITRATE = 1250000;
 const defaultTargetResolution = {
     bitrate: DEFAULT_BITRATE,
@@ -6644,7 +7019,6 @@ const findOptimalVideoLayers = (videoTrack, targetResolution = defaultTargetReso
     const optimalVideoLayers = [];
     const settings = videoTrack.getSettings();
     const { width: w = 0, height: h = 0 } = settings;
-    const isRNIos = isReactNative() && getOSInfo()?.name.toLowerCase() === 'ios';
     const maxBitrate = getComputedMaxBitrate(targetResolution, w, h);
     let downscaleFactor = 1;
     ['f', 'h', 'q'].forEach((rid) => {
@@ -6658,12 +7032,7 @@ const findOptimalVideoLayers = (videoTrack, targetResolution = defaultTargetReso
             height: Math.round(h / downscaleFactor),
             maxBitrate: Math.round(maxBitrate / downscaleFactor) || defaultBitratePerRid[rid],
             scaleResolutionDownBy: downscaleFactor,
-            // Simulcast on iOS React-Native requires all encodings to share the same framerate
-            maxFramerate: {
-                f: 30,
-                h: isRNIos ? 30 : 25,
-                q: isRNIos ? 30 : 20,
-            }[rid],
+            maxFramerate: 30,
         });
         downscaleFactor *= 2;
     });
@@ -6738,6 +7107,10 @@ const findOptimalScreenSharingLayers = (videoTrack, preferences, defaultMaxBitra
     ];
 };
 
+const ensureExhausted = (x, message) => {
+    getLogger(['helpers'])('warn', message, x);
+};
+
 const trackTypeToParticipantStreamKey = (trackType) => {
     switch (trackType) {
         case TrackType.SCREEN_SHARE:
@@ -6751,8 +7124,7 @@ const trackTypeToParticipantStreamKey = (trackType) => {
         case TrackType.UNSPECIFIED:
             throw new Error('Track type is unspecified');
         default:
-            const exhaustiveTrackTypeCheck = trackType;
-            throw new Error(`Unknown track type: ${exhaustiveTrackTypeCheck}`);
+            ensureExhausted(trackType, 'Unknown track type');
     }
 };
 const muteTypeToTrackType = (muteType) => {
@@ -6766,8 +7138,21 @@ const muteTypeToTrackType = (muteType) => {
         case 'screenshare_audio':
             return TrackType.SCREEN_SHARE_AUDIO;
         default:
-            const exhaustiveMuteTypeCheck = muteType;
-            throw new Error(`Unknown mute type: ${exhaustiveMuteTypeCheck}`);
+            ensureExhausted(muteType, 'Unknown mute type');
+    }
+};
+const toTrackType = (trackType) => {
+    switch (trackType) {
+        case 'TRACK_TYPE_AUDIO':
+            return TrackType.AUDIO;
+        case 'TRACK_TYPE_VIDEO':
+            return TrackType.VIDEO;
+        case 'TRACK_TYPE_SCREEN_SHARE':
+            return TrackType.SCREEN_SHARE;
+        case 'TRACK_TYPE_SCREEN_SHARE_AUDIO':
+            return TrackType.SCREEN_SHARE_AUDIO;
+        default:
+            return undefined;
     }
 };
 
@@ -7287,6 +7672,11 @@ class CallState {
         this.anonymousParticipantCountSubject = new rxjs.BehaviorSubject(0);
         this.participantsSubject = new rxjs.BehaviorSubject([]);
         this.callStatsReportSubject = new rxjs.BehaviorSubject(undefined);
+        // These are tracks that were delivered to the Subscriber's onTrack event
+        // that we couldn't associate with a participant yet.
+        // This happens when the participantJoined event hasn't been received yet.
+        // We keep these tracks around until we can associate them with a participant.
+        this.orphanedTracks = [];
         this.logger = getLogger(['CallState']);
         /**
          * A list of comparators that are used to sort the participants.
@@ -7476,7 +7866,7 @@ class CallState {
          */
         this.updateParticipants = (patch) => {
             if (Object.keys(patch).length === 0)
-                return;
+                return this.participants;
             return this.setParticipants((participants) => participants.map((p) => {
                 const thePatch = patch[p.sessionId];
                 if (thePatch) {
@@ -7535,6 +7925,41 @@ class CallState {
                 return participant;
             }));
         };
+        /**
+         * Adds an orphaned track to the call state.
+         *
+         * @internal
+         *
+         * @param orphanedTrack the orphaned track to add.
+         */
+        this.registerOrphanedTrack = (orphanedTrack) => {
+            this.orphanedTracks.push(orphanedTrack);
+        };
+        /**
+         * Removes an orphaned track from the call state.
+         *
+         * @internal
+         *
+         * @param id the ID of the orphaned track to remove.
+         */
+        this.removeOrphanedTrack = (id) => {
+            this.orphanedTracks = this.orphanedTracks.filter((o) => o.id !== id);
+        };
+        /**
+         * Takes all orphaned tracks with the given track lookup prefix.
+         * All orphaned tracks with the given track lookup prefix are removed from the call state.
+         *
+         * @internal
+         *
+         * @param trackLookupPrefix the track lookup prefix to match the orphaned tracks by.
+         */
+        this.takeOrphanedTracks = (trackLookupPrefix) => {
+            const orphans = this.orphanedTracks.filter((orphan) => orphan.trackLookupPrefix === trackLookupPrefix);
+            if (orphans.length > 0) {
+                this.orphanedTracks = this.orphanedTracks.filter((orphan) => orphan.trackLookupPrefix !== trackLookupPrefix);
+            }
+            return orphans;
+        };
         /**
          * Updates the call state with the data received from the server.
          *
@@ -7559,6 +7984,43 @@ class CallState {
             this.setCurrentValue(this.transcribingSubject, call.transcribing);
             this.setCurrentValue(this.thumbnailsSubject, call.thumbnails);
         };
+        /**
+         * Updates the call state with the data received from the SFU server.
+         *
+         * @internal
+         *
+         * @param callState the call state from the SFU server.
+         * @param currentSessionId the session ID of the current user.
+         * @param reconnectDetails optional reconnect details.
+         */
+        this.updateFromSfuCallState = (callState, currentSessionId, reconnectDetails) => {
+            const { participants, participantCount, startedAt, pins } = callState;
+            const localPublishedTracks = reconnectDetails?.announcedTracks.map((t) => t.trackType) ?? [];
+            this.setParticipants(() => {
+                const participantLookup = this.getParticipantLookupBySessionId();
+                return participants.map((p) => {
+                    // We need to preserve the local state of the participant
+                    // (e.g. videoDimension, visibilityState, pinnedAt, etc.)
+                    // as it doesn't exist on the server.
+                    const existingParticipant = participantLookup[p.sessionId];
+                    const isLocalParticipant = p.sessionId === currentSessionId;
+                    return Object.assign({}, existingParticipant, p, {
+                        isLocalParticipant,
+                        publishedTracks: isLocalParticipant
+                            ? localPublishedTracks
+                            : p.publishedTracks,
+                        viewportVisibilityState: existingParticipant?.viewportVisibilityState ?? {
+                            videoTrack: exports.VisibilityState.UNKNOWN,
+                            screenShareTrack: exports.VisibilityState.UNKNOWN,
+                        },
+                    });
+                });
+            });
+            this.setParticipantCount(participantCount?.total || 0);
+            this.setAnonymousParticipantCount(participantCount?.anonymous || 0);
+            this.setStartedAt(startedAt ? Timestamp.toDate(startedAt) : new Date());
+            this.setServerSidePins(pins);
+        };
         this.updateFromMemberRemoved = (event) => {
             this.updateFromCallResponse(event.call);
             this.setCurrentValue(this.membersSubject, (members) => members.filter((m) => event.members.indexOf(m.user_id) === -1));
@@ -8270,13 +8732,79 @@ const enableHighQualityAudio = (sdp, trackMid, maxBitrate = 510000) => {
     return SDP__namespace.write(parsedSdp);
 };
 
-const logger$3 = getLogger(['Publisher']);
-/**
- * The `Publisher` is responsible for publishing/unpublishing media streams to/from the SFU
- * @internal
- */
-class Publisher {
-    /**
+const version = "1.6.0-0" ;
+const [major, minor, patch] = version.split('.');
+let sdkInfo = {
+    type: SdkType.PLAIN_JAVASCRIPT,
+    major,
+    minor,
+    patch,
+};
+let osInfo;
+let deviceInfo;
+let webRtcInfo;
+const setSdkInfo = (info) => {
+    sdkInfo = info;
+};
+const getSdkInfo = () => {
+    return sdkInfo;
+};
+const setOSInfo = (info) => {
+    osInfo = info;
+};
+const getOSInfo = () => {
+    return osInfo;
+};
+const setDeviceInfo = (info) => {
+    deviceInfo = info;
+};
+const getDeviceInfo = () => {
+    return deviceInfo;
+};
+const getWebRTCInfo = () => {
+    return webRtcInfo;
+};
+const setWebRTCInfo = (info) => {
+    webRtcInfo = info;
+};
+const getClientDetails = () => {
+    if (isReactNative()) {
+        // Since RN doesn't support web, sharing browser info is not required
+        return {
+            sdk: getSdkInfo(),
+            os: getOSInfo(),
+            device: getDeviceInfo(),
+        };
+    }
+    const userAgent = new uaParserJs.UAParser(navigator.userAgent);
+    const { browser, os, device, cpu } = userAgent.getResult();
+    return {
+        sdk: getSdkInfo(),
+        browser: {
+            name: browser.name || navigator.userAgent,
+            version: browser.version || '',
+        },
+        os: {
+            name: os.name || '',
+            version: os.version || '',
+            architecture: cpu.architecture || '',
+        },
+        device: {
+            name: [device.vendor, device.model, device.type]
+                .filter(Boolean)
+                .join(' '),
+            version: '',
+        },
+    };
+};
+
+/**
+ * The `Publisher` is responsible for publishing/unpublishing media streams to/from the SFU
+ *
+ * @internal
+ */
+class Publisher {
+    /**
      * Returns the current connection configuration.
      *
      * @internal
@@ -8297,8 +8825,9 @@ class Publisher {
      * @param isRedEnabled whether RED is enabled.
      * @param iceRestartDelay the delay in milliseconds to wait before restarting ICE once connection goes to `disconnected` state.
      * @param onUnrecoverableError a callback to call when an unrecoverable error occurs.
+     * @param logTag the log tag to use.
      */
-    constructor({ connectionConfig, sfuClient, dispatcher, state, isDtxEnabled, isRedEnabled, iceRestartDelay = 2500, onUnrecoverableError, }) {
+    constructor({ connectionConfig, sfuClient, dispatcher, state, isDtxEnabled, isRedEnabled, onUnrecoverableError, logTag, }) {
         this.transceiverRegistry = {
             [TrackType.AUDIO]: undefined,
             [TrackType.VIDEO]: undefined,
@@ -8312,7 +8841,7 @@ class Publisher {
          * This is needed because some browsers (Firefox) don't reliably report
          * trackId and `mid` parameters.
          *
-         * @private
+         * @internal
          */
         this.transceiverInitOrder = [];
         this.trackKindMapping = {
@@ -8344,7 +8873,7 @@ class Publisher {
         /**
          * Closes the publisher PeerConnection and cleans up the resources.
          */
-        this.close = ({ stopTracks = true } = {}) => {
+        this.close = ({ stopTracks }) => {
             if (stopTracks) {
                 this.stopPublishing();
                 Object.keys(this.transceiverRegistry).forEach((trackType) => {
@@ -8356,10 +8885,22 @@ class Publisher {
                     this.trackLayersCache[trackType] = undefined;
                 });
             }
-            clearTimeout(this.iceRestartTimeout);
+            this.detachEventHandlers();
+            this.pc.close();
+        };
+        /**
+         * Detaches the event handlers from the `RTCPeerConnection`.
+         * This is useful when we want to replace the `RTCPeerConnection`
+         * instance with a new one (in case of migration).
+         */
+        this.detachEventHandlers = () => {
             this.unsubscribeOnIceRestart();
+            this.pc.removeEventListener('icecandidate', this.onIceCandidate);
             this.pc.removeEventListener('negotiationneeded', this.onNegotiationNeeded);
-            this.pc.close();
+            this.pc.removeEventListener('icecandidateerror', this.onIceCandidateError);
+            this.pc.removeEventListener('iceconnectionstatechange', this.onIceConnectionStateChange);
+            this.pc.removeEventListener('icegatheringstatechange', this.onIceGatheringStateChange);
+            this.pc.removeEventListener('signalingstatechange', this.onSignalingStateChange);
         };
         /**
          * Starts publishing the given track of the given media stream.
@@ -8386,7 +8927,7 @@ class Publisher {
              * Once the track has ended, it will notify the SFU and update the state.
              */
             const handleTrackEnded = async () => {
-                logger$3('info', `Track ${TrackType[trackType]} has ended, notifying the SFU`);
+                this.logger('info', `Track ${TrackType[trackType]} has ended, notifying the SFU`);
                 await this.notifyTrackMuteStateChanged(mediaStream, trackType, true);
                 // clean-up, this event listener needs to run only once.
                 track.removeEventListener('ended', handleTrackEnded);
@@ -8402,21 +8943,18 @@ class Publisher {
                         ? findOptimalScreenSharingLayers(track, opts.screenShareSettings, screenShareBitrate)
                         : undefined;
                 let preferredCodec = opts.preferredCodec;
-                if (!preferredCodec && trackType === TrackType.VIDEO) {
-                    if (isReactNative()) {
-                        const osName = getOSInfo()?.name.toLowerCase();
-                        if (osName === 'ipados') {
-                            // in ipads it was noticed that if vp8 codec is used
-                            // then the bytes sent is 0 in the outbound-rtp
-                            // so we are forcing h264 codec for ipads
-                            preferredCodec = 'H264';
-                        }
-                        else if (osName === 'android') {
-                            preferredCodec = 'VP8';
-                        }
+                if (!preferredCodec && trackType === TrackType.VIDEO && isReactNative()) {
+                    const osName = getOSInfo()?.name.toLowerCase();
+                    if (osName === 'ipados') {
+                        // in ipads it was noticed that if vp8 codec is used
+                        // then the bytes sent is 0 in the outbound-rtp
+                        // so we are forcing h264 codec for ipads
+                        preferredCodec = 'H264';
+                    }
+                    else if (osName === 'android') {
+                        preferredCodec = 'VP8';
                     }
                 }
-                const codecPreferences = this.getCodecPreferences(trackType, preferredCodec);
                 // listen for 'ended' event on the track as it might be ended abruptly
                 // by an external factor as permission revokes, device disconnected, etc.
                 // keep in mind that `track.stop()` doesn't trigger this event.
@@ -8431,17 +8969,20 @@ class Publisher {
                         : undefined,
                     sendEncodings: videoEncodings,
                 });
-                logger$3('debug', `Added ${TrackType[trackType]} transceiver`);
+                this.logger('debug', `Added ${TrackType[trackType]} transceiver`);
                 this.transceiverInitOrder.push(trackType);
                 this.transceiverRegistry[trackType] = transceiver;
                 this.publishOptionsPerTrackType.set(trackType, opts);
-                if ('setCodecPreferences' in transceiver && codecPreferences) {
-                    logger$3('info', `Setting ${TrackType[trackType]} codec preferences`, codecPreferences);
+                const codecPreferences = 'setCodecPreferences' in transceiver
+                    ? this.getCodecPreferences(trackType, preferredCodec)
+                    : undefined;
+                if (codecPreferences) {
+                    this.logger('info', `Setting ${TrackType[trackType]} codec preferences`, codecPreferences);
                     try {
                         transceiver.setCodecPreferences(codecPreferences);
                     }
                     catch (err) {
-                        logger$3('warn', `Couldn't set codec preferences`, err);
+                        this.logger('warn', `Couldn't set codec preferences`, err);
                     }
                 }
             }
@@ -8490,31 +9031,17 @@ class Publisher {
          * @param trackType the track type to check.
          */
         this.isPublishing = (trackType) => {
-            const transceiverForTrackType = this.transceiverRegistry[trackType];
-            if (transceiverForTrackType && transceiverForTrackType.sender) {
-                const sender = transceiverForTrackType.sender;
-                return (!!sender.track &&
-                    sender.track.readyState === 'live' &&
-                    sender.track.enabled);
-            }
-            return false;
-        };
-        /**
-         * Returns true if the given track type is currently live
-         *
-         * @param trackType the track type to check.
-         */
-        this.isLive = (trackType) => {
-            const transceiverForTrackType = this.transceiverRegistry[trackType];
-            if (transceiverForTrackType && transceiverForTrackType.sender) {
-                const sender = transceiverForTrackType.sender;
-                return !!sender.track && sender.track.readyState === 'live';
-            }
-            return false;
+            const transceiver = this.transceiverRegistry[trackType];
+            if (!transceiver || !transceiver.sender)
+                return false;
+            const track = transceiver.sender.track;
+            return !!track && track.readyState === 'live' && track.enabled;
         };
         this.notifyTrackMuteStateChanged = async (mediaStream, trackType, isMuted) => {
             await this.sfuClient.updateMuteState(trackType, isMuted);
             const audioOrVideoOrScreenShareStream = trackTypeToParticipantStreamKey(trackType);
+            if (!audioOrVideoOrScreenShareStream)
+                return;
             if (isMuted) {
                 this.state.updateParticipant(this.sfuClient.sessionId, (p) => ({
                     publishedTracks: p.publishedTracks.filter((t) => t !== trackType),
@@ -8536,7 +9063,7 @@ class Publisher {
          * Stops publishing all tracks and stop all tracks.
          */
         this.stopPublishing = () => {
-            logger$3('debug', 'Stopping publishing all tracks');
+            this.logger('debug', 'Stopping publishing all tracks');
             this.pc.getSenders().forEach((s) => {
                 s.track?.stop();
                 if (this.pc.signalingState !== 'closed') {
@@ -8545,15 +9072,15 @@ class Publisher {
             });
         };
         this.updateVideoPublishQuality = async (enabledLayers) => {
-            logger$3('info', 'Update publish quality, requested layers by SFU:', enabledLayers);
+            this.logger('info', 'Update publish quality, requested layers by SFU:', enabledLayers);
             const videoSender = this.transceiverRegistry[TrackType.VIDEO]?.sender;
             if (!videoSender) {
-                logger$3('warn', 'Update publish quality, no video sender found.');
+                this.logger('warn', 'Update publish quality, no video sender found.');
                 return;
             }
             const params = videoSender.getParameters();
             if (params.encodings.length === 0) {
-                logger$3('warn', 'Update publish quality, No suitable video encoding quality found');
+                this.logger('warn', 'Update publish quality, No suitable video encoding quality found');
                 return;
             }
             let changed = false;
@@ -8572,18 +9099,18 @@ class Publisher {
                     if (layer !== undefined) {
                         if (layer.scaleResolutionDownBy >= 1 &&
                             layer.scaleResolutionDownBy !== enc.scaleResolutionDownBy) {
-                            logger$3('debug', '[dynascale]: setting scaleResolutionDownBy from server', 'layer', layer.name, 'scale-resolution-down-by', layer.scaleResolutionDownBy);
+                            this.logger('debug', '[dynascale]: setting scaleResolutionDownBy from server', 'layer', layer.name, 'scale-resolution-down-by', layer.scaleResolutionDownBy);
                             enc.scaleResolutionDownBy = layer.scaleResolutionDownBy;
                             changed = true;
                         }
                         if (layer.maxBitrate > 0 && layer.maxBitrate !== enc.maxBitrate) {
-                            logger$3('debug', '[dynascale] setting max-bitrate from the server', 'layer', layer.name, 'max-bitrate', layer.maxBitrate);
+                            this.logger('debug', '[dynascale] setting max-bitrate from the server', 'layer', layer.name, 'max-bitrate', layer.maxBitrate);
                             enc.maxBitrate = layer.maxBitrate;
                             changed = true;
                         }
                         if (layer.maxFramerate > 0 &&
                             layer.maxFramerate !== enc.maxFramerate) {
-                            logger$3('debug', '[dynascale]: setting maxFramerate from server', 'layer', layer.name, 'max-framerate', layer.maxFramerate);
+                            this.logger('debug', '[dynascale]: setting maxFramerate from server', 'layer', layer.name, 'max-framerate', layer.maxFramerate);
                             enc.maxFramerate = layer.maxFramerate;
                             changed = true;
                         }
@@ -8593,10 +9120,10 @@ class Publisher {
             const activeLayers = params.encodings.filter((e) => e.active);
             if (changed) {
                 await videoSender.setParameters(params);
-                logger$3('info', `Update publish quality, enabled rids: `, activeLayers);
+                this.logger('info', `Update publish quality, enabled rids: `, activeLayers);
             }
             else {
-                logger$3('info', `Update publish quality, no change: `, activeLayers);
+                this.logger('info', `Update publish quality, no change: `, activeLayers);
             }
         };
         /**
@@ -8620,7 +9147,7 @@ class Publisher {
         this.onIceCandidate = (e) => {
             const { candidate } = e;
             if (!candidate) {
-                logger$3('debug', 'null ice candidate');
+                this.logger('debug', 'null ice candidate');
                 return;
             }
             this.sfuClient
@@ -8629,7 +9156,7 @@ class Publisher {
                 peerType: PeerType.PUBLISHER_UNSPECIFIED,
             })
                 .catch((err) => {
-                logger$3('warn', `ICETrickle failed`, err);
+                this.logger('warn', `ICETrickle failed`, err);
             });
         };
         /**
@@ -8640,38 +9167,23 @@ class Publisher {
         this.setSfuClient = (sfuClient) => {
             this.sfuClient = sfuClient;
         };
-        /**
-         * Performs a migration of this publisher instance to a new SFU.
-         *
-         * Initiates a new `iceRestart` offer/answer exchange with the new SFU.
-         *
-         * @param sfuClient the new SFU client to migrate to.
-         * @param connectionConfig the new connection configuration to use.
-         */
-        this.migrateTo = async (sfuClient, connectionConfig) => {
-            this.sfuClient = sfuClient;
-            this.pc.setConfiguration(connectionConfig);
-            this._connectionConfiguration = connectionConfig;
-            const shouldRestartIce = this.pc.iceConnectionState === 'connected';
-            if (shouldRestartIce) {
-                // negotiate only if there are tracks to publish
-                await this.negotiate({ iceRestart: true });
-            }
-        };
         /**
          * Restarts the ICE connection and renegotiates with the SFU.
          */
         this.restartIce = async () => {
-            logger$3('debug', 'Restarting ICE connection');
+            this.logger('debug', 'Restarting ICE connection');
             const signalingState = this.pc.signalingState;
             if (this.isIceRestarting || signalingState === 'have-local-offer') {
-                logger$3('debug', 'ICE restart is already in progress');
+                this.logger('debug', 'ICE restart is already in progress');
                 return;
             }
             await this.negotiate({ iceRestart: true });
         };
         this.onNegotiationNeeded = () => {
-            this.negotiate().catch((err) => logger$3('warn', `Negotiation failed.`, err));
+            this.negotiate().catch((err) => {
+                this.logger('warn', `Negotiation failed.`, err);
+                this.onUnrecoverableError?.();
+            });
         };
         /**
          * Initiates a new offer/answer exchange with the currently connected SFU.
@@ -8683,59 +9195,62 @@ class Publisher {
             const offer = await this.pc.createOffer(options);
             let sdp = this.mungeCodecs(offer.sdp);
             if (sdp && this.isPublishing(TrackType.SCREEN_SHARE_AUDIO)) {
-                const transceiver = this.transceiverRegistry[TrackType.SCREEN_SHARE_AUDIO];
-                if (transceiver && transceiver.sender.track) {
-                    const mid = transceiver.mid ??
-                        this.extractMid(sdp, transceiver.sender.track, TrackType.SCREEN_SHARE_AUDIO);
-                    sdp = enableHighQualityAudio(sdp, mid);
-                }
+                sdp = this.enableHighQualityAudio(sdp);
             }
             // set the munged SDP back to the offer
             offer.sdp = sdp;
-            const trackInfos = this.getCurrentTrackInfos(offer.sdp);
+            const trackInfos = this.getAnnouncedTracks(offer.sdp);
             if (trackInfos.length === 0) {
-                throw new Error(`Can't initiate negotiation without announcing any tracks`);
+                throw new Error(`Can't negotiate without announcing any tracks`);
             }
             await this.pc.setLocalDescription(offer);
             const { response } = await this.sfuClient.setPublisher({
                 sdp: offer.sdp || '',
                 tracks: trackInfos,
             });
+            const { sdp: remoteSdp, error } = response;
             try {
-                await this.pc.setRemoteDescription({
-                    type: 'answer',
-                    sdp: response.sdp,
-                });
+                await this.pc.setRemoteDescription({ type: 'answer', sdp: remoteSdp });
             }
             catch (e) {
-                logger$3('error', `setRemoteDescription error`, {
-                    sdp: response.sdp,
-                    error: e,
-                });
+                this.logger('error', `setRemoteDescription error`, remoteSdp, error, e);
+                throw e;
+            }
+            finally {
+                this.isIceRestarting = false;
             }
-            this.isIceRestarting = false;
             this.sfuClient.iceTrickleBuffer.publisherCandidates.subscribe(async (candidate) => {
                 try {
                     const iceCandidate = JSON.parse(candidate.iceCandidate);
                     await this.pc.addIceCandidate(iceCandidate);
                 }
                 catch (e) {
-                    logger$3('warn', `ICE candidate error`, [e, candidate]);
+                    this.logger('warn', `ICE candidate error`, e, candidate);
                 }
             });
         };
+        this.enableHighQualityAudio = (sdp) => {
+            const transceiver = this.transceiverRegistry[TrackType.SCREEN_SHARE_AUDIO];
+            if (!transceiver)
+                return sdp;
+            const mid = this.extractMid(transceiver, sdp, TrackType.SCREEN_SHARE_AUDIO);
+            return enableHighQualityAudio(sdp, mid);
+        };
         this.mungeCodecs = (sdp) => {
             if (sdp) {
                 sdp = toggleDtx(sdp, this.isDtxEnabled);
             }
             return sdp;
         };
-        this.extractMid = (sdp, track, trackType) => {
+        this.extractMid = (transceiver, sdp, trackType) => {
+            if (transceiver.mid)
+                return transceiver.mid;
             if (!sdp) {
-                logger$3('warn', 'No SDP found. Returning empty mid');
+                this.logger('warn', 'No SDP found. Returning empty mid');
                 return '';
             }
-            logger$3('debug', `No 'mid' found for track. Trying to find it from the Offer SDP`);
+            this.logger('debug', `No 'mid' found for track. Trying to find it from the Offer SDP`);
+            const track = transceiver.sender.track;
             const parsedSdp = SDP__namespace.parse(sdp);
             const media = parsedSdp.media.find((m) => {
                 return (m.type === track.kind &&
@@ -8743,17 +9258,23 @@ class Publisher {
                     (m.msid?.includes(track.id) ?? true));
             });
             if (typeof media?.mid === 'undefined') {
-                logger$3('debug', `No mid found in SDP for track type ${track.kind} and id ${track.id}. Attempting to find a heuristic mid`);
+                this.logger('debug', `No mid found in SDP for track type ${track.kind} and id ${track.id}. Attempting to find it heuristically`);
                 const heuristicMid = this.transceiverInitOrder.indexOf(trackType);
                 if (heuristicMid !== -1) {
                     return String(heuristicMid);
                 }
-                logger$3('debug', 'No heuristic mid found. Returning empty mid');
+                this.logger('debug', 'No heuristic mid found. Returning empty mid');
                 return '';
             }
             return String(media.mid);
         };
-        this.getCurrentTrackInfos = (sdp) => {
+        /**
+         * Returns a list of tracks that are currently being published.
+         *
+         * @internal
+         * @param sdp an optional SDP to extract the `mid` from.
+         */
+        this.getAnnouncedTracks = (sdp) => {
             sdp = sdp || this.pc.localDescription?.sdp;
             const { settings } = this.state;
             const targetResolution = settings?.video
@@ -8765,7 +9286,8 @@ class Publisher {
                 const trackType = Number(Object.keys(this.transceiverRegistry).find((key) => this.transceiverRegistry[key] === transceiver));
                 const track = transceiver.sender.track;
                 let optimalLayers;
-                if (track.readyState === 'live') {
+                const isTrackLive = track.readyState === 'live';
+                if (isTrackLive) {
                     const publishOpts = this.publishOptionsPerTrackType.get(trackType);
                     optimalLayers =
                         trackType === TrackType.VIDEO
@@ -8778,7 +9300,7 @@ class Publisher {
                 else {
                     // we report the last known optimal layers for ended tracks
                     optimalLayers = this.trackLayersCache[trackType] || [];
-                    logger$3('debug', `Track ${TrackType[trackType]} is ended. Announcing last known optimal layers`, optimalLayers);
+                    this.logger('debug', `Track ${TrackType[trackType]} is ended. Announcing last known optimal layers`, optimalLayers);
                 }
                 const layers = optimalLayers.map((optimalLayer) => ({
                     rid: optimalLayer.rid || '',
@@ -8800,10 +9322,11 @@ class Publisher {
                     trackId: track.id,
                     layers: layers,
                     trackType,
-                    mid: transceiver.mid ?? this.extractMid(sdp, track, trackType),
+                    mid: this.extractMid(transceiver, sdp, trackType),
                     stereo: isStereo,
                     dtx: isAudioTrack && this.isDtxEnabled,
                     red: isAudioTrack && this.isRedEnabled,
+                    muted: !isTrackLive,
                 };
             });
         };
@@ -8812,44 +9335,26 @@ class Publisher {
                 `${e.errorCode}: ${e.errorText}`;
             const iceState = this.pc.iceConnectionState;
             const logLevel = iceState === 'connected' || iceState === 'checking' ? 'debug' : 'warn';
-            logger$3(logLevel, `ICE Candidate error`, errorMessage);
+            this.logger(logLevel, `ICE Candidate error`, errorMessage);
         };
         this.onIceConnectionStateChange = () => {
             const state = this.pc.iceConnectionState;
-            logger$3('debug', `ICE Connection state changed to`, state);
-            const hasNetworkConnection = this.state.callingState !== exports.CallingState.OFFLINE;
-            if (state === 'failed') {
-                logger$3('debug', `Attempting to restart ICE`);
+            this.logger('debug', `ICE Connection state changed to`, state);
+            if (this.state.callingState === exports.CallingState.RECONNECTING)
+                return;
+            if (state === 'failed' || state === 'disconnected') {
+                this.logger('debug', `Attempting to restart ICE`);
                 this.restartIce().catch((e) => {
-                    logger$3('error', `ICE restart error`, e);
+                    this.logger('error', `ICE restart error`, e);
                     this.onUnrecoverableError?.();
                 });
             }
-            else if (state === 'disconnected' && hasNetworkConnection) {
-                // when in `disconnected` state, the browser may recover automatically,
-                // hence, we delay the ICE restart
-                logger$3('debug', `Scheduling ICE restart in ${this.iceRestartDelay} ms.`);
-                this.iceRestartTimeout = setTimeout(() => {
-                    // check if the state is still `disconnected` or `failed`
-                    // as the connection may have recovered (or failed) in the meantime
-                    if (this.pc.iceConnectionState === 'disconnected' ||
-                        this.pc.iceConnectionState === 'failed') {
-                        this.restartIce().catch((e) => {
-                            logger$3('error', `ICE restart error`, e);
-                            this.onUnrecoverableError?.();
-                        });
-                    }
-                    else {
-                        logger$3('debug', `Scheduled ICE restart: connection recovered, canceled.`);
-                    }
-                }, this.iceRestartDelay);
-            }
         };
         this.onIceGatheringStateChange = () => {
-            logger$3('debug', `ICE Gathering State`, this.pc.iceGatheringState);
+            this.logger('debug', `ICE Gathering State`, this.pc.iceGatheringState);
         };
         this.onSignalingStateChange = () => {
-            logger$3('debug', `Signaling state changed`, this.pc.signalingState);
+            this.logger('debug', `Signaling state changed`, this.pc.signalingState);
         };
         this.ridToVideoQuality = (rid) => {
             return rid === 'q'
@@ -8858,28 +9363,29 @@ class Publisher {
                     ? VideoQuality.MID
                     : VideoQuality.HIGH; // default to HIGH
         };
+        this.logger = getLogger(['Publisher', logTag]);
         this.pc = this.createPeerConnection(connectionConfig);
         this.sfuClient = sfuClient;
         this.state = state;
         this.isDtxEnabled = isDtxEnabled;
         this.isRedEnabled = isRedEnabled;
-        this.iceRestartDelay = iceRestartDelay;
         this.onUnrecoverableError = onUnrecoverableError;
         this.unsubscribeOnIceRestart = dispatcher.on('iceRestart', (iceRestart) => {
             if (iceRestart.peerType !== PeerType.PUBLISHER_UNSPECIFIED)
                 return;
             this.restartIce().catch((err) => {
-                logger$3('warn', `ICERestart failed`, err);
+                this.logger('warn', `ICERestart failed`, err);
                 this.onUnrecoverableError?.();
             });
         });
     }
 }
 
-const logger$2 = getLogger(['Subscriber']);
 /**
  * A wrapper around the `RTCPeerConnection` that handles the incoming
  * media streams from the SFU.
+ *
+ * @internal
  */
 class Subscriber {
     /**
@@ -8901,8 +9407,9 @@ class Subscriber {
      * @param connectionConfig the connection configuration to use.
      * @param iceRestartDelay the delay in milliseconds to wait before restarting ICE when connection goes to `disconnected` state.
      * @param onUnrecoverableError a callback to call when an unrecoverable error occurs.
+     * @param logTag a tag to use for logging.
      */
-    constructor({ sfuClient, dispatcher, state, connectionConfig, iceRestartDelay = 2500, onUnrecoverableError, }) {
+    constructor({ sfuClient, dispatcher, state, connectionConfig, onUnrecoverableError, logTag, }) {
         this.isIceRestarting = false;
         /**
          * Creates a new `RTCPeerConnection` instance with the given configuration.
@@ -8923,10 +9430,22 @@ class Subscriber {
          * Closes the `RTCPeerConnection` and unsubscribes from the dispatcher.
          */
         this.close = () => {
-            clearTimeout(this.iceRestartTimeout);
+            this.detachEventHandlers();
+            this.pc.close();
+        };
+        /**
+         * Detaches the event handlers from the `RTCPeerConnection`.
+         * This is useful when we want to replace the `RTCPeerConnection`
+         * instance with a new one (in case of migration).
+         */
+        this.detachEventHandlers = () => {
             this.unregisterOnSubscriberOffer();
             this.unregisterOnIceRestart();
-            this.pc.close();
+            this.pc.removeEventListener('icecandidate', this.onIceCandidate);
+            this.pc.removeEventListener('track', this.handleOnTrack);
+            this.pc.removeEventListener('icecandidateerror', this.onIceCandidateError);
+            this.pc.removeEventListener('iceconnectionstatechange', this.onIceConnectionStateChange);
+            this.pc.removeEventListener('icegatheringstatechange', this.onIceGatheringStateChange);
         };
         /**
          * Returns the result of the `RTCPeerConnection.getStats()` method
@@ -8944,76 +9463,17 @@ class Subscriber {
         this.setSfuClient = (sfuClient) => {
             this.sfuClient = sfuClient;
         };
-        /**
-         * Migrates the subscriber to a new SFU client.
-         *
-         * @param sfuClient the new SFU client to migrate to.
-         * @param connectionConfig the new connection configuration to use.
-         */
-        this.migrateTo = (sfuClient, connectionConfig) => {
-            this.setSfuClient(sfuClient);
-            // when migrating, we want to keep the previous subscriber open
-            // until the new one is connected
-            const previousPC = this.pc;
-            // we keep a record of previously available video tracks
-            // so that we can monitor when they become available on the new
-            // subscriber and close the previous one.
-            const trackIdsToMigrate = new Set();
-            previousPC.getReceivers().forEach((r) => {
-                if (r.track.kind === 'video') {
-                    trackIdsToMigrate.add(r.track.id);
-                }
-            });
-            // set up a new subscriber peer connection, configured to connect
-            // to the new SFU node
-            const pc = this.createPeerConnection(connectionConfig);
-            let migrationTimeoutId;
-            const cleanupMigration = () => {
-                previousPC.close();
-                clearTimeout(migrationTimeoutId);
-            };
-            // When migrating, we want to keep track of the video tracks
-            // that are migrating to the new subscriber.
-            // Once all of them are available, we can close the previous subscriber.
-            const handleTrackMigration = (e) => {
-                logger$2('debug', `[Migration]: Migrated track: ${e.track.id}, ${e.track.kind}`);
-                trackIdsToMigrate.delete(e.track.id);
-                if (trackIdsToMigrate.size === 0) {
-                    logger$2('debug', `[Migration]: Migration complete`);
-                    pc.removeEventListener('track', handleTrackMigration);
-                    cleanupMigration();
-                }
-            };
-            // When migrating, we want to keep track of the connection state
-            // of the new subscriber.
-            // Once it is connected, we give it a 2-second grace period to receive
-            // all the video tracks that are migrating from the previous subscriber.
-            // After this threshold, we abruptly close the previous subscriber.
-            const handleConnectionStateChange = () => {
-                if (pc.connectionState === 'connected') {
-                    migrationTimeoutId = setTimeout(() => {
-                        pc.removeEventListener('track', handleTrackMigration);
-                        cleanupMigration();
-                    }, 2000);
-                    pc.removeEventListener('connectionstatechange', handleConnectionStateChange);
-                }
-            };
-            pc.addEventListener('track', handleTrackMigration);
-            pc.addEventListener('connectionstatechange', handleConnectionStateChange);
-            // replace the PeerConnection instance
-            this.pc = pc;
-        };
         /**
          * Restarts the ICE connection and renegotiates with the SFU.
          */
         this.restartIce = async () => {
-            logger$2('debug', 'Restarting ICE connection');
+            this.logger('debug', 'Restarting ICE connection');
             if (this.pc.signalingState === 'have-remote-offer') {
-                logger$2('debug', 'ICE restart is already in progress');
+                this.logger('debug', 'ICE restart is already in progress');
                 return;
             }
             if (this.pc.connectionState === 'new') {
-                logger$2('debug', `ICE connection is not yet established, skipping restart.`);
+                this.logger('debug', `ICE connection is not yet established, skipping restart.`);
                 return;
             }
             const previousIsIceRestarting = this.isIceRestarting;
@@ -9032,36 +9492,42 @@ class Subscriber {
         this.handleOnTrack = (e) => {
             const [primaryStream] = e.streams;
             // example: `e3f6aaf8-b03d-4911-be36-83f47d37a76a:TRACK_TYPE_VIDEO`
-            const [trackId, trackType] = primaryStream.id.split(':');
+            const [trackId, rawTrackType] = primaryStream.id.split(':');
             const participantToUpdate = this.state.participants.find((p) => p.trackLookupPrefix === trackId);
-            logger$2('debug', `[onTrack]: Got remote ${trackType} track for userId: ${participantToUpdate?.userId}`, e.track.id, e.track);
-            if (!participantToUpdate) {
-                logger$2('warn', `[onTrack]: Received track for unknown participant: ${trackId}`, e);
-                return;
-            }
-            const trackDebugInfo = `${participantToUpdate.userId} ${trackType}:${trackId}`;
+            this.logger('debug', `[onTrack]: Got remote ${rawTrackType} track for userId: ${participantToUpdate?.userId}`, e.track.id, e.track);
+            const trackDebugInfo = `${participantToUpdate?.userId} ${rawTrackType}:${trackId}`;
             e.track.addEventListener('mute', () => {
-                logger$2('info', `[onTrack]: Track muted: ${trackDebugInfo}`);
+                this.logger('info', `[onTrack]: Track muted: ${trackDebugInfo}`);
             });
             e.track.addEventListener('unmute', () => {
-                logger$2('info', `[onTrack]: Track unmuted: ${trackDebugInfo}`);
+                this.logger('info', `[onTrack]: Track unmuted: ${trackDebugInfo}`);
             });
             e.track.addEventListener('ended', () => {
-                logger$2('info', `[onTrack]: Track ended: ${trackDebugInfo}`);
+                this.logger('info', `[onTrack]: Track ended: ${trackDebugInfo}`);
+                this.state.removeOrphanedTrack(primaryStream.id);
             });
-            const streamKindProp = {
-                TRACK_TYPE_AUDIO: 'audioStream',
-                TRACK_TYPE_VIDEO: 'videoStream',
-                TRACK_TYPE_SCREEN_SHARE: 'screenShareStream',
-                TRACK_TYPE_SCREEN_SHARE_AUDIO: 'screenShareAudioStream',
-            }[trackType];
+            const trackType = toTrackType(rawTrackType);
+            if (!trackType) {
+                return this.logger('error', `Unknown track type: ${rawTrackType}`);
+            }
+            if (!participantToUpdate) {
+                this.logger('warn', `[onTrack]: Received track for unknown participant: ${trackId}`, e);
+                this.state.registerOrphanedTrack({
+                    id: primaryStream.id,
+                    trackLookupPrefix: trackId,
+                    track: primaryStream,
+                    trackType,
+                });
+                return;
+            }
+            const streamKindProp = trackTypeToParticipantStreamKey(trackType);
             if (!streamKindProp) {
-                logger$2('error', `Unknown track type: ${trackType}`);
+                this.logger('error', `Unknown track type: ${rawTrackType}`);
                 return;
             }
             const previousStream = participantToUpdate[streamKindProp];
             if (previousStream) {
-                logger$2('info', `[onTrack]: Cleaning up previous remote ${e.track.kind} tracks for userId: ${participantToUpdate.userId}`);
+                this.logger('info', `[onTrack]: Cleaning up previous remote ${e.track.kind} tracks for userId: ${participantToUpdate.userId}`);
                 previousStream.getTracks().forEach((t) => {
                     t.stop();
                     previousStream.removeTrack(t);
@@ -9074,7 +9540,7 @@ class Subscriber {
         this.onIceCandidate = (e) => {
             const { candidate } = e;
             if (!candidate) {
-                logger$2('debug', 'null ice candidate');
+                this.logger('debug', 'null ice candidate');
                 return;
             }
             this.sfuClient
@@ -9083,11 +9549,11 @@ class Subscriber {
                 peerType: PeerType.SUBSCRIBER,
             })
                 .catch((err) => {
-                logger$2('warn', `ICETrickle failed`, err);
+                this.logger('warn', `ICETrickle failed`, err);
             });
         };
         this.negotiate = async (subscriberOffer) => {
-            logger$2('info', `Received subscriberOffer`, subscriberOffer);
+            this.logger('info', `Received subscriberOffer`, subscriberOffer);
             await this.pc.setRemoteDescription({
                 type: 'offer',
                 sdp: subscriberOffer.sdp,
@@ -9098,7 +9564,7 @@ class Subscriber {
                     await this.pc.addIceCandidate(iceCandidate);
                 }
                 catch (e) {
-                    logger$2('warn', `ICE candidate error`, [e, candidate]);
+                    this.logger('warn', `ICE candidate error`, [e, candidate]);
                 }
             });
             const answer = await this.pc.createAnswer();
@@ -9111,63 +9577,51 @@ class Subscriber {
         };
         this.onIceConnectionStateChange = () => {
             const state = this.pc.iceConnectionState;
-            logger$2('debug', `ICE connection state changed`, state);
+            this.logger('debug', `ICE connection state changed`, state);
+            if (this.state.callingState === exports.CallingState.RECONNECTING)
+                return;
             // do nothing when ICE is restarting
             if (this.isIceRestarting)
                 return;
-            const hasNetworkConnection = this.state.callingState !== exports.CallingState.OFFLINE;
-            if (state === 'failed') {
-                logger$2('debug', `Attempting to restart ICE`);
+            if (state === 'failed' || state === 'disconnected') {
+                this.logger('debug', `Attempting to restart ICE`);
                 this.restartIce().catch((e) => {
-                    logger$2('error', `ICE restart failed`, e);
+                    this.logger('error', `ICE restart failed`, e);
                     this.onUnrecoverableError?.();
                 });
             }
-            else if (state === 'disconnected' && hasNetworkConnection) {
-                // when in `disconnected` state, the browser may recover automatically,
-                // hence, we delay the ICE restart
-                logger$2('debug', `Scheduling ICE restart in ${this.iceRestartDelay} ms.`);
-                this.iceRestartTimeout = setTimeout(() => {
-                    // check if the state is still `disconnected` or `failed`
-                    // as the connection may have recovered (or failed) in the meantime
-                    if (this.pc.iceConnectionState === 'disconnected' ||
-                        this.pc.iceConnectionState === 'failed') {
-                        this.restartIce().catch((e) => {
-                            logger$2('error', `ICE restart failed`, e);
-                            this.onUnrecoverableError?.();
-                        });
-                    }
-                    else {
-                        logger$2('debug', `Scheduled ICE restart: connection recovered, canceled.`);
-                    }
-                }, this.iceRestartDelay);
-            }
         };
         this.onIceGatheringStateChange = () => {
-            logger$2('debug', `ICE gathering state changed`, this.pc.iceGatheringState);
+            this.logger('debug', `ICE gathering state changed`, this.pc.iceGatheringState);
         };
         this.onIceCandidateError = (e) => {
             const errorMessage = e instanceof RTCPeerConnectionIceErrorEvent &&
                 `${e.errorCode}: ${e.errorText}`;
             const iceState = this.pc.iceConnectionState;
             const logLevel = iceState === 'connected' || iceState === 'checking' ? 'debug' : 'warn';
-            logger$2(logLevel, `ICE Candidate error`, errorMessage);
+            this.logger(logLevel, `ICE Candidate error`, errorMessage);
         };
+        this.logger = getLogger(['Subscriber', logTag]);
         this.sfuClient = sfuClient;
         this.state = state;
-        this.iceRestartDelay = iceRestartDelay;
         this.onUnrecoverableError = onUnrecoverableError;
         this.pc = this.createPeerConnection(connectionConfig);
+        const subscriberOfferConcurrencyTag = Symbol('subscriberOffer');
         this.unregisterOnSubscriberOffer = dispatcher.on('subscriberOffer', (subscriberOffer) => {
-            this.negotiate(subscriberOffer).catch((err) => {
-                logger$2('warn', `Negotiation failed.`, err);
+            withoutConcurrency(subscriberOfferConcurrencyTag, () => {
+                return this.negotiate(subscriberOffer);
+            }).catch((err) => {
+                this.logger('warn', `Negotiation failed.`, err);
             });
         });
+        const iceRestartConcurrencyTag = Symbol('iceRestart');
         this.unregisterOnIceRestart = dispatcher.on('iceRestart', (iceRestart) => {
-            if (iceRestart.peerType !== PeerType.SUBSCRIBER)
-                return;
-            this.restartIce().catch((err) => {
-                logger$2('warn', `ICERestart failed`, err);
+            withoutConcurrency(iceRestartConcurrencyTag, async () => {
+                if (iceRestart.peerType !== PeerType.SUBSCRIBER)
+                    return;
+                await this.restartIce();
+            }).catch((err) => {
+                this.logger('warn', `ICERestart failed`, err);
                 this.onUnrecoverableError?.();
             });
         });
@@ -9175,8 +9629,8 @@ class Subscriber {
 }
 
 const createWebSocketSignalChannel = (opts) => {
-    const logger = getLogger(['sfu-client']);
-    const { endpoint, onMessage } = opts;
+    const { endpoint, onMessage, logTag } = opts;
+    const logger = getLogger(['sfu-client-ws', logTag]);
     const ws = new WebSocket(endpoint);
     ws.binaryType = 'arraybuffer'; // do we need this?
     ws.addEventListener('error', (e) => {
@@ -9194,140 +9648,45 @@ const createWebSocketSignalChannel = (opts) => {
                 ? SfuEvent.fromBinary(new Uint8Array(e.data))
                 : SfuEvent.fromJsonString(e.data.toString());
             onMessage(message);
-        }
-        catch (err) {
-            logger('error', 'Failed to decode a message. Check whether the Proto models match.', { event: e, error: err });
-        }
-    });
-    return ws;
-};
-
-const sleep = (m) => new Promise((r) => setTimeout(r, m));
-function isFunction(value) {
-    return (value &&
-        (Object.prototype.toString.call(value) === '[object Function]' ||
-            'function' === typeof value ||
-            value instanceof Function));
-}
-/**
- * A map of known error codes.
- */
-const KnownCodes = {
-    TOKEN_EXPIRED: 40,
-    WS_CLOSED_SUCCESS: 1000,
-    WS_CLOSED_ABRUPTLY: 1006,
-    WS_POLICY_VIOLATION: 1008,
-};
-/**
- * retryInterval - A retry interval which increases acc to number of failures
- *
- * @return {number} Duration to wait in milliseconds
- */
-function retryInterval(numberOfFailures) {
-    // try to reconnect in 0.25-5 seconds (random to spread out the load from failures)
-    const max = Math.min(500 + numberOfFailures * 2000, 5000);
-    const min = Math.min(Math.max(250, (numberOfFailures - 1) * 2000), 5000);
-    return Math.floor(Math.random() * (max - min) + min);
-}
-function randomId() {
-    return generateUUIDv4();
-}
-function hex(bytes) {
-    let s = '';
-    for (let i = 0; i < bytes.length; i++) {
-        s += bytes[i].toString(16).padStart(2, '0');
-    }
-    return s;
-}
-// https://tools.ietf.org/html/rfc4122
-function generateUUIDv4() {
-    const bytes = getRandomBytes(16);
-    bytes[6] = (bytes[6] & 0x0f) | 0x40; // version
-    bytes[8] = (bytes[8] & 0xbf) | 0x80; // variant
-    return (hex(bytes.subarray(0, 4)) +
-        '-' +
-        hex(bytes.subarray(4, 6)) +
-        '-' +
-        hex(bytes.subarray(6, 8)) +
-        '-' +
-        hex(bytes.subarray(8, 10)) +
-        '-' +
-        hex(bytes.subarray(10, 16)));
-}
-function getRandomValuesWithMathRandom(bytes) {
-    const max = Math.pow(2, (8 * bytes.byteLength) / bytes.length);
-    for (let i = 0; i < bytes.length; i++) {
-        bytes[i] = Math.random() * max;
-    }
-}
-const getRandomValues = (() => {
-    if (typeof crypto !== 'undefined' &&
-        typeof crypto?.getRandomValues !== 'undefined') {
-        return crypto.getRandomValues.bind(crypto);
-    }
-    else if (typeof msCrypto !== 'undefined') {
-        return msCrypto.getRandomValues.bind(msCrypto);
-    }
-    else {
-        return getRandomValuesWithMathRandom;
-    }
-})();
-function getRandomBytes(length) {
-    const bytes = new Uint8Array(length);
-    getRandomValues(bytes);
-    return bytes;
-}
-function convertErrorToJson(err) {
-    const jsonObj = {};
-    if (!err)
-        return jsonObj;
-    try {
-        Object.getOwnPropertyNames(err).forEach((key) => {
-            jsonObj[key] = Object.getOwnPropertyDescriptor(err, key);
-        });
-    }
-    catch (_) {
-        return {
-            error: 'failed to serialize the error',
-        };
-    }
-    return jsonObj;
-}
-/**
- * isOnline safely return the navigator.online value for browser env
- * if navigator is not in global object, it always return true
- */
-function isOnline(logger) {
-    const nav = typeof navigator !== 'undefined'
-        ? navigator
-        : typeof window !== 'undefined' && window.navigator
-            ? window.navigator
-            : undefined;
-    if (!nav) {
-        logger('warn', 'isOnline failed to access window.navigator and assume browser is online');
-        return true;
-    }
-    // RN navigator has undefined for onLine
-    if (typeof nav.onLine !== 'boolean') {
-        return true;
-    }
-    return nav.onLine;
-}
-/**
- * listenForConnectionChanges - Adds an event listener fired on browser going online or offline
- */
-function addConnectionEventListeners(cb) {
-    if (typeof window !== 'undefined' && window.addEventListener) {
-        window.addEventListener('offline', cb);
-        window.addEventListener('online', cb);
-    }
-}
-function removeConnectionEventListeners(cb) {
-    if (typeof window !== 'undefined' && window.removeEventListener) {
-        window.removeEventListener('offline', cb);
-        window.removeEventListener('online', cb);
-    }
-}
+        }
+        catch (err) {
+            logger('error', 'Failed to decode a message. Check whether the Proto models match.', { event: e, error: err });
+        }
+    });
+    return ws;
+};
+
+/**
+ * Creates a new promise with resolvers.
+ *
+ * Based on:
+ * - https://github.com/tc39/proposal-promise-with-resolvers/blob/main/polyfills.js
+ */
+const promiseWithResolvers = () => {
+    let resolve;
+    let reject;
+    const promise = new Promise((_resolve, _reject) => {
+        resolve = _resolve;
+        reject = _reject;
+    });
+    let isResolved = false;
+    let isRejected = false;
+    const resolver = (value) => {
+        isResolved = true;
+        resolve(value);
+    };
+    const rejecter = (reason) => {
+        isRejected = true;
+        reject(reason);
+    };
+    return {
+        promise,
+        resolve: resolver,
+        reject: rejecter,
+        isResolved,
+        isRejected,
+    };
+};
 
 /**
  * The client used for exchanging information with the SFU.
@@ -9335,133 +9694,224 @@ function removeConnectionEventListeners(cb) {
 class StreamSfuClient {
     /**
      * Constructs a new SFU client.
-     *
-     * @param dispatcher the event dispatcher to use.
-     * @param sfuServer the SFU server to connect to.
-     * @param token the JWT token to use for authentication.
-     * @param sessionId the `sessionId` of the currently connected participant.
      */
-    constructor({ dispatcher, sfuServer, token, sessionId, }) {
+    constructor({ dispatcher, credentials, sessionId, logTag, joinResponseTimeout = 5000, onSignalClose, }) {
         /**
          * A buffer for ICE Candidates that are received before
-         * the PeerConnections are ready to handle them.
+         * the Publisher and Subscriber Peer Connections are ready to handle them.
          */
         this.iceTrickleBuffer = new IceTrickleBuffer();
         /**
-         * A flag indicating whether the client is currently migrating away
-         * from this SFU.
-         */
-        this.isMigratingAway = false;
-        /**
-         * A flag indicating that the client connection is broken for the current
-         * client and that a fast-reconnect with a new client should be attempted.
+         * Flag to indicate if the client is in the process of leaving the call.
+         * This is set to `true` when the user initiates the leave process.
          */
-        this.isFastReconnecting = false;
+        this.isLeaving = false;
         this.pingIntervalInMs = 10 * 1000;
         this.unhealthyTimeoutInMs = this.pingIntervalInMs + 5 * 1000;
-        this.close = (code, reason) => {
-            this.logger('debug', `Closing SFU WS connection: ${code} - ${reason}`);
-            if (this.signalWs.readyState !== this.signalWs.CLOSED) {
+        this.restoreWebSocketConcurrencyTag = Symbol('recoverWebSocket');
+        /**
+         * Promise that resolves when the JoinResponse is received.
+         * Rejects after a certain threshold if the response is not received.
+         */
+        this.joinResponseTask = promiseWithResolvers();
+        /**
+         * A controller to abort the current requests.
+         */
+        this.abortController = new AbortController();
+        this.createWebSocket = () => {
+            this.signalWs = createWebSocketSignalChannel({
+                logTag: this.logTag,
+                endpoint: `${this.credentials.server.ws_endpoint}?tag=${this.logTag}`,
+                onMessage: (message) => {
+                    this.lastMessageTimestamp = new Date();
+                    this.scheduleConnectionCheck();
+                    this.dispatcher.dispatch(message, this.logTag);
+                },
+            });
+            this.signalWs.addEventListener('close', this.handleWebSocketClose);
+            this.signalWs.addEventListener('error', this.restoreWebSocket);
+            this.signalReady = new Promise((resolve) => {
+                const onOpen = () => {
+                    this.signalWs.removeEventListener('open', onOpen);
+                    resolve(this.signalWs);
+                };
+                this.signalWs.addEventListener('open', onOpen);
+            });
+        };
+        this.cleanUpWebSocket = () => {
+            this.signalWs.removeEventListener('error', this.restoreWebSocket);
+            this.signalWs.removeEventListener('close', this.handleWebSocketClose);
+        };
+        this.restoreWebSocket = () => {
+            withoutConcurrency(this.restoreWebSocketConcurrencyTag, async () => {
+                this.logger('debug', 'Restoring SFU WS connection');
+                this.cleanUpWebSocket();
+                await sleep(500);
+                this.createWebSocket();
+            }).catch((err) => this.logger('debug', `Can't restore WS connection`, err));
+        };
+        this.handleWebSocketClose = (e) => {
+            this.signalWs.removeEventListener('close', this.handleWebSocketClose);
+            clearInterval(this.keepAliveInterval);
+            clearTimeout(this.connectionCheckTimeout);
+            if (this.onSignalClose) {
+                this.onSignalClose(e);
+            }
+        };
+        this.close = (code = StreamSfuClient.NORMAL_CLOSURE, reason) => {
+            if (this.signalWs.readyState === WebSocket.OPEN) {
+                this.logger('debug', `Closing SFU WS connection: ${code} - ${reason}`);
                 this.signalWs.close(code, `js-client: ${reason}`);
+                this.cleanUpWebSocket();
             }
+            this.dispose();
+        };
+        this.dispose = () => {
+            this.logger('debug', 'Disposing SFU client');
             this.unsubscribeIceTrickle();
             clearInterval(this.keepAliveInterval);
             clearTimeout(this.connectionCheckTimeout);
+            clearTimeout(this.migrateAwayTimeout);
+            this.abortController.abort();
+            this.migrationTask?.resolve();
+        };
+        this.leaveAndClose = async (reason) => {
+            await this.joinResponseTask.promise;
+            try {
+                this.isLeaving = true;
+                await this.notifyLeave(reason);
+            }
+            catch (err) {
+                this.logger('debug', 'Error notifying SFU about leaving call', err);
+            }
+            this.close(StreamSfuClient.NORMAL_CLOSURE, reason.substring(0, 115));
         };
-        this.updateSubscriptions = async (subscriptions) => {
-            return retryable(() => this.rpc.updateSubscriptions({
-                sessionId: this.sessionId,
-                tracks: subscriptions,
-            }), this.logger, 'debug');
+        this.updateSubscriptions = async (tracks) => {
+            await this.joinResponseTask.promise;
+            return retryable(() => this.rpc.updateSubscriptions({ sessionId: this.sessionId, tracks }), this.abortController.signal);
         };
         this.setPublisher = async (data) => {
-            return retryable(() => this.rpc.setPublisher({
-                ...data,
-                sessionId: this.sessionId,
-            }), this.logger);
+            await this.joinResponseTask.promise;
+            return retryable(() => this.rpc.setPublisher({ ...data, sessionId: this.sessionId }), this.abortController.signal);
         };
         this.sendAnswer = async (data) => {
-            return retryable(() => this.rpc.sendAnswer({
-                ...data,
-                sessionId: this.sessionId,
-            }), this.logger);
+            await this.joinResponseTask.promise;
+            return retryable(() => this.rpc.sendAnswer({ ...data, sessionId: this.sessionId }), this.abortController.signal);
         };
         this.iceTrickle = async (data) => {
-            return retryable(() => this.rpc.iceTrickle({
-                ...data,
-                sessionId: this.sessionId,
-            }), this.logger);
+            await this.joinResponseTask.promise;
+            return retryable(() => this.rpc.iceTrickle({ ...data, sessionId: this.sessionId }), this.abortController.signal);
         };
         this.iceRestart = async (data) => {
-            return retryable(() => this.rpc.iceRestart({
-                ...data,
-                sessionId: this.sessionId,
-            }), this.logger);
+            await this.joinResponseTask.promise;
+            return retryable(() => this.rpc.iceRestart({ ...data, sessionId: this.sessionId }), this.abortController.signal);
         };
         this.updateMuteState = async (trackType, muted) => {
-            return this.updateMuteStates({
-                muteStates: [
-                    {
-                        trackType,
-                        muted,
-                    },
-                ],
-            });
+            await this.joinResponseTask.promise;
+            return this.updateMuteStates({ muteStates: [{ trackType, muted }] });
         };
         this.updateMuteStates = async (data) => {
-            return retryable(() => this.rpc.updateMuteStates({
-                ...data,
-                sessionId: this.sessionId,
-            }), this.logger);
+            await this.joinResponseTask.promise;
+            return retryable(() => this.rpc.updateMuteStates({ ...data, sessionId: this.sessionId }), this.abortController.signal);
         };
         this.sendStats = async (stats) => {
-            return retryable(() => this.rpc.sendStats({
-                ...stats,
-                sessionId: this.sessionId,
-            }), this.logger, 'debug');
+            await this.joinResponseTask.promise;
+            return retryable(() => this.rpc.sendStats({ ...stats, sessionId: this.sessionId }), this.abortController.signal);
         };
         this.startNoiseCancellation = async () => {
-            return retryable(() => this.rpc.startNoiseCancellation({
-                sessionId: this.sessionId,
-            }), this.logger);
+            await this.joinResponseTask.promise;
+            return retryable(() => this.rpc.startNoiseCancellation({ sessionId: this.sessionId }), this.abortController.signal);
         };
         this.stopNoiseCancellation = async () => {
-            return retryable(() => this.rpc.stopNoiseCancellation({
-                sessionId: this.sessionId,
-            }), this.logger);
+            await this.joinResponseTask.promise;
+            return retryable(() => this.rpc.stopNoiseCancellation({ sessionId: this.sessionId }), this.abortController.signal);
+        };
+        this.enterMigration = async (opts = {}) => {
+            this.isLeaving = true;
+            const { timeout = 7 * 1000 } = opts;
+            this.migrationTask?.reject(new Error('Cancelled previous migration'));
+            const task = (this.migrationTask = promiseWithResolvers());
+            const unsubscribe = this.dispatcher.on('participantMigrationComplete', () => {
+                unsubscribe();
+                clearTimeout(this.migrateAwayTimeout);
+                task.resolve();
+            });
+            this.migrateAwayTimeout = setTimeout(() => {
+                unsubscribe();
+                task.reject(new Error(`Migration (${this.logTag}) failed to complete in ${timeout}ms`));
+            }, timeout);
+            return task.promise;
         };
         this.join = async (data) => {
-            const joinRequest = JoinRequest.create({
-                ...data,
-                sessionId: this.sessionId,
-                token: this.token,
+            // wait for the signal web socket to be ready before sending "joinRequest"
+            await this.signalReady;
+            if (this.joinResponseTask.isResolved || this.joinResponseTask.isRejected) {
+                // we need to lock the RPC requests until we receive a JoinResponse.
+                // that's why we have this primitive lock mechanism.
+                // the client starts with already initialized joinResponseTask,
+                // and this code creates a new one for the next join request.
+                this.joinResponseTask = promiseWithResolvers();
+            }
+            // capture a reference to the current joinResponseTask as it might
+            // be replaced with a new one in case a second join request is made
+            const current = this.joinResponseTask;
+            let timeoutId;
+            const unsubscribe = this.dispatcher.on('joinResponse', (joinResponse) => {
+                this.logger('debug', 'Received joinResponse', joinResponse);
+                clearTimeout(timeoutId);
+                unsubscribe();
+                this.keepAlive();
+                current.resolve(joinResponse);
             });
-            return this.send(SfuRequest.create({
+            timeoutId = setTimeout(() => {
+                unsubscribe();
+                current.reject(new Error('Waiting for "joinResponse" has timed out'));
+            }, this.joinResponseTimeout);
+            await this.send(SfuRequest.create({
                 requestPayload: {
                     oneofKind: 'joinRequest',
-                    joinRequest,
+                    joinRequest: JoinRequest.create({
+                        ...data,
+                        sessionId: this.sessionId,
+                        token: this.credentials.token,
+                    }),
+                },
+            }));
+            return current.promise;
+        };
+        this.ping = async () => {
+            return this.send(SfuRequest.create({
+                requestPayload: {
+                    oneofKind: 'healthCheckRequest',
+                    healthCheckRequest: {},
+                },
+            }));
+        };
+        this.notifyLeave = async (reason) => {
+            return this.send(SfuRequest.create({
+                requestPayload: {
+                    oneofKind: 'leaveCallRequest',
+                    leaveCallRequest: {
+                        sessionId: this.sessionId,
+                        reason,
+                    },
                 },
             }));
         };
         this.send = async (message) => {
-            return this.signalReady.then((signal) => {
-                if (signal.readyState !== signal.OPEN)
-                    return;
-                this.logger('debug', `Sending message to: ${this.edgeName}`, SfuRequest.toJson(message));
-                signal.send(SfuRequest.toBinary(message));
-            });
+            await this.signalReady; // wait for the signal ws to be open
+            const msgJson = SfuRequest.toJson(message);
+            if (this.signalWs.readyState !== WebSocket.OPEN) {
+                this.logger('debug', 'Signal WS is not open. Skipping message', msgJson);
+                return;
+            }
+            this.logger('debug', `Sending message to: ${this.edgeName}`, msgJson);
+            this.signalWs.send(SfuRequest.toBinary(message));
         };
         this.keepAlive = () => {
             clearInterval(this.keepAliveInterval);
             this.keepAliveInterval = setInterval(() => {
-                this.logger('trace', 'Sending healthCheckRequest to SFU');
-                const message = SfuRequest.create({
-                    requestPayload: {
-                        oneofKind: 'healthCheckRequest',
-                        healthCheckRequest: {},
-                    },
-                });
-                this.send(message).catch((e) => {
+                this.ping().catch((e) => {
                     this.logger('error', 'Error sending healthCheckRequest to SFU', e);
                 });
             }, this.pingIntervalInMs);
@@ -9477,53 +9927,37 @@ class StreamSfuClient {
                 }
             }, this.unhealthyTimeoutInMs);
         };
+        this.dispatcher = dispatcher;
         this.sessionId = sessionId || generateUUIDv4();
-        this.sfuServer = sfuServer;
-        this.edgeName = sfuServer.edge_name;
-        this.token = token;
-        this.logger = getLogger(['sfu-client']);
-        const logInterceptor = {
-            interceptUnary: (next, method, input, options) => {
-                this.logger('trace', `Calling SFU RPC method ${method.name}`, {
-                    input,
-                    options,
-                });
-                return next(method, input, options);
-            },
-        };
+        this.onSignalClose = onSignalClose;
+        this.credentials = credentials;
+        const { server, token } = credentials;
+        this.edgeName = server.edge_name;
+        this.joinResponseTimeout = joinResponseTimeout;
+        this.logTag = logTag;
+        this.logger = getLogger(['sfu-client', logTag]);
         this.rpc = createSignalClient({
-            baseUrl: sfuServer.url,
+            baseUrl: server.url,
             interceptors: [
                 withHeaders({
                     Authorization: `Bearer ${token}`,
                 }),
-                logInterceptor,
-            ],
+                getLogLevel() === 'trace' && withRequestLogger(this.logger, 'trace'),
+            ].filter((v) => !!v),
         });
         // Special handling for the ICETrickle kind of events.
-        // These events might be triggered by the SFU before the initial RTC
-        // connection is established. In that case, those events (ICE candidates)
-        // need to be buffered and later added to the appropriate PeerConnection
+        // The SFU might trigger these events before the initial RTC
+        // connection is established or "JoinResponse" received.
+        // In that case, those events (ICE candidates) need to be buffered
+        // and later added to the appropriate PeerConnection
         // once the remoteDescription is known and set.
         this.unsubscribeIceTrickle = dispatcher.on('iceTrickle', (iceTrickle) => {
             this.iceTrickleBuffer.push(iceTrickle);
         });
-        this.signalWs = createWebSocketSignalChannel({
-            endpoint: sfuServer.ws_endpoint,
-            onMessage: (message) => {
-                this.lastMessageTimestamp = new Date();
-                this.scheduleConnectionCheck();
-                dispatcher.dispatch(message);
-            },
-        });
-        this.signalReady = new Promise((resolve) => {
-            const onOpen = () => {
-                this.signalWs.removeEventListener('open', onOpen);
-                this.keepAlive();
-                resolve(this.signalWs);
-            };
-            this.signalWs.addEventListener('open', onOpen);
-        });
+        this.createWebSocket();
+    }
+    get isHealthy() {
+        return this.signalWs.readyState === WebSocket.OPEN;
     }
 }
 /**
@@ -9536,45 +9970,15 @@ StreamSfuClient.NORMAL_CLOSURE = 1000;
  * a certain amount of time (`connectionCheckTimeout`).
  */
 StreamSfuClient.ERROR_CONNECTION_UNHEALTHY = 4001;
-/**
- * The error code used when the SFU connection is broken.
- * Usually, this means that the WS connection has been closed unexpectedly.
- * This error code is used to announce a fast-reconnect.
- */
-StreamSfuClient.ERROR_CONNECTION_BROKEN = 4002; // used in fast-reconnects
-const MAX_RETRIES = 5;
-/**
- * Creates a closure which wraps the given RPC call and retries invoking
- * the RPC until it succeeds or the maximum number of retries is reached.
- *
- * Between each retry, there would be a random delay in order to avoid
- * request bursts towards the SFU.
- *
- * @param rpc the closure around the RPC call to execute.
- * @param logger a logger instance to use.
- * @param <I> the type of the request object.
- * @param <O> the type of the response object.
- */
-const retryable = async (rpc, logger, level = 'error') => {
-    let retryAttempt = 0;
-    let rpcCallResult;
-    do {
-        // don't delay the first invocation
-        if (retryAttempt > 0) {
-            await sleep(retryInterval(retryAttempt));
-        }
-        rpcCallResult = await rpc();
-        // if the RPC call failed, log the error and retry
-        if (rpcCallResult.response.error) {
-            logger(level, `SFU RPC Error (${rpcCallResult.method.name}):`, rpcCallResult.response.error);
-        }
-        retryAttempt++;
-    } while (rpcCallResult.response.error?.shouldRetry &&
-        retryAttempt < MAX_RETRIES);
-    if (rpcCallResult.response.error) {
-        throw rpcCallResult.response.error;
-    }
-    return rpcCallResult;
+
+const toRtcConfiguration = (config) => {
+    return {
+        iceServers: config.map((ice) => ({
+            urls: ice.urls,
+            username: ice.username,
+            credential: ice.password,
+        })),
+    };
 };
 
 /**
@@ -9729,9 +10133,10 @@ const watchSfuErrorReports = (dispatcher) => {
     return dispatcher.on('error', (e) => {
         if (!e.error)
             return;
-        const { error } = e;
+        const { error, reconnectStrategy } = e;
         logger$1('error', 'SFU reported error', {
             code: ErrorCode[error.code],
+            reconnectStrategy: WebsocketReconnectStrategy[reconnectStrategy],
             message: error.message,
             shouldRetry: error.shouldRetry,
         });
@@ -9747,6 +10152,17 @@ const watchPinsUpdated = (state) => {
         state.setServerSidePins(pins);
     };
 };
+/**
+ * Watches for `callEnded` events.
+ */
+const watchSfuCallEnded = (call) => {
+    return call.on('callEnded', (e) => {
+        const reason = CallEndedReason[e.reason];
+        call.leave({ reason }).catch((err) => {
+            logger$1('error', 'Failed to leave call after call ended by the SFU', err);
+        });
+    });
+};
 
 /**
  * An event handler that handles soft mutes.
@@ -9768,12 +10184,13 @@ const handleRemoteSoftMute = (call) => {
                 else if (type === TrackType.AUDIO) {
                     await call.microphone.disable();
                 }
+                else if (type === TrackType.SCREEN_SHARE ||
+                    type === TrackType.SCREEN_SHARE_AUDIO) {
+                    await call.screenShare.disable();
+                }
                 else {
                     logger('warn', 'Unsupported track type to soft mute', TrackType[type]);
                 }
-                if (call.publisher?.isPublishing(type)) {
-                    await call.stopPublish(type);
-                }
             }
             catch (error) {
                 logger('error', 'Failed to stop publishing', error);
@@ -9794,11 +10211,12 @@ const watchParticipantJoined = (state) => {
         // potential duplicate events from the SFU.
         //
         // Although the SFU should not send duplicate events, we have seen
-        // some race conditions in the past during the `join-flow` where
-        // the SFU would send participant info as part of the `join`
+        // some race conditions in the past during the `join-flow`.
+        // The SFU would send participant info as part of the `join`
         // response and then follow up with a `participantJoined` event for
         // already announced participants.
-        state.updateOrAddParticipant(participant.sessionId, Object.assign(participant, {
+        const orphanedTracks = reconcileOrphanedTracks(state, participant);
+        state.updateOrAddParticipant(participant.sessionId, Object.assign(participant, orphanedTracks, {
             viewportVisibilityState: {
                 videoTrack: exports.VisibilityState.UNKNOWN,
                 screenShareTrack: exports.VisibilityState.UNKNOWN,
@@ -9834,12 +10252,14 @@ const watchParticipantUpdated = (state) => {
  */
 const watchTrackPublished = (state) => {
     return function onTrackPublished(e) {
-        const { type, sessionId, participant } = e;
+        const { type, sessionId } = e;
         // An optimization for large calls.
         // After a certain threshold, the SFU would stop emitting `participantJoined`
         // events, and instead, it would only provide the participant's information
         // once they start publishing a track.
-        if (participant) {
+        if (e.participant) {
+            const orphanedTracks = reconcileOrphanedTracks(state, e.participant);
+            const participant = Object.assign(e.participant, orphanedTracks);
             state.updateOrAddParticipant(sessionId, participant);
         }
         else {
@@ -9855,9 +10275,11 @@ const watchTrackPublished = (state) => {
  */
 const watchTrackUnpublished = (state) => {
     return function onTrackUnpublished(e) {
-        const { type, sessionId, participant } = e;
+        const { type, sessionId } = e;
         // An optimization for large calls. See `watchTrackPublished`.
-        if (participant) {
+        if (e.participant) {
+            const orphanedTracks = reconcileOrphanedTracks(state, e.participant);
+            const participant = Object.assign(e.participant, orphanedTracks);
             state.updateOrAddParticipant(sessionId, participant);
         }
         else {
@@ -9868,6 +10290,25 @@ const watchTrackUnpublished = (state) => {
     };
 };
 const unique = (v, i, arr) => arr.indexOf(v) === i;
+/**
+ * Reconciles orphaned tracks (if any) for the given participant.
+ *
+ * @param state the call state.
+ * @param participant the participant.
+ */
+const reconcileOrphanedTracks = (state, participant) => {
+    const orphanTracks = state.takeOrphanedTracks(participant.trackLookupPrefix);
+    if (!orphanTracks.length)
+        return;
+    const reconciledTracks = {};
+    for (const orphan of orphanTracks) {
+        const key = trackTypeToParticipantStreamKey(orphan.trackType);
+        if (!key)
+            continue;
+        reconciledTracks[key] = orphan.track;
+    }
+    return reconciledTracks;
+};
 
 /**
  * Watches for `dominantSpeakerChanged` events.
@@ -9916,12 +10357,13 @@ const watchAudioLevelChanged = (dispatcher, state) => {
  * Registers the default event handlers for a call during its lifecycle.
  *
  * @param call the call to register event handlers for.
- * @param state the call state.
  * @param dispatcher the dispatcher.
  */
-const registerEventHandlers = (call, state, dispatcher) => {
+const registerEventHandlers = (call, dispatcher) => {
+    const state = call.state;
     const eventHandlers = [
         call.on('call.ended', watchCallEnded(call)),
+        watchSfuCallEnded(call),
         watchLiveEnded(dispatcher, call),
         watchSfuErrorReports(dispatcher),
         watchChangePublishQuality(dispatcher, call),
@@ -9965,48 +10407,6 @@ const registerRingingCallEventHandlers = (call) => {
     };
 };
 
-/**
- * Collects all necessary information to join a call, talks to the coordinator
- * and returns the necessary information to join the call.
- *
- * @param httpClient the http client to use.
- * @param type the type of the call.
- * @param id the id of the call.
- * @param data the data for the call.
- */
-const join = async (httpClient, type, id, data) => {
-    const { call, credentials, members, own_capabilities, stats_options } = await doJoin(httpClient, type, id, data);
-    return {
-        connectionConfig: toRtcConfiguration(credentials.ice_servers),
-        sfuServer: credentials.server,
-        token: credentials.token,
-        metadata: call,
-        members,
-        ownCapabilities: own_capabilities,
-        statsOptions: stats_options,
-    };
-};
-const doJoin = async (httpClient, type, id, data) => {
-    const location = await httpClient.getLocationHint();
-    const request = {
-        ...data,
-        location,
-    };
-    return httpClient.post(`/call/${type}/${id}/join`, request);
-};
-const toRtcConfiguration = (config) => {
-    if (!config || config.length === 0)
-        return undefined;
-    const rtcConfig = {
-        iceServers: config.map((ice) => ({
-            urls: ice.urls,
-            username: ice.username,
-            credential: ice.password,
-        })),
-    };
-    return rtcConfig;
-};
-
 /**
  * Flatten the stats report into an array of stats objects.
  *
@@ -10286,6 +10686,7 @@ class SfuStatsReporter {
         this.start = () => {
             if (this.options.reporting_interval_ms <= 0)
                 return;
+            clearInterval(this.intervalId);
             this.intervalId = setInterval(() => {
                 this.run().catch((err) => {
                     this.logger('warn', 'Failed to report stats', err);
@@ -10969,7 +11370,7 @@ function lazy(factory) {
  * Returns an Observable that emits the list of available devices
  * that meet the given constraints.
  *
- * @param constraints the constraints to use when requesting the devices.
+ * @param permission a BrowserPermission instance.
  * @param kind the kind of devices to enumerate.
  */
 const getDevices = (permission, kind) => {
@@ -11222,6 +11623,12 @@ class InputMediaDeviceManager {
     listDevices() {
         return this.getDevices();
     }
+    /**
+     * Returns `true` when this device is in enabled state.
+     */
+    get enabled() {
+        return this.state.status === 'enabled';
+    }
     /**
      * Starts stream.
      */
@@ -11344,7 +11751,7 @@ class InputMediaDeviceManager {
         await this.applySettingsToStream();
     }
     async applySettingsToStream() {
-        if (this.state.status === 'enabled') {
+        if (this.enabled) {
             await this.muteStream();
             await this.unmuteStream();
         }
@@ -11481,19 +11888,22 @@ class InputMediaDeviceManager {
                 return output;
             })
                 .then(chainWith(parent), (error) => {
-                this.logger('warn', 'Fitler failed to start and will be ignored', error);
+                this.logger('warn', 'Filter failed to start and will be ignored', error);
                 return parent;
             }), rootStream);
         }
         if (this.call.state.callingState === exports.CallingState.JOINED) {
             await this.publishStream(stream);
         }
+        else {
+            this.logger('debug', 'Stream is not published as the call is not joined');
+        }
         if (this.state.mediaStream !== stream) {
             this.state.setMediaStream(stream, await rootStream);
             this.getTracks().forEach((track) => {
                 track.addEventListener('ended', async () => {
                     await this.statusChangeSettled();
-                    if (this.state.status === 'enabled') {
+                    if (this.enabled) {
                         this.isTrackStoppedDueToTrackEnd = true;
                         setTimeout(() => {
                             this.isTrackStoppedDueToTrackEnd = false;
@@ -11786,7 +12196,7 @@ class CameraManager extends InputMediaDeviceManager {
                 this.logger('warn', 'could not apply target resolution', error);
             }
         }
-        if (this.state.status === 'enabled') {
+        if (this.enabled) {
             const { width, height } = this.state
                 .mediaStream.getVideoTracks()[0]
                 ?.getSettings();
@@ -12090,7 +12500,7 @@ class MicrophoneManager extends InputMediaDeviceManager {
             });
             const registrationResult = this.registerFilter(noiseCancellation.toFilter());
             this.noiseCancellationRegistration = registrationResult.registered;
-            this.uregisterNoiseCancellation = registrationResult.unregister;
+            this.unregisterNoiseCancellation = registrationResult.unregister;
             await this.noiseCancellationRegistration;
             // handles an edge case where a noise cancellation is enabled after
             // the participant as joined the call -> we immediately enable NC
@@ -12116,7 +12526,7 @@ class MicrophoneManager extends InputMediaDeviceManager {
         if (isReactNative()) {
             throw new Error('Noise cancellation is not supported in React Native');
         }
-        await (this.uregisterNoiseCancellation?.() ?? Promise.resolve())
+        await (this.unregisterNoiseCancellation?.() ?? Promise.resolve())
             .then(() => this.noiseCancellation?.disable())
             .then(() => this.noiseCancellationChangeUnsubscribe?.())
             .catch((err) => {
@@ -12498,9 +12908,17 @@ class Call {
          */
         this.dispatcher = new Dispatcher();
         this.trackSubscriptionsSubject = new rxjs.BehaviorSubject({ type: exports.DebounceType.MEDIUM, data: [] });
+        this.sfuClientTag = 0;
+        this.reconnectConcurrencyTag = Symbol('reconnectConcurrencyTag');
         this.reconnectAttempts = 0;
-        this.maxReconnectAttempts = 10;
-        this.isLeaving = false;
+        this.reconnectStrategy = WebsocketReconnectStrategy.UNSPECIFIED;
+        this.fastReconnectDeadlineSeconds = 0;
+        this.lastOfflineTimestamp = 0;
+        // maintain the order of publishing tracks to restore them after a reconnection
+        // it shouldn't contain duplicates
+        this.trackPublishOrder = [];
+        this.hasJoinedOnce = false;
+        this.deviceSettingsAppliedOnce = false;
         this.initialized = false;
         this.joinLeaveConcurrencyTag = Symbol('joinLeaveConcurrencyTag');
         /**
@@ -12510,6 +12928,42 @@ class Call {
          */
         this.leaveCallHooks = new Set();
         this.streamClientEventHandlers = new Map();
+        this.handleOwnCapabilitiesUpdated = async (ownCapabilities) => {
+            // update the permission context.
+            this.permissionsContext.setPermissions(ownCapabilities);
+            if (!this.publisher)
+                return;
+            // check if the user still has publishing permissions and stop publishing if not.
+            const permissionToTrackType = {
+                [OwnCapability.SEND_AUDIO]: TrackType.AUDIO,
+                [OwnCapability.SEND_VIDEO]: TrackType.VIDEO,
+                [OwnCapability.SCREENSHARE]: TrackType.SCREEN_SHARE,
+            };
+            for (const [permission, trackType] of Object.entries(permissionToTrackType)) {
+                const hasPermission = this.permissionsContext.hasPermission(permission);
+                if (hasPermission)
+                    continue;
+                try {
+                    switch (trackType) {
+                        case TrackType.AUDIO:
+                            if (this.microphone.enabled)
+                                await this.microphone.disable();
+                            break;
+                        case TrackType.VIDEO:
+                            if (this.camera.enabled)
+                                await this.camera.disable();
+                            break;
+                        case TrackType.SCREEN_SHARE:
+                            if (this.screenShare.enabled)
+                                await this.screenShare.disable();
+                            break;
+                    }
+                }
+                catch (err) {
+                    this.logger('error', `Can't disable mic/camera/screenshare after revoked permissions`, err);
+                }
+            }
+        };
         /**
          * You can subscribe to WebSocket events provided by the API. To remove a subscription, call the `off` method.
          * Please note that subscribing to WebSocket events is an advanced use-case.
@@ -12560,9 +13014,8 @@ class Call {
                     throw new Error('Cannot leave call that has already been left.');
                 }
                 if (callingState === exports.CallingState.JOINING) {
-                    await this.assertCallJoined();
+                    await this.waitUntilCallJoined();
                 }
-                this.isLeaving = true;
                 if (this.ringing) {
                     // I'm the one who started the call, so I should cancel it.
                     const hasOtherParticipants = this.state.remoteParticipants.length > 0;
@@ -12584,14 +13037,15 @@ class Call {
                 this.sfuStatsReporter = undefined;
                 this.subscriber?.close();
                 this.subscriber = undefined;
-                this.publisher?.close();
+                this.publisher?.close({ stopTracks: true });
                 this.publisher = undefined;
-                this.sfuClient?.close(StreamSfuClient.NORMAL_CLOSURE, reason);
+                await this.sfuClient?.leaveAndClose(reason);
                 this.sfuClient = undefined;
                 this.state.setCallingState(exports.CallingState.LEFT);
                 // Call all leave call hooks, e.g. to clean up global event handlers
                 this.leaveCallHooks.forEach((hook) => hook());
                 this.initialized = false;
+                this.hasJoinedOnce = false;
                 this.clientStore.unregisterCall(this);
                 this.camera.dispose();
                 this.microphone.dispose();
@@ -12631,7 +13085,7 @@ class Call {
                 this.watching = true;
                 this.clientStore.registerCall(this);
             }
-            await this.applyDeviceConfig();
+            await this.applyDeviceConfig(false);
             return response;
         };
         /**
@@ -12653,7 +13107,7 @@ class Call {
                 this.watching = true;
                 this.clientStore.registerCall(this);
             }
-            await this.applyDeviceConfig();
+            await this.applyDeviceConfig(false);
             return response;
         };
         /**
@@ -12709,253 +13163,174 @@ class Call {
             await this.setup();
             const callingState = this.state.callingState;
             if ([exports.CallingState.JOINED, exports.CallingState.JOINING].includes(callingState)) {
-                this.logger('warn', 'Join method called twice, you should only call this once');
-                throw new Error(`Illegal State: Already joined.`);
+                throw new Error(`Illegal State: call.join() shall be called only once`);
             }
-            const isMigrating = callingState === exports.CallingState.MIGRATING;
-            const isReconnecting = callingState === exports.CallingState.RECONNECTING;
-            this.state.setCallingState(exports.CallingState.JOINING);
+            this.joinCallData = data;
             this.logger('debug', 'Starting join flow');
-            if (data?.ring && !this.ringing) {
-                this.ringingSubject.next(true);
-            }
-            if (this.ringing && !this.isCreatedByMe) {
-                // signals other users that I have accepted the incoming call.
-                await this.accept();
-            }
-            let sfuServer;
-            let sfuToken;
-            let connectionConfig;
-            let statsOptions;
-            try {
-                if (this.sfuClient?.isFastReconnecting) {
-                    // use previous SFU configuration and values
-                    connectionConfig = this.publisher?.connectionConfiguration;
-                    sfuServer = this.sfuClient.sfuServer;
-                    sfuToken = this.sfuClient.token;
-                    statsOptions = this.sfuStatsReporter?.options;
-                }
-                else {
-                    // full join flow - let the Coordinator pick a new SFU for us
-                    const call = await join(this.streamClient, this.type, this.id, data);
-                    this.state.updateFromCallResponse(call.metadata);
-                    this.state.setMembers(call.members);
-                    this.state.setOwnCapabilities(call.ownCapabilities);
-                    connectionConfig = call.connectionConfig;
-                    sfuServer = call.sfuServer;
-                    sfuToken = call.token;
-                    statsOptions = call.statsOptions;
+            this.state.setCallingState(exports.CallingState.JOINING);
+            const performingMigration = this.reconnectStrategy === WebsocketReconnectStrategy.MIGRATE;
+            const performingRejoin = this.reconnectStrategy === WebsocketReconnectStrategy.REJOIN;
+            const performingFastReconnect = this.reconnectStrategy === WebsocketReconnectStrategy.FAST;
+            let statsOptions = this.sfuStatsReporter?.options;
+            if (!this.credentials ||
+                !statsOptions ||
+                performingRejoin ||
+                performingMigration) {
+                try {
+                    const joinResponse = await this.doJoinRequest(data);
+                    this.credentials = joinResponse.credentials;
+                    statsOptions = joinResponse.stats_options;
                 }
-                if (this.streamClient._hasConnectionID()) {
-                    this.watching = true;
-                    this.clientStore.registerCall(this);
+                catch (error) {
+                    // restore the previous call state if the join-flow fails
+                    this.state.setCallingState(callingState);
+                    throw error;
                 }
             }
-            catch (error) {
-                // restore the previous call state if the join-flow fails
-                this.state.setCallingState(callingState);
-                throw error;
-            }
             const previousSfuClient = this.sfuClient;
-            const sfuClient = (this.sfuClient = new StreamSfuClient({
-                dispatcher: this.dispatcher,
-                sfuServer,
-                token: sfuToken,
-                sessionId: previousSfuClient?.sessionId,
-            }));
-            /**
-             * A closure which hides away the re-connection logic.
-             */
-            const reconnect = async (strategy, reason) => {
-                const currentState = this.state.callingState;
-                if (currentState === exports.CallingState.MIGRATING ||
-                    currentState === exports.CallingState.RECONNECTING) {
-                    // prevent parallel reconnection attempts
-                    return;
-                }
-                this.reconnectAttempts++;
-                this.state.setCallingState(strategy === 'migrate'
-                    ? exports.CallingState.MIGRATING
-                    : exports.CallingState.RECONNECTING);
-                if (strategy === 'migrate') {
-                    this.logger('debug', `[Migration]: migrating call ${this.cid} away from ${sfuServer.edge_name}`);
-                    sfuClient.isMigratingAway = true;
-                }
-                else {
-                    this.logger('debug', `[Rejoin]: ${strategy} rejoin call ${this.cid} (${this.reconnectAttempts})...`);
-                }
-                // take a snapshot of the current "local participant" state
-                // we'll need it for restoring the previous publishing state later
-                const localParticipant = this.state.localParticipant;
-                if (strategy === 'fast') {
-                    sfuClient.close(StreamSfuClient.ERROR_CONNECTION_BROKEN, `attempting fast reconnect: ${reason}`);
-                }
-                else if (strategy === 'full') {
-                    // in migration or recovery scenarios, we don't want to
-                    // wait before attempting to reconnect to an SFU server
-                    await sleep(retryInterval(this.reconnectAttempts));
-                    // in full-reconnect, we need to dispose all Peer Connections
-                    this.subscriber?.close();
-                    this.subscriber = undefined;
-                    this.publisher?.close({ stopTracks: false });
-                    this.publisher = undefined;
-                    this.statsReporter?.stop();
-                    this.statsReporter = undefined;
-                    this.sfuStatsReporter?.stop();
-                    this.sfuStatsReporter = undefined;
-                    // clean up current connection
-                    sfuClient.close(StreamSfuClient.NORMAL_CLOSURE, `attempting full reconnect: ${reason}`);
-                }
-                await this.join({
-                    ...data,
-                    ...(strategy === 'migrate' && { migrating_from: sfuServer.edge_name }),
+            const previousSessionId = previousSfuClient?.sessionId;
+            const isWsHealthy = !!previousSfuClient?.isHealthy;
+            const sfuClient = performingRejoin || performingMigration || !isWsHealthy
+                ? new StreamSfuClient({
+                    logTag: String(this.sfuClientTag++),
+                    dispatcher: this.dispatcher,
+                    credentials: this.credentials,
+                    // a new session_id is necessary for the REJOIN strategy.
+                    // we use the previous session_id if available
+                    sessionId: performingRejoin ? undefined : previousSessionId,
+                    onSignalClose: () => this.handleSfuSignalClose(sfuClient),
+                })
+                : previousSfuClient;
+            this.sfuClient = sfuClient;
+            const clientDetails = getClientDetails();
+            // we don't need to send JoinRequest if we are re-using an existing healthy SFU client
+            if (previousSfuClient !== sfuClient) {
+                // prepare a generic SDP and send it to the SFU.
+                // this is a throw-away SDP that the SFU will use to determine
+                // the capabilities of the client (codec support, etc.)
+                const receivingCapabilitiesSdp = await getGenericSdp('recvonly');
+                const reconnectDetails = this.reconnectStrategy !== WebsocketReconnectStrategy.UNSPECIFIED
+                    ? this.getReconnectDetails(data?.migrating_from, previousSessionId)
+                    : undefined;
+                const { callState, fastReconnectDeadlineSeconds } = await sfuClient.join({
+                    subscriberSdp: receivingCapabilitiesSdp,
+                    clientDetails,
+                    fastReconnect: performingFastReconnect,
+                    reconnectDetails,
                 });
-                // clean up previous connection
-                if (strategy === 'migrate') {
-                    sfuClient.close(StreamSfuClient.NORMAL_CLOSURE, 'attempting migration');
-                }
-                this.logger('info', `[Rejoin]: Attempt ${this.reconnectAttempts} successful!`);
-                // we shouldn't be republishing the streams if we're migrating
-                // as the underlying peer connection will take care of it as part
-                // of the ice-restart process
-                if (localParticipant && strategy === 'full') {
-                    const { audioStream, videoStream, screenShareStream, screenShareAudioStream, } = localParticipant;
-                    let screenShare;
-                    if (screenShareStream || screenShareAudioStream) {
-                        screenShare = new MediaStream();
-                        screenShareStream?.getVideoTracks().forEach((track) => {
-                            screenShare?.addTrack(track);
-                        });
-                        screenShareAudioStream?.getAudioTracks().forEach((track) => {
-                            screenShare?.addTrack(track);
-                        });
-                    }
-                    // restore previous publishing state
-                    if (audioStream)
-                        await this.publishAudioStream(audioStream);
-                    if (videoStream) {
-                        await this.publishVideoStream(videoStream, {
-                            preferredCodec: this.camera.preferredCodec,
-                        });
-                    }
-                    if (screenShare)
-                        await this.publishScreenShareStream(screenShare);
-                    this.logger('info', `[Rejoin]: State restored. Attempt: ${this.reconnectAttempts}`);
+                this.fastReconnectDeadlineSeconds = fastReconnectDeadlineSeconds;
+                if (callState) {
+                    this.state.updateFromSfuCallState(callState, sfuClient.sessionId, reconnectDetails);
                 }
-            };
-            // reconnect if the connection was closed unexpectedly. example:
-            // - SFU crash or restart
-            // - network change
-            sfuClient.signalReady.then(() => {
-                // register a handler for the "goAway" event
-                const unregisterGoAway = this.dispatcher.on('goAway', (event) => {
-                    const { reason } = event;
-                    this.logger('info', `[Migration]: Going away from SFU... Reason: ${GoAwayReason[reason]}`);
-                    reconnect('migrate', GoAwayReason[reason]).catch((err) => {
-                        this.logger('warn', `[Migration]: Failed to migrate to another SFU.`, err);
-                    });
-                });
-                sfuClient.signalWs.addEventListener('close', (e) => {
-                    // unregister the "goAway" handler, as we won't need it anymore for this connection.
-                    // the upcoming re-join will register a new handler anyway
-                    unregisterGoAway();
-                    // when the user has initiated "call.leave()" operation, we shouldn't
-                    // care for the WS close code and we shouldn't ever attempt to reconnect
-                    if (this.isLeaving)
-                        return;
-                    // do nothing if the connection was closed on purpose
-                    if (e.code === StreamSfuClient.NORMAL_CLOSURE)
-                        return;
-                    // do nothing if the connection was closed because of a policy violation
-                    // e.g., the user has been blocked by an admin or moderator
-                    if (e.code === KnownCodes.WS_POLICY_VIOLATION)
-                        return;
-                    // When the SFU is being shut down, it sends a goAway message.
-                    // While we migrate to another SFU, we might have the WS connection
-                    // to the old SFU closed abruptly. In this case, we don't want
-                    // to reconnect to the old SFU, but rather to the new one.
-                    const isMigratingAway = e.code === KnownCodes.WS_CLOSED_ABRUPTLY && sfuClient.isMigratingAway;
-                    const isFastReconnecting = e.code === KnownCodes.WS_CLOSED_ABRUPTLY &&
-                        sfuClient.isFastReconnecting;
-                    if (isMigratingAway || isFastReconnecting)
-                        return;
-                    // do nothing if the connection was closed because of a fast reconnect
-                    if (e.code === StreamSfuClient.ERROR_CONNECTION_BROKEN)
-                        return;
-                    if (this.reconnectAttempts < this.maxReconnectAttempts) {
-                        sfuClient.isFastReconnecting = this.reconnectAttempts === 0;
-                        const strategy = sfuClient.isFastReconnecting ? 'fast' : 'full';
-                        reconnect(strategy, `SFU closed the WS with code: ${e.code}`).catch((err) => {
-                            this.logger('error', `[Rejoin]: ${strategy} rejoin failed for ${this.reconnectAttempts} times. Giving up.`, err);
-                            this.state.setCallingState(exports.CallingState.RECONNECTING_FAILED);
-                        });
-                    }
-                    else {
-                        this.logger('error', '[Rejoin]: Reconnect attempts exceeded. Giving up...');
-                        this.state.setCallingState(exports.CallingState.RECONNECTING_FAILED);
-                    }
-                });
-            });
-            // handlers for connection online/offline events
-            const unsubscribeOnlineEvent = this.streamClient.on('connection.changed', async (e) => {
-                if (e.type !== 'connection.changed')
-                    return;
-                if (!e.online)
-                    return;
-                unsubscribeOnlineEvent();
-                const currentCallingState = this.state.callingState;
-                const shouldReconnect = currentCallingState === exports.CallingState.OFFLINE ||
-                    currentCallingState === exports.CallingState.RECONNECTING_FAILED;
-                if (!shouldReconnect)
-                    return;
-                this.logger('info', '[Rejoin]: Going online...');
-                let isFirstReconnectAttempt = true;
-                do {
-                    try {
-                        sfuClient.isFastReconnecting = isFirstReconnectAttempt;
-                        await reconnect(isFirstReconnectAttempt ? 'fast' : 'full', 'Network: online');
-                        return; // break the loop if rejoin is successful
-                    }
-                    catch (err) {
-                        this.logger('error', `[Rejoin][Network]: Rejoin failed for attempt ${this.reconnectAttempts}`, err);
-                    }
-                    // wait for a bit before trying to reconnect again
-                    await sleep(retryInterval(this.reconnectAttempts));
-                    isFirstReconnectAttempt = false;
-                } while (this.reconnectAttempts < this.maxReconnectAttempts);
-                // if we're here, it means that we've exhausted all the reconnect attempts
-                this.logger('error', `[Rejoin][Network]: Rejoin failed. Giving up.`);
-                this.state.setCallingState(exports.CallingState.RECONNECTING_FAILED);
-            });
-            const unsubscribeOfflineEvent = this.streamClient.on('connection.changed', (e) => {
-                if (e.type !== 'connection.changed')
-                    return;
-                if (e.online)
-                    return;
-                unsubscribeOfflineEvent();
-                this.state.setCallingState(exports.CallingState.OFFLINE);
-            });
-            this.leaveCallHooks.add(() => {
-                unsubscribeOnlineEvent();
-                unsubscribeOfflineEvent();
-            });
-            if (!this.subscriber) {
-                this.subscriber = new Subscriber({
+            }
+            if (!performingMigration) {
+                // in MIGRATION, `JOINED` state is set in `this.reconnectMigrate()`
+                this.state.setCallingState(exports.CallingState.JOINED);
+            }
+            this.hasJoinedOnce = true;
+            // when performing fast reconnect, or when we reuse the same SFU client,
+            // (ws remained healthy), we just need to restore the ICE connection
+            if (performingFastReconnect) {
+                // the SFU automatically issues an ICE restart on the subscriber
+                // we don't have to do it ourselves
+                await this.restoreICE(sfuClient, { includeSubscriber: false });
+            }
+            else {
+                const connectionConfig = toRtcConfiguration(this.credentials.ice_servers);
+                this.initPublisherAndSubscriber({
                     sfuClient,
-                    dispatcher: this.dispatcher,
-                    state: this.state,
                     connectionConfig,
-                    onUnrecoverableError: () => {
-                        reconnect('full', 'unrecoverable subscriber error').catch((err) => {
-                            this.logger('debug', '[Rejoin]: Rejoin failed', err);
-                        });
-                    },
+                    clientDetails,
+                    statsOptions,
+                    closePreviousInstances: !performingMigration,
                 });
             }
+            if (performingRejoin) {
+                const strategy = WebsocketReconnectStrategy[this.reconnectStrategy];
+                await previousSfuClient?.leaveAndClose(`Closing previous WS after reconnect with strategy: ${strategy}`);
+            }
+            else if (!isWsHealthy) {
+                previousSfuClient?.close(4002, 'Closing unhealthy WS after reconnect');
+            }
+            // device settings should be applied only once, we don't have to
+            // re-apply them on later reconnections or server-side data fetches
+            if (!this.deviceSettingsAppliedOnce) {
+                await this.applyDeviceConfig(true);
+                this.deviceSettingsAppliedOnce = true;
+            }
+            this.logger('info', `Joined call ${this.cid}`);
+        };
+        /**
+         * Prepares Reconnect Details object.
+         * @internal
+         */
+        this.getReconnectDetails = (migratingFromSfuId, previousSessionId) => {
+            const strategy = this.reconnectStrategy;
+            const performingRejoin = strategy === WebsocketReconnectStrategy.REJOIN;
+            const announcedTracks = this.publisher?.getAnnouncedTracks() || [];
+            const subscribedTracks = getCurrentValue(this.trackSubscriptionsSubject);
+            return {
+                strategy,
+                announcedTracks,
+                subscriptions: subscribedTracks.data || [],
+                reconnectAttempt: this.reconnectAttempts,
+                fromSfuId: migratingFromSfuId || '',
+                previousSessionId: performingRejoin ? previousSessionId || '' : '',
+            };
+        };
+        /**
+         * Performs an ICE restart on both the Publisher and Subscriber Peer Connections.
+         * Uses the provided SFU client to restore the ICE connection.
+         *
+         * This method can throw an error if the ICE restart fails.
+         * This error should be handled by the reconnect loop,
+         * and a new reconnection shall be attempted.
+         *
+         * @internal
+         */
+        this.restoreICE = async (nextSfuClient, opts = {}) => {
+            const { includeSubscriber = true, includePublisher = true } = opts;
+            if (this.subscriber) {
+                this.subscriber.setSfuClient(nextSfuClient);
+                if (includeSubscriber) {
+                    await this.subscriber.restartIce();
+                }
+            }
+            if (this.publisher) {
+                this.publisher.setSfuClient(nextSfuClient);
+                if (includePublisher) {
+                    await this.publisher.restartIce();
+                }
+            }
+        };
+        /**
+         * Initializes the Publisher and Subscriber Peer Connections.
+         * @internal
+         */
+        this.initPublisherAndSubscriber = (opts) => {
+            const { sfuClient, connectionConfig, clientDetails, statsOptions, closePreviousInstances, } = opts;
+            if (closePreviousInstances && this.subscriber) {
+                this.subscriber.close();
+            }
+            this.subscriber = new Subscriber({
+                sfuClient,
+                dispatcher: this.dispatcher,
+                state: this.state,
+                connectionConfig,
+                logTag: String(this.reconnectAttempts),
+                onUnrecoverableError: () => {
+                    this.reconnect(WebsocketReconnectStrategy.REJOIN).catch((err) => {
+                        this.logger('warn', '[Reconnect] Error reconnecting after a subscriber error', err);
+                    });
+                },
+            });
             // anonymous users can't publish anything hence, there is no need
             // to create Publisher Peer Connection for them
             const isAnonymous = this.streamClient.user?.type === 'anonymous';
-            if (!this.publisher && !isAnonymous) {
+            if (!isAnonymous) {
+                if (closePreviousInstances && this.publisher) {
+                    this.publisher.close({ stopTracks: false });
+                }
                 const audioSettings = this.state.settings?.audio;
                 const isDtxEnabled = !!audioSettings?.opus_dtx_enabled;
                 const isRedEnabled = !!audioSettings?.redundant_coding_enabled;
@@ -12966,23 +13341,23 @@ class Call {
                     connectionConfig,
                     isDtxEnabled,
                     isRedEnabled,
+                    logTag: String(this.reconnectAttempts),
                     onUnrecoverableError: () => {
-                        reconnect('full', 'unrecoverable publisher error').catch((err) => {
-                            this.logger('debug', '[Rejoin]: Rejoin failed', err);
+                        this.reconnect(WebsocketReconnectStrategy.REJOIN).catch((err) => {
+                            this.logger('warn', '[Reconnect] Error reconnecting after a publisher error', err);
                         });
                     },
                 });
             }
-            if (!this.statsReporter) {
-                this.statsReporter = createStatsReporter({
-                    subscriber: this.subscriber,
-                    publisher: this.publisher,
-                    state: this.state,
-                    datacenter: this.sfuClient.edgeName,
-                });
-            }
-            const clientDetails = getClientDetails();
-            if (!this.sfuStatsReporter && statsOptions) {
+            this.statsReporter?.stop();
+            this.statsReporter = createStatsReporter({
+                subscriber: this.subscriber,
+                publisher: this.publisher,
+                state: this.state,
+                datacenter: sfuClient.edgeName,
+            });
+            this.sfuStatsReporter?.stop();
+            if (statsOptions?.reporting_interval_ms > 0) {
                 this.sfuStatsReporter = new SfuStatsReporter(sfuClient, {
                     clientDetails,
                     options: statsOptions,
@@ -12991,129 +13366,262 @@ class Call {
                 });
                 this.sfuStatsReporter.start();
             }
-            try {
-                // 1. wait for the signal server to be ready before sending "joinRequest"
-                sfuClient.signalReady
-                    .catch((err) => this.logger('error', 'Signal ready failed', err))
-                    // prepare a generic SDP and send it to the SFU.
-                    // this is a throw-away SDP that the SFU will use to determine
-                    // the capabilities of the client (codec support, etc.)
-                    .then(() => getGenericSdp('recvonly'))
-                    .then((sdp) => {
-                    const subscriptions = getCurrentValue(this.trackSubscriptionsSubject);
-                    const migration = isMigrating
-                        ? {
-                            fromSfuId: data?.migrating_from || '',
-                            subscriptions: subscriptions.data || [],
-                            announcedTracks: this.publisher?.getCurrentTrackInfos() || [],
+        };
+        /**
+         * Retrieves credentials for joining the call.
+         *
+         * @internal
+         *
+         * @param data the join call data.
+         */
+        this.doJoinRequest = async (data) => {
+            const location = await this.streamClient.getLocationHint();
+            const request = { ...data, location };
+            const joinResponse = await this.streamClient.post(`${this.streamClientBasePath}/join`, request);
+            this.state.updateFromCallResponse(joinResponse.call);
+            this.state.setMembers(joinResponse.members);
+            this.state.setOwnCapabilities(joinResponse.own_capabilities);
+            if (data?.ring && !this.ringing) {
+                this.ringingSubject.next(true);
+            }
+            if (this.ringing && !this.isCreatedByMe) {
+                // signals other users that I have accepted the incoming call.
+                await this.accept();
+            }
+            if (this.streamClient._hasConnectionID()) {
+                this.watching = true;
+                this.clientStore.registerCall(this);
+            }
+            return joinResponse;
+        };
+        /**
+         * Handles the reconnection flow.
+         *
+         * @internal
+         *
+         * @param strategy the reconnection strategy to use.
+         */
+        this.reconnect = async (strategy) => {
+            return withoutConcurrency(this.reconnectConcurrencyTag, async () => {
+                this.logger('info', `[Reconnect] Reconnecting with strategy ${WebsocketReconnectStrategy[strategy]}`);
+                this.reconnectStrategy = strategy;
+                do {
+                    this.reconnectAttempts++;
+                    const current = WebsocketReconnectStrategy[this.reconnectStrategy];
+                    try {
+                        // wait until the network is available
+                        await this.networkAvailableTask?.promise;
+                        switch (this.reconnectStrategy) {
+                            case WebsocketReconnectStrategy.UNSPECIFIED:
+                            case WebsocketReconnectStrategy.DISCONNECT:
+                                this.logger('debug', `[Reconnect] No-op strategy ${current}`);
+                                break;
+                            case WebsocketReconnectStrategy.FAST:
+                                await this.reconnectFast();
+                                break;
+                            case WebsocketReconnectStrategy.REJOIN:
+                                await this.reconnectRejoin();
+                                break;
+                            case WebsocketReconnectStrategy.MIGRATE:
+                                await this.reconnectMigrate();
+                                break;
+                            default:
+                                ensureExhausted(this.reconnectStrategy, 'Unknown reconnection strategy');
+                                break;
                         }
-                        : undefined;
-                    return sfuClient.join({
-                        subscriberSdp: sdp || '',
-                        clientDetails,
-                        migration,
-                        fastReconnect: previousSfuClient?.isFastReconnecting ?? false,
-                    });
+                        break; // do-while loop, reconnection worked, exit the loop
+                    }
+                    catch (error) {
+                        this.logger('warn', `[Reconnect] ${current}(${this.reconnectAttempts}) failed. Attempting with REJOIN`, error);
+                        await sleep(500);
+                        this.reconnectStrategy = WebsocketReconnectStrategy.REJOIN;
+                    }
+                } while (this.state.callingState !== exports.CallingState.JOINED &&
+                    this.state.callingState !== exports.CallingState.LEFT);
+            });
+        };
+        /**
+         * Initiates the reconnection flow with the "fast" strategy.
+         * @internal
+         */
+        this.reconnectFast = async () => {
+            this.reconnectStrategy = WebsocketReconnectStrategy.FAST;
+            this.state.setCallingState(exports.CallingState.RECONNECTING);
+            return this.join(this.joinCallData);
+        };
+        /**
+         * Initiates the reconnection flow with the "rejoin" strategy.
+         * @internal
+         */
+        this.reconnectRejoin = async () => {
+            this.reconnectStrategy = WebsocketReconnectStrategy.REJOIN;
+            this.state.setCallingState(exports.CallingState.RECONNECTING);
+            await this.join(this.joinCallData);
+            await this.restorePublishedTracks();
+            this.restoreSubscribedTracks();
+        };
+        /**
+         * Initiates the reconnection flow with the "migrate" strategy.
+         * @internal
+         */
+        this.reconnectMigrate = async () => {
+            const currentSfuClient = this.sfuClient;
+            if (!currentSfuClient) {
+                throw new Error('Cannot migrate without an active SFU client');
+            }
+            this.reconnectStrategy = WebsocketReconnectStrategy.MIGRATE;
+            this.state.setCallingState(exports.CallingState.MIGRATING);
+            const currentSubscriber = this.subscriber;
+            const currentPublisher = this.publisher;
+            currentSubscriber?.detachEventHandlers();
+            currentPublisher?.detachEventHandlers();
+            const migrationTask = currentSfuClient.enterMigration();
+            try {
+                const currentSfu = currentSfuClient.edgeName;
+                await this.join({ ...this.joinCallData, migrating_from: 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;
+            }
+            await this.restorePublishedTracks();
+            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;
+                // in MIGRATE, we can consider the call as joined only after
+                // `participantMigrationComplete` event is received, signaled by
+                // the `migrationTask`
+                this.state.setCallingState(exports.CallingState.JOINED);
+            }
+            finally {
+                currentSubscriber?.close();
+                currentPublisher?.close({ stopTracks: false });
+                // and close the previous SFU client, without specifying close code
+                currentSfuClient.close();
+            }
+        };
+        /**
+         * Registers the various event handlers for reconnection.
+         *
+         * @internal
+         */
+        this.registerReconnectHandlers = () => {
+            // handles the legacy "goAway" event
+            const unregisterGoAway = this.on('goAway', () => {
+                this.reconnect(WebsocketReconnectStrategy.MIGRATE).catch((err) => {
+                    this.logger('warn', '[Reconnect] Error reconnecting', err);
                 });
-                // 2. in parallel, wait for the SFU to send us the "joinResponse"
-                // this will throw an error if the SFU rejects the join request or
-                // fails to respond in time
-                const { callState, reconnected } = await this.waitForJoinResponse();
-                if (isReconnecting) {
-                    this.logger('debug', '[Rejoin] fast reconnected:', reconnected);
+            });
+            // handles the "error" event, through which the SFU can request a reconnect
+            const unregisterOnError = this.on('error', (e) => {
+                const { reconnectStrategy: strategy } = e;
+                if (strategy === WebsocketReconnectStrategy.UNSPECIFIED)
+                    return;
+                if (strategy === WebsocketReconnectStrategy.DISCONNECT) {
+                    this.leave({ reason: 'SFU instructed to disconnect' }).catch((err) => {
+                        this.logger('warn', `Can't leave call after disconnect request`, err);
+                    });
                 }
-                if (isMigrating) {
-                    await this.subscriber.migrateTo(sfuClient, connectionConfig);
-                    await this.publisher?.migrateTo(sfuClient, connectionConfig);
+                else {
+                    this.reconnect(strategy).catch((err) => {
+                        this.logger('warn', '[Reconnect] Error reconnecting', err);
+                    });
                 }
-                else if (isReconnecting) {
-                    if (reconnected) {
-                        // update the SFU client instance on the subscriber and publisher
-                        this.subscriber.setSfuClient(sfuClient);
-                        // publisher might not be there (anonymous users)
-                        if (this.publisher) {
-                            this.publisher.setSfuClient(sfuClient);
-                            // and perform a full ICE restart on the publisher
-                            await this.publisher.restartIce();
+            });
+            const unregisterNetworkChanged = this.streamClient.on('network.changed', (e) => {
+                if (!e.online) {
+                    this.logger('debug', '[Reconnect] Going offline');
+                    if (!this.hasJoinedOnce)
+                        return;
+                    this.lastOfflineTimestamp = Date.now();
+                    // create a new task that would resolve when the network is available
+                    const networkAvailableTask = promiseWithResolvers();
+                    networkAvailableTask.promise.then(() => {
+                        let strategy = WebsocketReconnectStrategy.FAST;
+                        if (this.lastOfflineTimestamp) {
+                            const offline = (Date.now() - this.lastOfflineTimestamp) / 1000;
+                            if (offline > this.fastReconnectDeadlineSeconds) {
+                                // We shouldn't attempt FAST if we have exceeded the deadline.
+                                // The SFU would have already wiped out the session.
+                                strategy = WebsocketReconnectStrategy.REJOIN;
+                            }
                         }
-                    }
-                    else if (previousSfuClient?.isFastReconnecting) {
-                        // reconnection wasn't possible, so we need to do a full rejoin
-                        return await reconnect('full', 're-attempting').catch((err) => {
-                            this.logger('error', `[Rejoin]: Rejoin failed forced full rejoin.`, err);
-                        });
-                    }
-                }
-                const currentParticipants = callState?.participants || [];
-                const participantCount = callState?.participantCount;
-                const startedAt = callState?.startedAt
-                    ? Timestamp.toDate(callState.startedAt)
-                    : new Date();
-                const pins = callState?.pins ?? [];
-                this.state.setParticipants(() => {
-                    const participantLookup = this.state.getParticipantLookupBySessionId();
-                    return currentParticipants.map((p) => {
-                        // We need to preserve the local state of the participant
-                        // (e.g. videoDimension, visibilityState, pinnedAt, etc.)
-                        // as it doesn't exist on the server.
-                        const existingParticipant = participantLookup[p.sessionId];
-                        return Object.assign(p, existingParticipant, {
-                            isLocalParticipant: p.sessionId === sfuClient.sessionId,
-                            viewportVisibilityState: existingParticipant?.viewportVisibilityState ?? {
-                                videoTrack: exports.VisibilityState.UNKNOWN,
-                                screenShareTrack: exports.VisibilityState.UNKNOWN,
-                            },
+                        this.reconnect(strategy).catch((err) => {
+                            this.logger('warn', '[Reconnect] Error restoring connection after going online', err);
                         });
                     });
-                });
-                this.state.setParticipantCount(participantCount?.total || 0);
-                this.state.setAnonymousParticipantCount(participantCount?.anonymous || 0);
-                this.state.setStartedAt(startedAt);
-                this.state.setServerSidePins(pins);
-                this.reconnectAttempts = 0; // reset the reconnect attempts counter
-                this.state.setCallingState(exports.CallingState.JOINED);
-                try {
-                    await this.initCamera({ setStatus: true });
-                    await this.initMic({ setStatus: true });
-                }
-                catch (error) {
-                    this.logger('warn', 'Camera and/or mic init failed during join call', error);
-                }
-                // 3. once we have the "joinResponse", and possibly reconciled the local state
-                // we schedule a fast subscription update for all remote participants
-                // that were visible before we reconnected or migrated to a new SFU.
-                const { remoteParticipants } = this.state;
-                if (remoteParticipants.length > 0) {
-                    this.updateSubscriptions(remoteParticipants, exports.DebounceType.FAST);
-                }
-                this.logger('info', `Joined call ${this.cid}`);
-            }
-            catch (err) {
-                // join failed, try to rejoin
-                if (this.reconnectAttempts < this.maxReconnectAttempts) {
-                    this.logger('error', `[Rejoin]: Rejoin ${this.reconnectAttempts} failed.`, err);
-                    await reconnect('full', 'previous attempt failed');
-                    this.logger('info', `[Rejoin]: Rejoin ${this.reconnectAttempts} successful!`);
+                    this.networkAvailableTask = networkAvailableTask;
+                    this.sfuStatsReporter?.stop();
+                    this.state.setCallingState(exports.CallingState.OFFLINE);
                 }
                 else {
-                    this.logger('error', `[Rejoin]: Rejoin failed for ${this.reconnectAttempts} times. Giving up.`);
-                    this.state.setCallingState(exports.CallingState.RECONNECTING_FAILED);
-                    throw new Error('Join failed');
+                    this.logger('debug', '[Reconnect] Going online');
+                    // TODO try to remove this .close call
+                    this.sfuClient?.close(4002, 'Closing WS to reconnect after going online');
+                    // we went online, release the previous waiters and reset the state
+                    this.networkAvailableTask?.resolve();
+                    this.networkAvailableTask = undefined;
+                    this.sfuStatsReporter?.start();
+                }
+            });
+            this.leaveCallHooks.add(unregisterGoAway);
+            this.leaveCallHooks.add(unregisterOnError);
+            this.leaveCallHooks.add(unregisterNetworkChanged);
+        };
+        /**
+         * Restores the published tracks after a reconnection.
+         * @internal
+         */
+        this.restorePublishedTracks = async () => {
+            // the tracks need to be restored in their original order of publishing
+            // otherwise, we might get `m-lines order mismatch` errors
+            for (const trackType of this.trackPublishOrder) {
+                switch (trackType) {
+                    case TrackType.AUDIO:
+                        const audioStream = this.microphone.state.mediaStream;
+                        if (audioStream) {
+                            await this.publishAudioStream(audioStream);
+                        }
+                        break;
+                    case TrackType.VIDEO:
+                        const videoStream = this.camera.state.mediaStream;
+                        if (videoStream) {
+                            await this.publishVideoStream(videoStream, {
+                                preferredCodec: this.camera.preferredCodec,
+                            });
+                        }
+                        break;
+                    case TrackType.SCREEN_SHARE:
+                        const screenShareStream = this.screenShare.state.mediaStream;
+                        if (screenShareStream) {
+                            await this.publishScreenShareStream(screenShareStream, {
+                                screenShareSettings: this.screenShare.getSettings(),
+                            });
+                        }
+                        break;
+                    // screen share audio can't exist without a screen share, so we handle it there
+                    case TrackType.SCREEN_SHARE_AUDIO:
+                    case TrackType.UNSPECIFIED:
+                        break;
+                    default:
+                        ensureExhausted(trackType, 'Unknown track type');
+                        break;
                 }
             }
         };
-        this.waitForJoinResponse = (timeout = 5000) => {
-            return new Promise((resolve, reject) => {
-                const unsubscribe = this.on('joinResponse', (event) => {
-                    clearTimeout(timeoutId);
-                    unsubscribe();
-                    resolve(event);
-                });
-                const timeoutId = setTimeout(() => {
-                    unsubscribe();
-                    reject(new Error('Waiting for "joinResponse" has timed out'));
-                }, timeout);
-            });
+        /**
+         * Restores the subscribed tracks after a reconnection.
+         * @internal
+         */
+        this.restoreSubscribedTracks = () => {
+            const { remoteParticipants } = this.state;
+            if (remoteParticipants.length <= 0)
+                return;
+            this.updateSubscriptions(remoteParticipants, exports.DebounceType.FAST);
         };
         /**
          * Starts publishing the given video stream to the call.
@@ -13128,7 +13636,7 @@ class Call {
         this.publishVideoStream = async (videoStream, opts = {}) => {
             // we should wait until we get a JoinResponse from the SFU,
             // otherwise we risk breaking the ICETrickle flow.
-            await this.assertCallJoined();
+            await this.waitUntilCallJoined();
             if (!this.publisher) {
                 this.logger('error', 'Trying to publish video before join is completed');
                 throw new Error(`Call not joined yet.`);
@@ -13138,6 +13646,9 @@ class Call {
                 this.logger('error', `There is no video track to publish in the stream.`);
                 return;
             }
+            if (!this.trackPublishOrder.includes(TrackType.VIDEO)) {
+                this.trackPublishOrder.push(TrackType.VIDEO);
+            }
             await this.publisher.publishStream(videoStream, videoTrack, TrackType.VIDEO, opts);
         };
         /**
@@ -13152,7 +13663,7 @@ class Call {
         this.publishAudioStream = async (audioStream) => {
             // we should wait until we get a JoinResponse from the SFU,
             // otherwise we risk breaking the ICETrickle flow.
-            await this.assertCallJoined();
+            await this.waitUntilCallJoined();
             if (!this.publisher) {
                 this.logger('error', 'Trying to publish audio before join is completed');
                 throw new Error(`Call not joined yet.`);
@@ -13162,6 +13673,9 @@ class Call {
                 this.logger('error', `There is no audio track in the stream to publish`);
                 return;
             }
+            if (!this.trackPublishOrder.includes(TrackType.AUDIO)) {
+                this.trackPublishOrder.push(TrackType.AUDIO);
+            }
             await this.publisher.publishStream(audioStream, audioTrack, TrackType.AUDIO);
         };
         /**
@@ -13176,7 +13690,7 @@ class Call {
         this.publishScreenShareStream = async (screenShareStream, opts = {}) => {
             // we should wait until we get a JoinResponse from the SFU,
             // otherwise we risk breaking the ICETrickle flow.
-            await this.assertCallJoined();
+            await this.waitUntilCallJoined();
             if (!this.publisher) {
                 this.logger('error', 'Trying to publish screen share before join is completed');
                 throw new Error(`Call not joined yet.`);
@@ -13186,9 +13700,15 @@ class Call {
                 this.logger('error', `There is no video track in the screen share stream to publish`);
                 return;
             }
+            if (!this.trackPublishOrder.includes(TrackType.SCREEN_SHARE)) {
+                this.trackPublishOrder.push(TrackType.SCREEN_SHARE);
+            }
             await this.publisher.publishStream(screenShareStream, screenShareTrack, TrackType.SCREEN_SHARE, opts);
             const [screenShareAudioTrack] = screenShareStream.getAudioTracks();
             if (screenShareAudioTrack) {
+                if (!this.trackPublishOrder.includes(TrackType.SCREEN_SHARE_AUDIO)) {
+                    this.trackPublishOrder.push(TrackType.SCREEN_SHARE_AUDIO);
+                }
                 await this.publisher.publishStream(screenShareStream, screenShareAudioTrack, TrackType.SCREEN_SHARE_AUDIO, opts);
             }
         };
@@ -13233,19 +13753,9 @@ class Call {
          * @param type the debounce type to use for the update.
          */
         this.updateSubscriptionsPartial = (trackType, changes, type = exports.DebounceType.SLOW) => {
-            if (trackType === 'video') {
-                this.logger('warn', `updateSubscriptionsPartial: ${trackType} is deprecated. Please switch to 'videoTrack'`);
-                trackType = 'videoTrack';
-            }
-            else if (trackType === 'screen') {
-                this.logger('warn', `updateSubscriptionsPartial: ${trackType} is deprecated. Please switch to 'screenShareTrack'`);
-                trackType = 'screenShareTrack';
-            }
             const participants = this.state.updateParticipants(Object.entries(changes).reduce((acc, [sessionId, change]) => {
-                if (change.dimension?.height) {
+                if (change.dimension) {
                     change.dimension.height = Math.ceil(change.dimension.height);
-                }
-                if (change.dimension?.width) {
                     change.dimension.width = Math.ceil(change.dimension.width);
                 }
                 const prop = trackType === 'videoTrack'
@@ -13260,9 +13770,7 @@ class Call {
                 }
                 return acc;
             }, {}));
-            if (participants) {
-                this.updateSubscriptions(participants, type);
-            }
+            this.updateSubscriptions(participants, type);
         };
         this.updateSubscriptions = (participants, type = exports.DebounceType.SLOW) => {
             const subscriptions = [];
@@ -13345,10 +13853,15 @@ class Call {
         this.updatePublishQuality = async (enabledLayers) => {
             return this.publisher?.updateVideoPublishQuality(enabledLayers);
         };
-        this.assertCallJoined = () => {
+        this.waitUntilCallJoined = () => {
+            if (this.sfuClient) {
+                // if we have an SFU client, we can wait for the join response
+                return this.sfuClient.joinResponseTask.promise;
+            }
+            // otherwise, fall back to the calling state
             return new Promise((resolve) => {
                 this.state.callingState$
-                    .pipe(rxjs.takeWhile((state) => state !== exports.CallingState.JOINED, true), rxjs.filter((s) => s === exports.CallingState.JOINED))
+                    .pipe(rxjs.takeWhile((state) => state !== exports.CallingState.JOINED, true))
                     .subscribe(() => resolve());
             });
         };
@@ -13732,14 +14245,72 @@ class Call {
          *
          * @internal
          */
-        this.applyDeviceConfig = async () => {
-            await this.initCamera({ setStatus: false }).catch((err) => {
+        this.applyDeviceConfig = async (status) => {
+            await this.initCamera({ setStatus: status }).catch((err) => {
                 this.logger('warn', 'Camera init failed', err);
             });
-            await this.initMic({ setStatus: false }).catch((err) => {
+            await this.initMic({ setStatus: status }).catch((err) => {
                 this.logger('warn', 'Mic init failed', err);
             });
         };
+        this.initCamera = async (options) => {
+            // Wait for any in progress camera operation
+            await this.camera.statusChangeSettled();
+            if (this.state.localParticipant?.videoStream ||
+                !this.permissionsContext.hasPermission('send-video')) {
+                return;
+            }
+            // Set camera direction if it's not yet set
+            if (!this.camera.state.direction && !this.camera.state.selectedDevice) {
+                let defaultDirection = 'front';
+                const backendSetting = this.state.settings?.video.camera_facing;
+                if (backendSetting) {
+                    defaultDirection = backendSetting === 'front' ? 'front' : 'back';
+                }
+                this.camera.state.setDirection(defaultDirection);
+            }
+            // Set target resolution
+            const targetResolution = this.state.settings?.video.target_resolution;
+            if (targetResolution) {
+                await this.camera.selectTargetResolution(targetResolution);
+            }
+            if (options.setStatus) {
+                // Publish already that was set before we joined
+                if (this.camera.enabled &&
+                    this.camera.state.mediaStream &&
+                    !this.publisher?.isPublishing(TrackType.VIDEO)) {
+                    await this.publishVideoStream(this.camera.state.mediaStream, {
+                        preferredCodec: this.camera.preferredCodec,
+                    });
+                }
+                // Start camera if backend config specifies, and there is no local setting
+                if (this.camera.state.status === undefined &&
+                    this.state.settings?.video.camera_default_on) {
+                    await this.camera.enable();
+                }
+            }
+        };
+        this.initMic = async (options) => {
+            // Wait for any in progress mic operation
+            await this.microphone.statusChangeSettled();
+            if (this.state.localParticipant?.audioStream ||
+                !this.permissionsContext.hasPermission('send-audio')) {
+                return;
+            }
+            if (options.setStatus) {
+                // Publish media stream that was set before we joined
+                if (this.microphone.enabled &&
+                    this.microphone.state.mediaStream &&
+                    !this.publisher?.isPublishing(TrackType.AUDIO)) {
+                    await this.publishAudioStream(this.microphone.state.mediaStream);
+                }
+                // Start mic if backend config specifies, and there is no local setting
+                if (this.microphone.state.status === undefined &&
+                    this.state.settings?.audio.mic_default_on) {
+                    await this.microphone.enable();
+                }
+            }
+        };
         /**
          * Will begin tracking the given element for visibility changes within the
          * configured viewport element (`call.setViewport`).
@@ -13854,15 +14425,15 @@ class Call {
     }
     async setup() {
         await withoutConcurrency(this.joinLeaveConcurrencyTag, async () => {
-            if (this.initialized) {
+            if (this.initialized)
                 return;
-            }
             this.leaveCallHooks.add(this.on('all', (event) => {
                 // update state with the latest event data
                 this.state.updateFromEvent(event);
             }));
-            this.leaveCallHooks.add(registerEventHandlers(this, this.state, this.dispatcher));
+            this.leaveCallHooks.add(registerEventHandlers(this, this.dispatcher));
             this.registerEffects();
+            this.registerReconnectHandlers();
             this.leaveCallHooks.add(createSubscription(this.trackSubscriptionsSubject.pipe(rxjs.debounce((v) => rxjs.timer(v.type)), rxjs.map((v) => v.data)), (subscriptions) => this.sfuClient?.updateSubscriptions(subscriptions).catch((err) => {
                 this.logger('debug', `Failed to update track subscriptions`, err);
             })));
@@ -13882,44 +14453,7 @@ class Call {
         }));
         this.leaveCallHooks.add(
         // handle the case when the user permissions are modified.
-        createSubscription(this.state.ownCapabilities$, (ownCapabilities) => {
-            // update the permission context.
-            this.permissionsContext.setPermissions(ownCapabilities);
-            if (!this.publisher)
-                return;
-            // check if the user still has publishing permissions and stop publishing if not.
-            const permissionToTrackType = {
-                [OwnCapability.SEND_AUDIO]: TrackType.AUDIO,
-                [OwnCapability.SEND_VIDEO]: TrackType.VIDEO,
-                [OwnCapability.SCREENSHARE]: TrackType.SCREEN_SHARE,
-            };
-            for (const [permission, trackType] of Object.entries(permissionToTrackType)) {
-                const hasPermission = this.permissionsContext.hasPermission(permission);
-                if (!hasPermission &&
-                    (this.publisher.isPublishing(trackType) ||
-                        this.publisher.isLive(trackType))) {
-                    // Stop tracks, then notify device manager
-                    this.stopPublish(trackType)
-                        .catch((err) => {
-                        this.logger('error', `Error stopping publish ${trackType}`, err);
-                    })
-                        .then(() => {
-                        if (trackType === TrackType.VIDEO &&
-                            this.camera.state.status === 'enabled') {
-                            this.camera
-                                .disable()
-                                .catch((err) => this.logger('error', `Error disabling camera after permission revoked`, err));
-                        }
-                        if (trackType === TrackType.AUDIO &&
-                            this.microphone.state.status === 'enabled') {
-                            this.microphone
-                                .disable()
-                                .catch((err) => this.logger('error', `Error disabling microphone after permission revoked`, err));
-                        }
-                    });
-                }
-            }
-        }));
+        createSafeAsyncSubscription(this.state.ownCapabilities$, this.handleOwnCapabilitiesUpdated));
         this.leaveCallHooks.add(
         // handles the case when the user is blocked by the call owner.
         createSubscription(this.state.blockedUserIds$, async (blockedUserIds) => {
@@ -14011,63 +14545,20 @@ class Call {
     get isCreatedByMe() {
         return this.state.createdBy?.id === this.currentUserId;
     }
-    async initCamera(options) {
-        // Wait for any in progress camera operation
-        await this.camera.statusChangeSettled();
-        if (this.state.localParticipant?.videoStream ||
-            !this.permissionsContext.hasPermission('send-video')) {
-            return;
-        }
-        // Set camera direction if it's not yet set
-        if (!this.camera.state.direction && !this.camera.state.selectedDevice) {
-            let defaultDirection = 'front';
-            const backendSetting = this.state.settings?.video.camera_facing;
-            if (backendSetting) {
-                defaultDirection = backendSetting === 'front' ? 'front' : 'back';
-            }
-            this.camera.state.setDirection(defaultDirection);
-        }
-        // Set target resolution
-        const targetResolution = this.state.settings?.video.target_resolution;
-        if (targetResolution) {
-            await this.camera.selectTargetResolution(targetResolution);
-        }
-        if (options.setStatus) {
-            // Publish already that was set before we joined
-            if (this.camera.state.status === 'enabled' &&
-                this.camera.state.mediaStream &&
-                !this.publisher?.isPublishing(TrackType.VIDEO)) {
-                await this.publishVideoStream(this.camera.state.mediaStream, {
-                    preferredCodec: this.camera.preferredCodec,
-                });
-            }
-            // Start camera if backend config specifies, and there is no local setting
-            if (this.camera.state.status === undefined &&
-                this.state.settings?.video.camera_default_on) {
-                await this.camera.enable();
-            }
-        }
-    }
-    async initMic(options) {
-        // Wait for any in progress mic operation
-        await this.microphone.statusChangeSettled();
-        if (this.state.localParticipant?.audioStream ||
-            !this.permissionsContext.hasPermission('send-audio')) {
+    /**
+     * Handles the closing of the SFU signal connection.
+     *
+     * @internal
+     * @param sfuClient the SFU client instance that was closed.
+     */
+    handleSfuSignalClose(sfuClient) {
+        this.logger('debug', '[Reconnect] SFU signal connection closed');
+        // normal close, no need to reconnect
+        if (sfuClient.isLeaving)
             return;
-        }
-        if (options.setStatus) {
-            // Publish media stream that was set before we joined
-            if (this.microphone.state.status === 'enabled' &&
-                this.microphone.state.mediaStream &&
-                !this.publisher?.isPublishing(TrackType.AUDIO)) {
-                await this.publishAudioStream(this.microphone.state.mediaStream);
-            }
-            // Start mic if backend config specifies, and there is no local setting
-            if (this.microphone.state.status === undefined &&
-                this.state.settings?.audio.mic_default_on) {
-                await this.microphone.enable();
-            }
-        }
+        this.reconnect(WebsocketReconnectStrategy.REJOIN).catch((err) => {
+            this.logger('warn', '[Reconnect] Error reconnecting', err);
+        });
     }
 }
 
@@ -14270,6 +14761,7 @@ class StableWSConnection {
                 }
             }
             if (data) {
+                data.received_at = new Date();
                 this.client.dispatchEvent(data);
             }
             this.scheduleConnectionCheck();
@@ -14610,7 +15102,7 @@ class StableWSConnection {
                 wsURL,
                 requestID: this.requestID,
             });
-            this.ws = new WebSocket(wsURL);
+            this.ws = new WebSocket$1(wsURL);
             this.ws.onopen = this.onopen.bind(this, this.wsID);
             this.ws.onclose = this.onclose.bind(this, this.wsID);
             this.ws.onerror = this.onerror.bind(this, this.wsID);
@@ -15226,6 +15718,7 @@ class StreamClient {
             const wsPromise = this.openConnection();
             this.setUserPromise = Promise.all([setTokenPromise, wsPromise]).then((result) => result[1]);
             try {
+                addConnectionEventListeners(this.updateNetworkConnectionStatus);
                 return await this.setUserPromise;
             }
             catch (err) {
@@ -15321,6 +15814,7 @@ class StreamClient {
             delete this.userID;
             this.anonymous = false;
             await this.closeConnection(timeout);
+            removeConnectionEventListeners(this.updateNetworkConnectionStatus);
             this.tokenManager.reset();
             this.connectionIdPromise = undefined;
             this.rejectConnectionId = undefined;
@@ -15340,6 +15834,7 @@ class StreamClient {
          * connectAnonymousUser - Set an anonymous user and open a WebSocket connection
          */
         this.connectAnonymousUser = async (user, tokenOrProvider) => {
+            addConnectionEventListeners(this.updateNetworkConnectionStatus);
             this.connectionIdPromise = new Promise((resolve, reject) => {
                 this.resolveConnectionId = resolve;
                 this.rejectConnectionId = reject;
@@ -15499,8 +15994,6 @@ class StreamClient {
             return data;
         };
         this.dispatchEvent = (event) => {
-            if (!event.received_at)
-                event.received_at = new Date();
             this.logger('debug', `Dispatching event: ${event.type}`, event);
             if (!this.listeners)
                 return;
@@ -15591,7 +16084,7 @@ class StreamClient {
             });
         };
         this.getUserAgent = () => {
-            const version = "1.5.0" ;
+            const version = "1.6.0-0" ;
             return (this.userAgent ||
                 `stream-video-javascript-client-${this.node ? 'node' : 'browser'}-${version}`);
         };
@@ -15657,11 +16150,15 @@ class StreamClient {
                 client_request_id,
             });
         };
-        /**
-         * creates an abort controller that will be used by the next HTTP Request.
-         */
-        this.createAbortControllerForNextRequest = () => {
-            return (this.nextRequestAbortController = new AbortController());
+        this.updateNetworkConnectionStatus = (event) => {
+            if (event.type === 'offline') {
+                this.logger('debug', 'device went offline');
+                this.dispatchEvent({ type: 'network.changed', online: false });
+            }
+            else if (event.type === 'online') {
+                this.logger('debug', 'device went online');
+                this.dispatchEvent({ type: 'network.changed', online: true });
+            }
         };
         // set the key
         this.key = key;
@@ -15691,10 +16188,14 @@ class StreamClient {
             });
         }
         this.setBaseURL(this.options.baseURL || 'https://video.stream-io-api.com/video');
-        if (typeof process !== 'undefined' && process.env.STREAM_LOCAL_TEST_RUN) {
+        if (typeof process !== 'undefined' &&
+            'env' in process &&
+            process.env.STREAM_LOCAL_TEST_RUN) {
             this.setBaseURL('http://localhost:3030/video');
         }
-        if (typeof process !== 'undefined' && process.env.STREAM_LOCAL_TEST_HOST) {
+        if (typeof process !== 'undefined' &&
+            'env' in process &&
+            process.env.STREAM_LOCAL_TEST_HOST) {
             this.setBaseURL(`http://${process.env.STREAM_LOCAL_TEST_HOST}/video`);
         }
         this.axiosInstance = axios.create({
@@ -15729,6 +16230,99 @@ class StreamVideoClient {
     constructor(apiKeyOrArgs, opts) {
         this.logLevel = 'warn';
         this.eventHandlersToUnregister = [];
+        /**
+         * Connects the given user to the client.
+         * Only one user can connect at a time, if you want to change users, call `disconnectUser` before connecting a new user.
+         * If the connection is successful, the connected user [state variable](#readonlystatestore) will be updated accordingly.
+         *
+         * @param user the user to connect.
+         * @param token a token or a function that returns a token.
+         */
+        this.connectUser = async (user, token) => {
+            if (user.type === 'anonymous') {
+                user.id = '!anon';
+                return this.connectAnonymousUser(user, token);
+            }
+            let connectUser = () => {
+                return this.streamClient.connectUser(user, token);
+            };
+            if (user.type === 'guest') {
+                connectUser = async () => {
+                    return this.streamClient.connectGuestUser(user);
+                };
+            }
+            this.connectionPromise = this.disconnectionPromise
+                ? this.disconnectionPromise.then(() => connectUser())
+                : connectUser();
+            this.connectionPromise?.finally(() => (this.connectionPromise = undefined));
+            const connectUserResponse = await this.connectionPromise;
+            // connectUserResponse will be void if connectUser called twice for the same user
+            if (connectUserResponse?.me) {
+                this.writeableStateStore.setConnectedUser(connectUserResponse.me);
+            }
+            this.eventHandlersToUnregister.push(this.on('connection.changed', (event) => {
+                if (event.online) {
+                    const callsToReWatch = this.writeableStateStore.calls
+                        .filter((call) => call.watching)
+                        .map((call) => call.cid);
+                    this.logger('info', `Rewatching calls after connection changed ${callsToReWatch.join(', ')}`);
+                    if (callsToReWatch.length > 0) {
+                        this.queryCalls({
+                            watch: true,
+                            filter_conditions: {
+                                cid: { $in: callsToReWatch },
+                            },
+                            sort: [{ field: 'cid', direction: 1 }],
+                        }).catch((err) => {
+                            this.logger('error', 'Failed to re-watch calls', err);
+                        });
+                    }
+                }
+            }));
+            this.eventHandlersToUnregister.push(this.on('call.created', (event) => {
+                const { call, members } = event;
+                if (user.id === call.created_by.id) {
+                    this.logger('warn', 'Received `call.created` sent by the current user');
+                    return;
+                }
+                this.logger('info', `New call created and registered: ${call.cid}`);
+                const newCall = new Call({
+                    streamClient: this.streamClient,
+                    type: call.type,
+                    id: call.id,
+                    members,
+                    clientStore: this.writeableStateStore,
+                });
+                newCall.state.updateFromCallResponse(call);
+                this.writeableStateStore.registerCall(newCall);
+            }));
+            this.eventHandlersToUnregister.push(this.on('call.ring', async (event) => {
+                const { call, members } = event;
+                if (user.id === call.created_by.id) {
+                    this.logger('debug', 'Received `call.ring` sent by the current user so ignoring the event');
+                    return;
+                }
+                // The call might already be tracked by the client,
+                // if `call.created` was received before `call.ring`.
+                // In that case, we cleanup the already tracked call.
+                const prevCall = this.writeableStateStore.findCall(call.type, call.id);
+                await prevCall?.leave({ reason: 'cleaning-up in call.ring' });
+                // we create a new call
+                const theCall = new Call({
+                    streamClient: this.streamClient,
+                    type: call.type,
+                    id: call.id,
+                    members,
+                    clientStore: this.writeableStateStore,
+                    ringing: true,
+                });
+                theCall.state.updateFromCallResponse(call);
+                // we fetch the latest metadata for the call from the server
+                await theCall.get();
+                this.writeableStateStore.registerCall(theCall);
+            }));
+            return connectUserResponse;
+        };
         /**
          * Disconnects the currently connected user from the client.
          *
@@ -15817,7 +16411,7 @@ class StreamVideoClient {
                     clientStore: this.writeableStateStore,
                 });
                 call.state.updateFromCallResponse(c.call);
-                await call.applyDeviceConfig();
+                await call.applyDeviceConfig(false);
                 if (data.watch) {
                     this.writeableStateStore.registerCall(call);
                 }
@@ -15861,6 +16455,17 @@ class StreamVideoClient {
                 ...(push_provider_name != null ? { push_provider_name } : {}),
             });
         };
+        /**
+         * addDevice - Adds a push device for a user.
+         *
+         * @param {string} id the device id
+         * @param {string} push_provider the push provider name (eg. apn, firebase)
+         * @param {string} push_provider_name user provided push provider name
+         * @param {string} [userID] the user id (defaults to current user)
+         */
+        this.addVoipDevice = async (id, push_provider, push_provider_name, userID) => {
+            return await this.addDevice(id, push_provider, push_provider_name, userID, true);
+        };
         /**
          * getDevices - Returns the devices associated with a current user
          * @param {string} [userID] User ID. Only works on serverside
@@ -15888,7 +16493,7 @@ class StreamVideoClient {
         this.onRingingCall = async (call_cid) => {
             // if we find the call and is already ringing, we don't need to create a new call
             // as client would have received the call.ring state because the app had WS alive when receiving push notifications
-            let call = this.readOnlyStateStore.calls.find((c) => c.cid === call_cid && c.ringing);
+            let call = this.state.calls.find((c) => c.cid === call_cid && c.ringing);
             if (!call) {
                 // if not it means that WS is not alive when receiving the push notifications and we need to fetch the call
                 const [callType, callId] = call_cid.split(':');
@@ -15929,12 +16534,13 @@ class StreamVideoClient {
         }
         setLogger(logger, logLevel);
         this.logger = getLogger(['client']);
+        const coordinatorLogger = getLogger(['coordinator']);
         if (typeof apiKeyOrArgs === 'string') {
             this.streamClient = new StreamClient(apiKeyOrArgs, {
                 persistUserOnConnectionFailure: true,
                 ...opts,
                 logLevel,
-                logger: this.logger,
+                logger: coordinatorLogger,
             });
         }
         else {
@@ -15942,12 +16548,14 @@ class StreamVideoClient {
                 persistUserOnConnectionFailure: true,
                 ...apiKeyOrArgs.options,
                 logLevel,
-                logger: this.logger,
+                logger: coordinatorLogger,
             });
             const sdkInfo = getSdkInfo();
             if (sdkInfo) {
-                this.streamClient.setUserAgent(this.streamClient.getUserAgent() +
-                    `-video-${SdkType[sdkInfo.type].toLowerCase()}-sdk-${sdkInfo.major}.${sdkInfo.minor}.${sdkInfo.patch}`);
+                const sdkName = SdkType[sdkInfo.type].toLowerCase();
+                const sdkVersion = `${sdkInfo.major}.${sdkInfo.minor}.${sdkInfo.patch}`;
+                const userAgent = this.streamClient.getUserAgent();
+                this.streamClient.setUserAgent(`${userAgent}-video-${sdkName}-sdk-${sdkVersion}`);
             }
         }
         this.writeableStateStore = new StreamVideoWriteableStateStore();
@@ -16000,110 +16608,6 @@ class StreamVideoClient {
     get state() {
         return this.readOnlyStateStore;
     }
-    /**
-     * Connects the given user to the client.
-     * Only one user can connect at a time, if you want to change users, call `disconnectUser` before connecting a new user.
-     * If the connection is successful, the connected user [state variable](#readonlystatestore) will be updated accordingly.
-     *
-     * @param user the user to connect.
-     * @param token a token or a function that returns a token.
-     */
-    async connectUser(user, token) {
-        if (user.type === 'anonymous') {
-            user.id = '!anon';
-            return this.connectAnonymousUser(user, token);
-        }
-        let connectUser = () => {
-            return this.streamClient.connectUser(user, token);
-        };
-        if (user.type === 'guest') {
-            connectUser = async () => {
-                return this.streamClient.connectGuestUser(user);
-            };
-        }
-        this.connectionPromise = this.disconnectionPromise
-            ? this.disconnectionPromise.then(() => connectUser())
-            : connectUser();
-        this.connectionPromise?.finally(() => (this.connectionPromise = undefined));
-        const connectUserResponse = await this.connectionPromise;
-        // connectUserResponse will be void if connectUser called twice for the same user
-        if (connectUserResponse?.me) {
-            this.writeableStateStore.setConnectedUser(connectUserResponse.me);
-        }
-        this.eventHandlersToUnregister.push(this.on('connection.changed', (event) => {
-            if (event.online) {
-                const callsToReWatch = this.writeableStateStore.calls
-                    .filter((call) => call.watching)
-                    .map((call) => call.cid);
-                this.logger('info', `Rewatching calls after connection changed ${callsToReWatch.join(', ')}`);
-                if (callsToReWatch.length > 0) {
-                    this.queryCalls({
-                        watch: true,
-                        filter_conditions: {
-                            cid: { $in: callsToReWatch },
-                        },
-                        sort: [{ field: 'cid', direction: 1 }],
-                    }).catch((err) => {
-                        this.logger('error', 'Failed to re-watch calls', err);
-                    });
-                }
-            }
-        }));
-        this.eventHandlersToUnregister.push(this.on('call.created', (event) => {
-            const { call, members } = event;
-            if (user.id === call.created_by.id) {
-                this.logger('warn', 'Received `call.created` sent by the current user');
-                return;
-            }
-            this.logger('info', `New call created and registered: ${call.cid}`);
-            const newCall = new Call({
-                streamClient: this.streamClient,
-                type: call.type,
-                id: call.id,
-                members,
-                clientStore: this.writeableStateStore,
-            });
-            newCall.state.updateFromCallResponse(call);
-            this.writeableStateStore.registerCall(newCall);
-        }));
-        this.eventHandlersToUnregister.push(this.on('call.ring', async (event) => {
-            const { call, members } = event;
-            if (user.id === call.created_by.id) {
-                this.logger('debug', 'Received `call.ring` sent by the current user so ignoring the event');
-                return;
-            }
-            // The call might already be tracked by the client,
-            // if `call.created` was received before `call.ring`.
-            // In that case, we cleanup the already tracked call.
-            const prevCall = this.writeableStateStore.findCall(call.type, call.id);
-            await prevCall?.leave({ reason: 'cleaning-up in call.ring' });
-            // we create a new call
-            const theCall = new Call({
-                streamClient: this.streamClient,
-                type: call.type,
-                id: call.id,
-                members,
-                clientStore: this.writeableStateStore,
-                ringing: true,
-            });
-            theCall.state.updateFromCallResponse(call);
-            // we fetch the latest metadata for the call from the server
-            await theCall.get();
-            this.writeableStateStore.registerCall(theCall);
-        }));
-        return connectUserResponse;
-    }
-    /**
-     * addDevice - Adds a push device for a user.
-     *
-     * @param {string} id the device id
-     * @param {string} push_provider the push provider name (eg. apn, firebase)
-     * @param {string} push_provider_name user provided push provider name
-     * @param {string} [userID] the user id (defaults to current user)
-     */
-    async addVoipDevice(id, push_provider, push_provider_name, userID) {
-        return await this.addDevice(id, push_provider, push_provider_name, userID, true);
-    }
 }
 StreamVideoClient._instanceMap = new Map();
 
@@ -16166,6 +16670,7 @@ exports.getAudioOutputDevices = getAudioOutputDevices;
 exports.getAudioStream = getAudioStream;
 exports.getClientDetails = getClientDetails;
 exports.getDeviceInfo = getDeviceInfo;
+exports.getLogLevel = getLogLevel;
 exports.getLogger = getLogger;
 exports.getOSInfo = getOSInfo;
 exports.getScreenShareStream = getScreenShareStream;