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

package/dist/index.browser.es.js

@@ -1,13 +1,13 @@
 import 'webrtc-adapter';
 import { MessageType, isJsonObject, typeofJsonValue, reflectionMergePartial, UnknownFieldHandler, WireType, PbLong } from '@protobuf-ts/runtime';
-import { ServiceType, stackIntercept } from '@protobuf-ts/runtime-rpc';
+import { ServiceType, stackIntercept, RpcError } from '@protobuf-ts/runtime-rpc';
 import axios, { AxiosHeaders } from 'axios';
 export { AxiosError } from 'axios';
-import { TwirpFetchTransport } from '@protobuf-ts/twirp-transport';
-import { ReplaySubject, combineLatest, BehaviorSubject, map as map$1, shareReplay, distinctUntilChanged, takeWhile, distinctUntilKeyChanged, fromEventPattern, startWith, concatMap, merge, from, fromEvent, debounceTime, pairwise, of, filter, debounce, timer } from 'rxjs';
+import { TwirpFetchTransport, TwirpErrorCode } from '@protobuf-ts/twirp-transport';
+import { ReplaySubject, combineLatest, BehaviorSubject, map as map$1, shareReplay, distinctUntilChanged, takeWhile, distinctUntilKeyChanged, fromEventPattern, startWith, concatMap, merge, from, fromEvent, debounceTime, pairwise, of, debounce, timer } from 'rxjs';
 import * as SDP from 'sdp-transform';
 import { UAParser } from 'ua-parser-js';
-import WebSocket from 'isomorphic-ws';
+import WebSocket$1 from 'isomorphic-ws';
 import { fromByteArray } from 'base64-js';
 
 /**
@@ -1014,6 +1014,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.
@@ -1027,7 +1031,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;
      */
@@ -1040,25 +1044,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 MessageType {
@@ -1860,6 +1857,7 @@ class TrackInfo$Type extends 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) {
@@ -1871,6 +1869,7 @@ class TrackInfo$Type extends MessageType {
         message.dtx = false;
         message.stereo = false;
         message.red = false;
+        message.muted = false;
         if (value !== undefined)
             reflectionMergePartial(this, message, value);
         return message;
@@ -1901,6 +1900,9 @@ class TrackInfo$Type extends 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')
@@ -1934,6 +1936,9 @@ class TrackInfo$Type extends MessageType {
         /* bool red = 9; */
         if (message.red !== false)
             writer.tag(9, WireType.Varint).bool(message.red);
+        /* bool muted = 10; */
+        if (message.muted !== false)
+            writer.tag(10, WireType.Varint).bool(message.muted);
         let u = options.writeUnknownFields;
         if (u !== false)
             (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
@@ -1945,108 +1950,6 @@ class TrackInfo$Type extends MessageType {
  */
 const TrackInfo = new TrackInfo$Type();
 // @generated message type with reflection information, may provide speed optimized methods
-class Call$Type extends 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)
-            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 ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
-            }
-        }
-        return message;
-    }
-    internalBinaryWrite(message, writer, options) {
-        /* string type = 1; */
-        if (message.type !== '')
-            writer.tag(1, WireType.LengthDelimited).string(message.type);
-        /* string id = 2; */
-        if (message.id !== '')
-            writer.tag(2, WireType.LengthDelimited).string(message.id);
-        /* string created_by_user_id = 3; */
-        if (message.createdByUserId !== '')
-            writer.tag(3, WireType.LengthDelimited).string(message.createdByUserId);
-        /* string host_user_id = 4; */
-        if (message.hostUserId !== '')
-            writer.tag(4, WireType.LengthDelimited).string(message.hostUserId);
-        /* google.protobuf.Struct custom = 5; */
-        if (message.custom)
-            Struct.internalBinaryWrite(message.custom, writer.tag(5, WireType.LengthDelimited).fork(), options).join();
-        /* google.protobuf.Timestamp created_at = 6; */
-        if (message.createdAt)
-            Timestamp.internalBinaryWrite(message.createdAt, writer.tag(6, WireType.LengthDelimited).fork(), options).join();
-        /* google.protobuf.Timestamp updated_at = 7; */
-        if (message.updatedAt)
-            Timestamp.internalBinaryWrite(message.updatedAt, writer.tag(7, WireType.LengthDelimited).fork(), options).join();
-        let u = options.writeUnknownFields;
-        if (u !== false)
-            (u == true ? 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 MessageType {
     constructor() {
         super('stream.video.sfu.models.Error', [
@@ -2440,6 +2343,108 @@ class Device$Type extends MessageType {
  */
 const Device = new Device$Type();
 // @generated message type with reflection information, may provide speed optimized methods
+class Call$Type extends 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)
+            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 ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* string type = 1; */
+        if (message.type !== '')
+            writer.tag(1, WireType.LengthDelimited).string(message.type);
+        /* string id = 2; */
+        if (message.id !== '')
+            writer.tag(2, WireType.LengthDelimited).string(message.id);
+        /* string created_by_user_id = 3; */
+        if (message.createdByUserId !== '')
+            writer.tag(3, WireType.LengthDelimited).string(message.createdByUserId);
+        /* string host_user_id = 4; */
+        if (message.hostUserId !== '')
+            writer.tag(4, WireType.LengthDelimited).string(message.hostUserId);
+        /* google.protobuf.Struct custom = 5; */
+        if (message.custom)
+            Struct.internalBinaryWrite(message.custom, writer.tag(5, WireType.LengthDelimited).fork(), options).join();
+        /* google.protobuf.Timestamp created_at = 6; */
+        if (message.createdAt)
+            Timestamp.internalBinaryWrite(message.createdAt, writer.tag(6, WireType.LengthDelimited).fork(), options).join();
+        /* google.protobuf.Timestamp updated_at = 7; */
+        if (message.updatedAt)
+            Timestamp.internalBinaryWrite(message.updatedAt, writer.tag(7, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? 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 MessageType {
     constructor() {
         super('stream.video.sfu.models.CallGrants', [
@@ -3970,6 +3975,13 @@ class SfuEvent$Type extends MessageType {
                 oneof: 'eventPayload',
                 T: () => ParticipantUpdated,
             },
+            {
+                no: 25,
+                name: 'participant_migration_complete',
+                kind: 'message',
+                oneof: 'eventPayload',
+                T: () => ParticipantMigrationComplete,
+            },
         ]);
     }
     create(value) {
@@ -4104,6 +4116,12 @@ class SfuEvent$Type extends 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')
@@ -4176,6 +4194,9 @@ class SfuEvent$Type extends MessageType {
         /* stream.video.sfu.event.ParticipantUpdated participant_updated = 24; */
         if (message.eventPayload.oneofKind === 'participantUpdated')
             ParticipantUpdated.internalBinaryWrite(message.eventPayload.participantUpdated, writer.tag(24, 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, WireType.LengthDelimited).fork(), options).join();
         let u = options.writeUnknownFields;
         if (u !== false)
             (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
@@ -4187,6 +4208,31 @@ class SfuEvent$Type extends MessageType {
  */
 const SfuEvent = new SfuEvent$Type();
 // @generated message type with reflection information, may provide speed optimized methods
+class ParticipantMigrationComplete$Type extends MessageType {
+    constructor() {
+        super('stream.video.sfu.event.ParticipantMigrationComplete', []);
+    }
+    create(value) {
+        const message = globalThis.Object.create(this.messagePrototype);
+        if (value !== undefined)
+            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 ? 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 MessageType {
     constructor() {
         super('stream.video.sfu.event.PinsChanged', [
@@ -4437,6 +4483,13 @@ class SfuRequest$Type extends MessageType {
                 oneof: 'requestPayload',
                 T: () => HealthCheckRequest,
             },
+            {
+                no: 3,
+                name: 'leave_call_request',
+                kind: 'message',
+                oneof: 'requestPayload',
+                T: () => LeaveCallRequest,
+            },
         ]);
     }
     create(value) {
@@ -4463,6 +4516,12 @@ class SfuRequest$Type extends 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')
@@ -4481,6 +4540,9 @@ class SfuRequest$Type extends MessageType {
         /* stream.video.sfu.event.HealthCheckRequest health_check_request = 2; */
         if (message.requestPayload.oneofKind === 'healthCheckRequest')
             HealthCheckRequest.internalBinaryWrite(message.requestPayload.healthCheckRequest, writer.tag(2, 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, WireType.LengthDelimited).fork(), options).join();
         let u = options.writeUnknownFields;
         if (u !== false)
             (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
@@ -4492,19 +4554,74 @@ class SfuRequest$Type extends MessageType {
  */
 const SfuRequest = new SfuRequest$Type();
 // @generated message type with reflection information, may provide speed optimized methods
-class HealthCheckRequest$Type extends MessageType {
+class LeaveCallRequest$Type extends 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)
             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 ? 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, WireType.LengthDelimited).string(message.sessionId);
+        /* string reason = 2; */
+        if (message.reason !== '')
+            writer.tag(2, WireType.LengthDelimited).string(message.reason);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? 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 MessageType {
+    constructor() {
+        super('stream.video.sfu.event.HealthCheckRequest', []);
+    }
+    create(value) {
+        const message = globalThis.Object.create(this.messagePrototype);
+        if (value !== undefined)
+            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)
@@ -4767,6 +4884,12 @@ class JoinRequest$Type extends MessageType {
                 kind: 'scalar',
                 T: 8 /*ScalarType.BOOL*/,
             },
+            {
+                no: 7,
+                name: 'reconnect_details',
+                kind: 'message',
+                T: () => ReconnectDetails,
+            },
         ]);
     }
     create(value) {
@@ -4796,12 +4919,15 @@ class JoinRequest$Type extends 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')
@@ -4826,12 +4952,15 @@ class JoinRequest$Type extends MessageType {
         /* stream.video.sfu.models.ClientDetails client_details = 4; */
         if (message.clientDetails)
             ClientDetails.internalBinaryWrite(message.clientDetails, writer.tag(4, 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, WireType.LengthDelimited).fork(), options).join();
-        /* bool fast_reconnect = 6; */
+        /* bool fast_reconnect = 6 [deprecated = true]; */
         if (message.fastReconnect !== false)
             writer.tag(6, WireType.Varint).bool(message.fastReconnect);
+        /* stream.video.sfu.event.ReconnectDetails reconnect_details = 7; */
+        if (message.reconnectDetails)
+            ReconnectDetails.internalBinaryWrite(message.reconnectDetails, writer.tag(7, WireType.LengthDelimited).fork(), options).join();
         let u = options.writeUnknownFields;
         if (u !== false)
             (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
@@ -4843,6 +4972,129 @@ class JoinRequest$Type extends MessageType {
  */
 const JoinRequest = new JoinRequest$Type();
 // @generated message type with reflection information, may provide speed optimized methods
+class ReconnectDetails$Type extends 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)
+            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 ? 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, 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, 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, WireType.LengthDelimited).fork(), options).join();
+        /* uint32 reconnect_attempt = 5; */
+        if (message.reconnectAttempt !== 0)
+            writer.tag(5, WireType.Varint).uint32(message.reconnectAttempt);
+        /* string from_sfu_id = 6; */
+        if (message.fromSfuId !== '')
+            writer.tag(6, WireType.LengthDelimited).string(message.fromSfuId);
+        /* string previous_session_id = 7; */
+        if (message.previousSessionId !== '')
+            writer.tag(7, WireType.LengthDelimited).string(message.previousSessionId);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? 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 MessageType {
     constructor() {
         super('stream.video.sfu.event.Migration', [
@@ -4928,11 +5180,18 @@ class JoinResponse$Type extends 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)
             reflectionMergePartial(this, message, value);
         return message;
@@ -4948,6 +5207,9 @@ class JoinResponse$Type extends 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')
@@ -4966,6 +5228,11 @@ class JoinResponse$Type extends MessageType {
         /* bool reconnected = 2; */
         if (message.reconnected !== false)
             writer.tag(2, WireType.Varint).bool(message.reconnected);
+        /* int32 fast_reconnect_deadline_seconds = 3; */
+        if (message.fastReconnectDeadlineSeconds !== 0)
+            writer
+                .tag(3, WireType.Varint)
+                .int32(message.fastReconnectDeadlineSeconds);
         let u = options.writeUnknownFields;
         if (u !== false)
             (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
@@ -6166,12 +6433,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,
@@ -6297,6 +6567,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.
  *
@@ -6310,68 +6591,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);
@@ -6380,6 +6789,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 RpcError &&
+                err.code === TwirpErrorCode[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)) {
@@ -6452,6 +6892,7 @@ const sfuEventKinds = {
     pinsUpdated: undefined,
     callEnded: undefined,
     participantUpdated: undefined,
+    participantMigrationComplete: undefined,
 };
 const isSfuEvent = (eventName) => {
     return Object.prototype.hasOwnProperty.call(sfuEventKinds, eventName);
@@ -6460,12 +6901,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;
@@ -6507,7 +6948,6 @@ class IceTrickleBuffer {
     constructor() {
         this.subscriberCandidates = new ReplaySubject();
         this.publisherCandidates = new ReplaySubject();
-        this.logger = getLogger(['sfu-client']);
         this.push = (iceTrickle) => {
             if (iceTrickle.peerType === PeerType.SUBSCRIBER) {
                 this.subscriberCandidates.next(iceTrickle);
@@ -6516,7 +6956,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);
             }
         };
     }
@@ -6535,72 +6976,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 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,
@@ -6623,7 +6998,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) => {
@@ -6637,12 +7011,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;
     });
@@ -6717,6 +7086,10 @@ const findOptimalScreenSharingLayers = (videoTrack, preferences, defaultMaxBitra
     ];
 };
 
+const ensureExhausted = (x, message) => {
+    getLogger(['helpers'])('warn', message, x);
+};
+
 const trackTypeToParticipantStreamKey = (trackType) => {
     switch (trackType) {
         case TrackType.SCREEN_SHARE:
@@ -6730,8 +7103,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) => {
@@ -6745,8 +7117,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;
     }
 };
 
@@ -7266,6 +7651,11 @@ class CallState {
         this.anonymousParticipantCountSubject = new BehaviorSubject(0);
         this.participantsSubject = new BehaviorSubject([]);
         this.callStatsReportSubject = new 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.
@@ -7455,7 +7845,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) {
@@ -7514,6 +7904,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.
          *
@@ -7538,6 +7963,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: VisibilityState.UNKNOWN,
+                            screenShareTrack: 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));
@@ -8249,13 +8711,79 @@ const enableHighQualityAudio = (sdp, trackMid, maxBitrate = 510000) => {
     return SDP.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 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
@@ -8276,8 +8804,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,
@@ -8291,7 +8820,7 @@ class Publisher {
          * This is needed because some browsers (Firefox) don't reliably report
          * trackId and `mid` parameters.
          *
-         * @private
+         * @internal
          */
         this.transceiverInitOrder = [];
         this.trackKindMapping = {
@@ -8323,7 +8852,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) => {
@@ -8335,10 +8864,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.
@@ -8365,7 +8906,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);
@@ -8381,21 +8922,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.
@@ -8410,17 +8948,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);
                     }
                 }
             }
@@ -8469,31 +9010,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),
@@ -8515,7 +9042,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') {
@@ -8524,15 +9051,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;
@@ -8551,18 +9078,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;
                         }
@@ -8572,10 +9099,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);
             }
         };
         /**
@@ -8599,7 +9126,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
@@ -8608,7 +9135,7 @@ class Publisher {
                 peerType: PeerType.PUBLISHER_UNSPECIFIED,
             })
                 .catch((err) => {
-                logger$3('warn', `ICETrickle failed`, err);
+                this.logger('warn', `ICETrickle failed`, err);
             });
         };
         /**
@@ -8619,38 +9146,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.
@@ -8662,59 +9174,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.parse(sdp);
             const media = parsedSdp.media.find((m) => {
                 return (m.type === track.kind &&
@@ -8722,17 +9237,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
@@ -8744,7 +9265,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
@@ -8757,7 +9279,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 || '',
@@ -8779,10 +9301,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,
                 };
             });
         };
@@ -8791,44 +9314,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 !== 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 === 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'
@@ -8837,28 +9342,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 {
     /**
@@ -8880,8 +9386,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.
@@ -8902,10 +9409,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
@@ -8923,76 +9442,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;
@@ -9011,36 +9471,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);
@@ -9053,7 +9519,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
@@ -9062,11 +9528,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,
@@ -9077,7 +9543,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();
@@ -9090,63 +9556,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 === CallingState.RECONNECTING)
+                return;
             // do nothing when ICE is restarting
             if (this.isIceRestarting)
                 return;
-            const hasNetworkConnection = this.state.callingState !== 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?.();
             });
         });
@@ -9154,8 +9608,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) => {
@@ -9173,140 +9627,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.
@@ -9314,133 +9673,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);
@@ -9456,53 +9906,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;
     }
 }
 /**
@@ -9515,45 +9949,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,
+        })),
+    };
 };
 
 /**
@@ -9708,9 +10112,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,
         });
@@ -9726,6 +10131,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.
@@ -9747,12 +10163,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);
@@ -9773,11 +10190,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: VisibilityState.UNKNOWN,
                 screenShareTrack: VisibilityState.UNKNOWN,
@@ -9813,12 +10231,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 {
@@ -9834,9 +10254,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 {
@@ -9847,6 +10269,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.
@@ -9895,12 +10336,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),
@@ -9944,48 +10386,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.
  *
@@ -10265,6 +10665,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);
@@ -10948,7 +11349,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) => {
@@ -11201,6 +11602,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.
      */
@@ -11323,7 +11730,7 @@ class InputMediaDeviceManager {
         await this.applySettingsToStream();
     }
     async applySettingsToStream() {
-        if (this.state.status === 'enabled') {
+        if (this.enabled) {
             await this.muteStream();
             await this.unmuteStream();
         }
@@ -11460,19 +11867,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 === 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;
@@ -11765,7 +12175,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();
@@ -12069,7 +12479,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
@@ -12095,7 +12505,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) => {
@@ -12477,9 +12887,17 @@ class Call {
          */
         this.dispatcher = new Dispatcher();
         this.trackSubscriptionsSubject = new BehaviorSubject({ type: 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');
         /**
@@ -12489,6 +12907,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.
@@ -12539,9 +12993,8 @@ class Call {
                     throw new Error('Cannot leave call that has already been left.');
                 }
                 if (callingState === 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;
@@ -12563,14 +13016,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(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();
@@ -12610,7 +13064,7 @@ class Call {
                 this.watching = true;
                 this.clientStore.registerCall(this);
             }
-            await this.applyDeviceConfig();
+            await this.applyDeviceConfig(false);
             return response;
         };
         /**
@@ -12632,7 +13086,7 @@ class Call {
                 this.watching = true;
                 this.clientStore.registerCall(this);
             }
-            await this.applyDeviceConfig();
+            await this.applyDeviceConfig(false);
             return response;
         };
         /**
@@ -12688,253 +13142,174 @@ class Call {
             await this.setup();
             const callingState = this.state.callingState;
             if ([CallingState.JOINED, 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 === CallingState.MIGRATING;
-            const isReconnecting = callingState === CallingState.RECONNECTING;
-            this.state.setCallingState(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(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 === CallingState.MIGRATING ||
-                    currentState === CallingState.RECONNECTING) {
-                    // prevent parallel reconnection attempts
-                    return;
-                }
-                this.reconnectAttempts++;
-                this.state.setCallingState(strategy === 'migrate'
-                    ? CallingState.MIGRATING
-                    : 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(CallingState.RECONNECTING_FAILED);
-                        });
-                    }
-                    else {
-                        this.logger('error', '[Rejoin]: Reconnect attempts exceeded. Giving up...');
-                        this.state.setCallingState(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 === CallingState.OFFLINE ||
-                    currentCallingState === 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(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(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(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;
@@ -12945,23 +13320,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,
@@ -12970,129 +13345,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 !== CallingState.JOINED &&
+                    this.state.callingState !== CallingState.LEFT);
+            });
+        };
+        /**
+         * Initiates the reconnection flow with the "fast" strategy.
+         * @internal
+         */
+        this.reconnectFast = async () => {
+            this.reconnectStrategy = WebsocketReconnectStrategy.FAST;
+            this.state.setCallingState(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(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(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(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: VisibilityState.UNKNOWN,
-                                screenShareTrack: 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(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, 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(CallingState.OFFLINE);
                 }
                 else {
-                    this.logger('error', `[Rejoin]: Rejoin failed for ${this.reconnectAttempts} times. Giving up.`);
-                    this.state.setCallingState(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, DebounceType.FAST);
         };
         /**
          * Starts publishing the given video stream to the call.
@@ -13107,7 +13615,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.`);
@@ -13117,6 +13625,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);
         };
         /**
@@ -13131,7 +13642,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.`);
@@ -13141,6 +13652,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);
         };
         /**
@@ -13155,7 +13669,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.`);
@@ -13165,9 +13679,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);
             }
         };
@@ -13212,19 +13732,9 @@ class Call {
          * @param type the debounce type to use for the update.
          */
         this.updateSubscriptionsPartial = (trackType, changes, type = 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'
@@ -13239,9 +13749,7 @@ class Call {
                 }
                 return acc;
             }, {}));
-            if (participants) {
-                this.updateSubscriptions(participants, type);
-            }
+            this.updateSubscriptions(participants, type);
         };
         this.updateSubscriptions = (participants, type = DebounceType.SLOW) => {
             const subscriptions = [];
@@ -13324,10 +13832,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(takeWhile((state) => state !== CallingState.JOINED, true), filter((s) => s === CallingState.JOINED))
+                    .pipe(takeWhile((state) => state !== CallingState.JOINED, true))
                     .subscribe(() => resolve());
             });
         };
@@ -13711,14 +14224,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`).
@@ -13833,15 +14404,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(debounce((v) => timer(v.type)), map$1((v) => v.data)), (subscriptions) => this.sfuClient?.updateSubscriptions(subscriptions).catch((err) => {
                 this.logger('debug', `Failed to update track subscriptions`, err);
             })));
@@ -13861,44 +14432,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) => {
@@ -13990,63 +14524,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);
+        });
     }
 }
 
@@ -14251,6 +14742,7 @@ class StableWSConnection {
                 }
             }
             if (data) {
+                data.received_at = new Date();
                 this.client.dispatchEvent(data);
             }
             this.scheduleConnectionCheck();
@@ -14591,7 +15083,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);
@@ -15207,6 +15699,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) {
@@ -15302,6 +15795,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;
@@ -15321,6 +15815,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;
@@ -15480,8 +15975,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;
@@ -15572,7 +16065,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}`);
         };
@@ -15638,11 +16131,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;
@@ -15672,10 +16169,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({
@@ -15710,6 +16211,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.
          *
@@ -15798,7 +16392,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);
                 }
@@ -15842,6 +16436,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
@@ -15869,7 +16474,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(':');
@@ -15910,12 +16515,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 {
@@ -15923,12 +16529,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();
@@ -15981,112 +16589,8 @@ 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();
 
-export { AudioSettingsRequestDefaultDeviceEnum, AudioSettingsResponseDefaultDeviceEnum, BlockListOptionsBehaviorEnum, browsers as Browsers, Call, CallState, CallType, CallTypes, CallingState, CameraManager, CameraManagerState, ChannelConfigWithInfoAutomodBehaviorEnum, ChannelConfigWithInfoAutomodEnum, ChannelConfigWithInfoBlocklistBehaviorEnum, CreateDeviceRequestPushProviderEnum, DebounceType, DynascaleManager, ErrorFromResponse, InputMediaDeviceManager, InputMediaDeviceManagerState, MicrophoneManager, MicrophoneManagerState, NoiseCancellationSettingsModeEnum, OwnCapability, RecordSettingsRequestModeEnum, RecordSettingsRequestQualityEnum, rxUtils as RxUtils, ScreenShareManager, ScreenShareState, events as SfuEvents, models as SfuModels, SpeakerManager, SpeakerState, StreamSfuClient, StreamVideoClient, StreamVideoReadOnlyStateStore, StreamVideoWriteableStateStore, TranscriptionSettingsRequestModeEnum, TranscriptionSettingsResponseModeEnum, VideoSettingsRequestCameraFacingEnum, VideoSettingsResponseCameraFacingEnum, ViewportTracker, VisibilityState, checkIfAudioOutputChangeSupported, combineComparators, conditional, createSoundDetector, defaultSortPreset, descending, deviceIds$, disposeOfMediaStream, dominantSpeaker, getAudioBrowserPermission, getAudioDevices, getAudioOutputDevices, getAudioStream, getClientDetails, getDeviceInfo, getLogger, getOSInfo, getScreenShareStream, getSdkInfo, getVideoBrowserPermission, getVideoDevices, getVideoStream, getWebRTCInfo, hasAudio, hasScreenShare, hasScreenShareAudio, hasVideo, isPinned, livestreamOrAudioRoomSortPreset, logLevels, logToConsole, name, noopComparator, paginatedLayoutSortPreset, pinned, publishingAudio, publishingVideo, reactionType, role, screenSharing, setDeviceInfo, setLogLevel, setLogger, setOSInfo, setSdkInfo, setWebRTCInfo, speakerLayoutSortPreset, speaking };
+export { AudioSettingsRequestDefaultDeviceEnum, AudioSettingsResponseDefaultDeviceEnum, BlockListOptionsBehaviorEnum, browsers as Browsers, Call, CallState, CallType, CallTypes, CallingState, CameraManager, CameraManagerState, ChannelConfigWithInfoAutomodBehaviorEnum, ChannelConfigWithInfoAutomodEnum, ChannelConfigWithInfoBlocklistBehaviorEnum, CreateDeviceRequestPushProviderEnum, DebounceType, DynascaleManager, ErrorFromResponse, InputMediaDeviceManager, InputMediaDeviceManagerState, MicrophoneManager, MicrophoneManagerState, NoiseCancellationSettingsModeEnum, OwnCapability, RecordSettingsRequestModeEnum, RecordSettingsRequestQualityEnum, rxUtils as RxUtils, ScreenShareManager, ScreenShareState, events as SfuEvents, models as SfuModels, SpeakerManager, SpeakerState, StreamSfuClient, StreamVideoClient, StreamVideoReadOnlyStateStore, StreamVideoWriteableStateStore, TranscriptionSettingsRequestModeEnum, TranscriptionSettingsResponseModeEnum, VideoSettingsRequestCameraFacingEnum, VideoSettingsResponseCameraFacingEnum, ViewportTracker, VisibilityState, checkIfAudioOutputChangeSupported, combineComparators, conditional, createSoundDetector, defaultSortPreset, descending, deviceIds$, disposeOfMediaStream, dominantSpeaker, getAudioBrowserPermission, getAudioDevices, getAudioOutputDevices, getAudioStream, getClientDetails, getDeviceInfo, getLogLevel, getLogger, getOSInfo, getScreenShareStream, getSdkInfo, getVideoBrowserPermission, getVideoDevices, getVideoStream, getWebRTCInfo, hasAudio, hasScreenShare, hasScreenShareAudio, hasVideo, isPinned, livestreamOrAudioRoomSortPreset, logLevels, logToConsole, name, noopComparator, paginatedLayoutSortPreset, pinned, publishingAudio, publishingVideo, reactionType, role, screenSharing, setDeviceInfo, setLogLevel, setLogger, setOSInfo, setSdkInfo, setWebRTCInfo, speakerLayoutSortPreset, speaking };
 //# sourceMappingURL=index.browser.es.js.map