livekit-client 1.0.0 → 1.0.3

package/dist/livekit-client.esm.mjs

@@ -5200,6 +5200,91 @@ const ParticipantInfo = {
 
 };
 
+function createBaseSimulcastCodecInfo() {
+  return {
+    mimeType: '',
+    mid: '',
+    cid: ''
+  };
+}
+
+const SimulcastCodecInfo = {
+  encode(message) {
+    let writer = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : minimal.Writer.create();
+
+    if (message.mimeType !== '') {
+      writer.uint32(10).string(message.mimeType);
+    }
+
+    if (message.mid !== '') {
+      writer.uint32(18).string(message.mid);
+    }
+
+    if (message.cid !== '') {
+      writer.uint32(26).string(message.cid);
+    }
+
+    return writer;
+  },
+
+  decode(input, length) {
+    const reader = input instanceof minimal.Reader ? input : new minimal.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseSimulcastCodecInfo();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.mimeType = reader.string();
+          break;
+
+        case 2:
+          message.mid = reader.string();
+          break;
+
+        case 3:
+          message.cid = reader.string();
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromJSON(object) {
+    return {
+      mimeType: isSet$1(object.mimeType) ? String(object.mimeType) : '',
+      mid: isSet$1(object.mid) ? String(object.mid) : '',
+      cid: isSet$1(object.cid) ? String(object.cid) : ''
+    };
+  },
+
+  toJSON(message) {
+    const obj = {};
+    message.mimeType !== undefined && (obj.mimeType = message.mimeType);
+    message.mid !== undefined && (obj.mid = message.mid);
+    message.cid !== undefined && (obj.cid = message.cid);
+    return obj;
+  },
+
+  fromPartial(object) {
+    var _a, _b, _c;
+
+    const message = createBaseSimulcastCodecInfo();
+    message.mimeType = (_a = object.mimeType) !== null && _a !== void 0 ? _a : '';
+    message.mid = (_b = object.mid) !== null && _b !== void 0 ? _b : '';
+    message.cid = (_c = object.cid) !== null && _c !== void 0 ? _c : '';
+    return message;
+  }
+
+};
+
 function createBaseTrackInfo() {
   return {
     sid: '',
@@ -5213,7 +5298,8 @@ function createBaseTrackInfo() {
     source: 0,
     layers: [],
     mimeType: '',
-    mid: ''
+    mid: '',
+    codecs: []
   };
 }
 
@@ -5269,6 +5355,10 @@ const TrackInfo = {
       writer.uint32(98).string(message.mid);
     }
 
+    for (const v of message.codecs) {
+      SimulcastCodecInfo.encode(v, writer.uint32(106).fork()).ldelim();
+    }
+
     return writer;
   },
 
@@ -5329,6 +5419,10 @@ const TrackInfo = {
           message.mid = reader.string();
           break;
 
+        case 13:
+          message.codecs.push(SimulcastCodecInfo.decode(reader, reader.uint32()));
+          break;
+
         default:
           reader.skipType(tag & 7);
           break;
@@ -5351,7 +5445,8 @@ const TrackInfo = {
       source: isSet$1(object.source) ? trackSourceFromJSON(object.source) : 0,
       layers: Array.isArray(object === null || object === void 0 ? void 0 : object.layers) ? object.layers.map(e => VideoLayer.fromJSON(e)) : [],
       mimeType: isSet$1(object.mimeType) ? String(object.mimeType) : '',
-      mid: isSet$1(object.mid) ? String(object.mid) : ''
+      mid: isSet$1(object.mid) ? String(object.mid) : '',
+      codecs: Array.isArray(object === null || object === void 0 ? void 0 : object.codecs) ? object.codecs.map(e => SimulcastCodecInfo.fromJSON(e)) : []
     };
   },
 
@@ -5375,11 +5470,18 @@ const TrackInfo = {
 
     message.mimeType !== undefined && (obj.mimeType = message.mimeType);
     message.mid !== undefined && (obj.mid = message.mid);
+
+    if (message.codecs) {
+      obj.codecs = message.codecs.map(e => e ? SimulcastCodecInfo.toJSON(e) : undefined);
+    } else {
+      obj.codecs = [];
+    }
+
     return obj;
   },
 
   fromPartial(object) {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o;
 
     const message = createBaseTrackInfo();
     message.sid = (_a = object.sid) !== null && _a !== void 0 ? _a : '';
@@ -5394,6 +5496,7 @@ const TrackInfo = {
     message.layers = ((_k = object.layers) === null || _k === void 0 ? void 0 : _k.map(e => VideoLayer.fromPartial(e))) || [];
     message.mimeType = (_l = object.mimeType) !== null && _l !== void 0 ? _l : '';
     message.mid = (_m = object.mid) !== null && _m !== void 0 ? _m : '';
+    message.codecs = ((_o = object.codecs) === null || _o === void 0 ? void 0 : _o.map(e => SimulcastCodecInfo.fromPartial(e))) || [];
     return message;
   }
 
@@ -6381,6 +6484,42 @@ function streamStateToJSON(object) {
       return 'UNKNOWN';
   }
 }
+var CandidateProtocol;
+
+(function (CandidateProtocol) {
+  CandidateProtocol[CandidateProtocol["UDP"] = 0] = "UDP";
+  CandidateProtocol[CandidateProtocol["TCP"] = 1] = "TCP";
+  CandidateProtocol[CandidateProtocol["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+})(CandidateProtocol || (CandidateProtocol = {}));
+
+function candidateProtocolFromJSON(object) {
+  switch (object) {
+    case 0:
+    case 'UDP':
+      return CandidateProtocol.UDP;
+
+    case 1:
+    case 'TCP':
+      return CandidateProtocol.TCP;
+
+    case -1:
+    case 'UNRECOGNIZED':
+    default:
+      return CandidateProtocol.UNRECOGNIZED;
+  }
+}
+function candidateProtocolToJSON(object) {
+  switch (object) {
+    case CandidateProtocol.UDP:
+      return 'UDP';
+
+    case CandidateProtocol.TCP:
+      return 'TCP';
+
+    default:
+      return 'UNKNOWN';
+  }
+}
 
 function createBaseSignalRequest() {
   return {
@@ -6814,6 +6953,91 @@ const SignalResponse = {
 
 };
 
+function createBaseSimulcastCodec() {
+  return {
+    codec: '',
+    cid: '',
+    enableSimulcastLayers: false
+  };
+}
+
+const SimulcastCodec = {
+  encode(message) {
+    let writer = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : minimal.Writer.create();
+
+    if (message.codec !== '') {
+      writer.uint32(10).string(message.codec);
+    }
+
+    if (message.cid !== '') {
+      writer.uint32(18).string(message.cid);
+    }
+
+    if (message.enableSimulcastLayers === true) {
+      writer.uint32(24).bool(message.enableSimulcastLayers);
+    }
+
+    return writer;
+  },
+
+  decode(input, length) {
+    const reader = input instanceof minimal.Reader ? input : new minimal.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseSimulcastCodec();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.codec = reader.string();
+          break;
+
+        case 2:
+          message.cid = reader.string();
+          break;
+
+        case 3:
+          message.enableSimulcastLayers = reader.bool();
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromJSON(object) {
+    return {
+      codec: isSet(object.codec) ? String(object.codec) : '',
+      cid: isSet(object.cid) ? String(object.cid) : '',
+      enableSimulcastLayers: isSet(object.enableSimulcastLayers) ? Boolean(object.enableSimulcastLayers) : false
+    };
+  },
+
+  toJSON(message) {
+    const obj = {};
+    message.codec !== undefined && (obj.codec = message.codec);
+    message.cid !== undefined && (obj.cid = message.cid);
+    message.enableSimulcastLayers !== undefined && (obj.enableSimulcastLayers = message.enableSimulcastLayers);
+    return obj;
+  },
+
+  fromPartial(object) {
+    var _a, _b, _c;
+
+    const message = createBaseSimulcastCodec();
+    message.codec = (_a = object.codec) !== null && _a !== void 0 ? _a : '';
+    message.cid = (_b = object.cid) !== null && _b !== void 0 ? _b : '';
+    message.enableSimulcastLayers = (_c = object.enableSimulcastLayers) !== null && _c !== void 0 ? _c : false;
+    return message;
+  }
+
+};
+
 function createBaseAddTrackRequest() {
   return {
     cid: '',
@@ -6824,7 +7048,8 @@ function createBaseAddTrackRequest() {
     muted: false,
     disableDtx: false,
     source: 0,
-    layers: []
+    layers: [],
+    simulcastCodecs: []
   };
 }
 
@@ -6868,6 +7093,10 @@ const AddTrackRequest = {
       VideoLayer.encode(v, writer.uint32(74).fork()).ldelim();
     }
 
+    for (const v of message.simulcastCodecs) {
+      SimulcastCodec.encode(v, writer.uint32(82).fork()).ldelim();
+    }
+
     return writer;
   },
 
@@ -6916,6 +7145,10 @@ const AddTrackRequest = {
           message.layers.push(VideoLayer.decode(reader, reader.uint32()));
           break;
 
+        case 10:
+          message.simulcastCodecs.push(SimulcastCodec.decode(reader, reader.uint32()));
+          break;
+
         default:
           reader.skipType(tag & 7);
           break;
@@ -6935,7 +7168,8 @@ const AddTrackRequest = {
       muted: isSet(object.muted) ? Boolean(object.muted) : false,
       disableDtx: isSet(object.disableDtx) ? Boolean(object.disableDtx) : false,
       source: isSet(object.source) ? trackSourceFromJSON(object.source) : 0,
-      layers: Array.isArray(object === null || object === void 0 ? void 0 : object.layers) ? object.layers.map(e => VideoLayer.fromJSON(e)) : []
+      layers: Array.isArray(object === null || object === void 0 ? void 0 : object.layers) ? object.layers.map(e => VideoLayer.fromJSON(e)) : [],
+      simulcastCodecs: Array.isArray(object === null || object === void 0 ? void 0 : object.simulcastCodecs) ? object.simulcastCodecs.map(e => SimulcastCodec.fromJSON(e)) : []
     };
   },
 
@@ -6956,11 +7190,17 @@ const AddTrackRequest = {
       obj.layers = [];
     }
 
+    if (message.simulcastCodecs) {
+      obj.simulcastCodecs = message.simulcastCodecs.map(e => e ? SimulcastCodec.toJSON(e) : undefined);
+    } else {
+      obj.simulcastCodecs = [];
+    }
+
     return obj;
   },
 
   fromPartial(object) {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
 
     const message = createBaseAddTrackRequest();
     message.cid = (_a = object.cid) !== null && _a !== void 0 ? _a : '';
@@ -6972,6 +7212,7 @@ const AddTrackRequest = {
     message.disableDtx = (_g = object.disableDtx) !== null && _g !== void 0 ? _g : false;
     message.source = (_h = object.source) !== null && _h !== void 0 ? _h : 0;
     message.layers = ((_j = object.layers) === null || _j === void 0 ? void 0 : _j.map(e => VideoLayer.fromPartial(e))) || [];
+    message.simulcastCodecs = ((_k = object.simulcastCodecs) === null || _k === void 0 ? void 0 : _k.map(e => SimulcastCodec.fromPartial(e))) || [];
     return message;
   }
 
@@ -8512,10 +8753,90 @@ const SubscribedQuality = {
 
 };
 
+function createBaseSubscribedCodec() {
+  return {
+    codec: '',
+    qualities: []
+  };
+}
+
+const SubscribedCodec = {
+  encode(message) {
+    let writer = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : minimal.Writer.create();
+
+    if (message.codec !== '') {
+      writer.uint32(10).string(message.codec);
+    }
+
+    for (const v of message.qualities) {
+      SubscribedQuality.encode(v, writer.uint32(18).fork()).ldelim();
+    }
+
+    return writer;
+  },
+
+  decode(input, length) {
+    const reader = input instanceof minimal.Reader ? input : new minimal.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseSubscribedCodec();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.codec = reader.string();
+          break;
+
+        case 2:
+          message.qualities.push(SubscribedQuality.decode(reader, reader.uint32()));
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromJSON(object) {
+    return {
+      codec: isSet(object.codec) ? String(object.codec) : '',
+      qualities: Array.isArray(object === null || object === void 0 ? void 0 : object.qualities) ? object.qualities.map(e => SubscribedQuality.fromJSON(e)) : []
+    };
+  },
+
+  toJSON(message) {
+    const obj = {};
+    message.codec !== undefined && (obj.codec = message.codec);
+
+    if (message.qualities) {
+      obj.qualities = message.qualities.map(e => e ? SubscribedQuality.toJSON(e) : undefined);
+    } else {
+      obj.qualities = [];
+    }
+
+    return obj;
+  },
+
+  fromPartial(object) {
+    var _a, _b;
+
+    const message = createBaseSubscribedCodec();
+    message.codec = (_a = object.codec) !== null && _a !== void 0 ? _a : '';
+    message.qualities = ((_b = object.qualities) === null || _b === void 0 ? void 0 : _b.map(e => SubscribedQuality.fromPartial(e))) || [];
+    return message;
+  }
+
+};
+
 function createBaseSubscribedQualityUpdate() {
   return {
     trackSid: '',
-    subscribedQualities: []
+    subscribedQualities: [],
+    subscribedCodecs: []
   };
 }
 
@@ -8531,6 +8852,10 @@ const SubscribedQualityUpdate = {
       SubscribedQuality.encode(v, writer.uint32(18).fork()).ldelim();
     }
 
+    for (const v of message.subscribedCodecs) {
+      SubscribedCodec.encode(v, writer.uint32(26).fork()).ldelim();
+    }
+
     return writer;
   },
 
@@ -8551,6 +8876,10 @@ const SubscribedQualityUpdate = {
           message.subscribedQualities.push(SubscribedQuality.decode(reader, reader.uint32()));
           break;
 
+        case 3:
+          message.subscribedCodecs.push(SubscribedCodec.decode(reader, reader.uint32()));
+          break;
+
         default:
           reader.skipType(tag & 7);
           break;
@@ -8563,7 +8892,8 @@ const SubscribedQualityUpdate = {
   fromJSON(object) {
     return {
       trackSid: isSet(object.trackSid) ? String(object.trackSid) : '',
-      subscribedQualities: Array.isArray(object === null || object === void 0 ? void 0 : object.subscribedQualities) ? object.subscribedQualities.map(e => SubscribedQuality.fromJSON(e)) : []
+      subscribedQualities: Array.isArray(object === null || object === void 0 ? void 0 : object.subscribedQualities) ? object.subscribedQualities.map(e => SubscribedQuality.fromJSON(e)) : [],
+      subscribedCodecs: Array.isArray(object === null || object === void 0 ? void 0 : object.subscribedCodecs) ? object.subscribedCodecs.map(e => SubscribedCodec.fromJSON(e)) : []
     };
   },
 
@@ -8577,15 +8907,22 @@ const SubscribedQualityUpdate = {
       obj.subscribedQualities = [];
     }
 
+    if (message.subscribedCodecs) {
+      obj.subscribedCodecs = message.subscribedCodecs.map(e => e ? SubscribedCodec.toJSON(e) : undefined);
+    } else {
+      obj.subscribedCodecs = [];
+    }
+
     return obj;
   },
 
   fromPartial(object) {
-    var _a, _b;
+    var _a, _b, _c;
 
     const message = createBaseSubscribedQualityUpdate();
     message.trackSid = (_a = object.trackSid) !== null && _a !== void 0 ? _a : '';
     message.subscribedQualities = ((_b = object.subscribedQualities) === null || _b === void 0 ? void 0 : _b.map(e => SubscribedQuality.fromPartial(e))) || [];
+    message.subscribedCodecs = ((_c = object.subscribedCodecs) === null || _c === void 0 ? void 0 : _c.map(e => SubscribedCodec.fromPartial(e))) || [];
     return message;
   }
 
@@ -9056,7 +9393,8 @@ function createBaseSimulateScenario() {
     speakerUpdate: undefined,
     nodeFailure: undefined,
     migration: undefined,
-    serverLeave: undefined
+    serverLeave: undefined,
+    switchCandidateProtocol: undefined
   };
 }
 
@@ -9080,6 +9418,10 @@ const SimulateScenario = {
       writer.uint32(32).bool(message.serverLeave);
     }
 
+    if (message.switchCandidateProtocol !== undefined) {
+      writer.uint32(40).int32(message.switchCandidateProtocol);
+    }
+
     return writer;
   },
 
@@ -9108,6 +9450,10 @@ const SimulateScenario = {
           message.serverLeave = reader.bool();
           break;
 
+        case 5:
+          message.switchCandidateProtocol = reader.int32();
+          break;
+
         default:
           reader.skipType(tag & 7);
           break;
@@ -9122,7 +9468,8 @@ const SimulateScenario = {
       speakerUpdate: isSet(object.speakerUpdate) ? Number(object.speakerUpdate) : undefined,
       nodeFailure: isSet(object.nodeFailure) ? Boolean(object.nodeFailure) : undefined,
       migration: isSet(object.migration) ? Boolean(object.migration) : undefined,
-      serverLeave: isSet(object.serverLeave) ? Boolean(object.serverLeave) : undefined
+      serverLeave: isSet(object.serverLeave) ? Boolean(object.serverLeave) : undefined,
+      switchCandidateProtocol: isSet(object.switchCandidateProtocol) ? candidateProtocolFromJSON(object.switchCandidateProtocol) : undefined
     };
   },
 
@@ -9132,17 +9479,19 @@ const SimulateScenario = {
     message.nodeFailure !== undefined && (obj.nodeFailure = message.nodeFailure);
     message.migration !== undefined && (obj.migration = message.migration);
     message.serverLeave !== undefined && (obj.serverLeave = message.serverLeave);
+    message.switchCandidateProtocol !== undefined && (obj.switchCandidateProtocol = message.switchCandidateProtocol !== undefined ? candidateProtocolToJSON(message.switchCandidateProtocol) : undefined);
     return obj;
   },
 
   fromPartial(object) {
-    var _a, _b, _c, _d;
+    var _a, _b, _c, _d, _e;
 
     const message = createBaseSimulateScenario();
     message.speakerUpdate = (_a = object.speakerUpdate) !== null && _a !== void 0 ? _a : undefined;
     message.nodeFailure = (_b = object.nodeFailure) !== null && _b !== void 0 ? _b : undefined;
     message.migration = (_c = object.migration) !== null && _c !== void 0 ? _c : undefined;
     message.serverLeave = (_d = object.serverLeave) !== null && _d !== void 0 ? _d : undefined;
+    message.switchCandidateProtocol = (_e = object.switchCandidateProtocol) !== null && _e !== void 0 ? _e : undefined;
     return message;
   }
 
@@ -9462,6 +9811,11 @@ var RoomEvent;
    */
 
   RoomEvent["ParticipantPermissionsChanged"] = "participantPermissionsChanged";
+  /**
+   * Signal connected, can publish tracks.
+   */
+
+  RoomEvent["SignalConnected"] = "signalConnected";
 })(RoomEvent || (RoomEvent = {}));
 
 var ParticipantEvent;
@@ -9704,83 +10058,10 @@ function computeBitrate(currentStats, prevStats) {
   return (bytesNow - bytesPrev) * 8 * 1000 / (currentStats.timestamp - prevStats.timestamp);
 }
 
-const defaultId = 'default';
-class DeviceManager {
-  static getInstance() {
-    if (this.instance === undefined) {
-      this.instance = new DeviceManager();
-    }
-
-    return this.instance;
-  }
-
-  async getDevices(kind) {
-    let requestPermissions = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
-    let devices = await navigator.mediaDevices.enumerateDevices();
-
-    if (requestPermissions) {
-      const isDummyDeviceOrEmpty = devices.length === 0 || devices.some(device => {
-        const noLabel = device.label === '';
-        const isRelevant = kind ? device.kind === kind : true;
-        return noLabel && isRelevant;
-      });
-
-      if (isDummyDeviceOrEmpty) {
-        const permissionsToAcquire = {
-          video: kind !== 'audioinput' && kind !== 'audiooutput',
-          audio: kind !== 'videoinput'
-        };
-        const stream = await navigator.mediaDevices.getUserMedia(permissionsToAcquire);
-        devices = await navigator.mediaDevices.enumerateDevices();
-        stream.getTracks().forEach(track => {
-          track.stop();
-        });
-      }
-    }
-
-    if (kind) {
-      devices = devices.filter(device => device.kind === kind);
-    } // Chrome returns 'default' devices, we would filter them out, but put the default
-    // device at first
-    // we would only do this if there are more than 1 device though
-
-
-    if (devices.length > 1 && devices[0].deviceId === defaultId) {
-      // find another device with matching group id, and move that to 0
-      const defaultDevice = devices[0];
-
-      for (let i = 1; i < devices.length; i += 1) {
-        if (devices[i].groupId === defaultDevice.groupId) {
-          const temp = devices[0];
-          devices[0] = devices[i];
-          devices[i] = temp;
-          break;
-        }
-      }
-
-      return devices.filter(device => device !== defaultDevice);
-    }
-
-    return devices;
-  }
-
-  async normalizeDeviceId(kind, deviceId, groupId) {
-    if (deviceId !== defaultId) {
-      return deviceId;
-    } // resolve actual device id if it's 'default': Chrome returns it when no
-    // device has been chosen
-
-
-    const devices = await this.getDevices(kind);
-    const device = devices.find(d => d.groupId === groupId && d.deviceId !== defaultId);
-    return device === null || device === void 0 ? void 0 : device.deviceId;
-  }
-
-}
-DeviceManager.mediaDeviceKinds = ['audioinput', 'audiooutput', 'videoinput'];
+var version$1 = "1.0.3";
 
-const version = '1.0.0';
-const protocolVersion = 7;
+const version = version$1;
+const protocolVersion = 8;
 
 const separator = '|';
 function unpackStreamId(packed) {
@@ -9887,6 +10168,81 @@ function getEmptyAudioStreamTrack() {
   return emptyAudioStreamTrack;
 }
 
+const defaultId = 'default';
+class DeviceManager {
+  static getInstance() {
+    if (this.instance === undefined) {
+      this.instance = new DeviceManager();
+    }
+
+    return this.instance;
+  }
+
+  async getDevices(kind) {
+    let requestPermissions = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+    let devices = await navigator.mediaDevices.enumerateDevices();
+
+    if (requestPermissions) {
+      const isDummyDeviceOrEmpty = devices.length === 0 || devices.some(device => {
+        const noLabel = device.label === '';
+        const isRelevant = kind ? device.kind === kind : true;
+        return noLabel && isRelevant;
+      });
+
+      if (isDummyDeviceOrEmpty) {
+        const permissionsToAcquire = {
+          video: kind !== 'audioinput' && kind !== 'audiooutput',
+          audio: kind !== 'videoinput'
+        };
+        const stream = await navigator.mediaDevices.getUserMedia(permissionsToAcquire);
+        devices = await navigator.mediaDevices.enumerateDevices();
+        stream.getTracks().forEach(track => {
+          track.stop();
+        });
+      }
+    }
+
+    if (kind) {
+      devices = devices.filter(device => device.kind === kind);
+    } // Chrome returns 'default' devices, we would filter them out, but put the default
+    // device at first
+    // we would only do this if there are more than 1 device though
+
+
+    if (devices.length > 1 && devices[0].deviceId === defaultId) {
+      // find another device with matching group id, and move that to 0
+      const defaultDevice = devices[0];
+
+      for (let i = 1; i < devices.length; i += 1) {
+        if (devices[i].groupId === defaultDevice.groupId) {
+          const temp = devices[0];
+          devices[0] = devices[i];
+          devices[i] = temp;
+          break;
+        }
+      }
+
+      return devices.filter(device => device !== defaultDevice);
+    }
+
+    return devices;
+  }
+
+  async normalizeDeviceId(kind, deviceId, groupId) {
+    if (deviceId !== defaultId) {
+      return deviceId;
+    } // resolve actual device id if it's 'default': Chrome returns it when no
+    // device has been chosen
+
+
+    const devices = await this.getDevices(kind);
+    const device = devices.find(d => d.groupId === groupId && d.deviceId !== defaultId);
+    return device === null || device === void 0 ? void 0 : device.deviceId;
+  }
+
+}
+DeviceManager.mediaDeviceKinds = ['audioinput', 'audiooutput', 'videoinput'];
+
 var events = {exports: {}};
 
 var R = typeof Reflect === 'object' ? Reflect : null;
@@ -10332,6 +10688,7 @@ function eventTargetAgnosticAddListener(emitter, name, listener, flags) {
   }
 }
 
+const BACKGROUND_REACTION_DELAY = 5000; // keep old audio elements when detached, we would re-use them since on iOS
 // Safari tracks which audio elements have been "blessed" by the user.
 
 const recycledElements = [];
@@ -10340,10 +10697,25 @@ class Track extends events.exports.EventEmitter {
     super();
     this.attachedElements = [];
     this.isMuted = false;
+    /**
+     * indicates current state of stream
+     */
+
+    this.streamState = Track.StreamState.Active;
     this._currentBitrate = 0;
 
     this.appVisibilityChangedListener = () => {
-      this.handleAppVisibilityChanged();
+      if (this.backgroundTimeout) {
+        clearTimeout(this.backgroundTimeout);
+      } // delay app visibility update if it goes to hidden
+      // update immediately if it comes back to focus
+
+
+      if (document.visibilityState === 'hidden') {
+        this.backgroundTimeout = setTimeout(() => this.handleAppVisibilityChanged(), BACKGROUND_REACTION_DELAY);
+      } else {
+        this.handleAppVisibilityChanged();
+      }
     };
 
     this.kind = kind;
@@ -10769,7 +11141,11 @@ class LocalTrack extends Track {
 
     track.addEventListener('ended', this.handleEnded);
     livekitLogger.debug('replace MediaStreamTrack');
-    await this.sender.replaceTrack(track);
+
+    if (this.sender) {
+      await this.sender.replaceTrack(track);
+    }
+
     this._mediaStreamTrack = track;
     this.attachedElements.forEach(el => {
       attachToElement(track, el);
@@ -10779,10 +11155,6 @@ class LocalTrack extends Track {
   }
 
   async restart(constraints) {
-    if (!this.sender) {
-      throw new TrackInvalidError('unable to restart an unpublished track');
-    }
-
     if (!constraints) {
       constraints = this.constraints;
     }
@@ -10816,7 +11188,12 @@ class LocalTrack extends Track {
     const newTrack = mediaStream.getTracks()[0];
     newTrack.addEventListener('ended', this.handleEnded);
     livekitLogger.debug('re-acquired MediaStreamTrack');
-    await this.sender.replaceTrack(newTrack);
+
+    if (this.sender) {
+      // Track can be restarted after it's unpublished
+      await this.sender.replaceTrack(newTrack);
+    }
+
     this._mediaStreamTrack = newTrack;
     this.attachedElements.forEach(el => {
       attachToElement(newTrack, el);
@@ -11090,6 +11467,10 @@ class LocalAudioTrack extends LocalTrack {
 
 
   startMonitor() {
+    if (!isWeb()) {
+      return;
+    }
+
     setTimeout(() => {
       this.monitorSender();
     }, monitorFrequency);
@@ -11136,6 +11517,7 @@ class LocalAudioTrack extends LocalTrack {
 class LocalVideoTrack extends LocalTrack {
   constructor(mediaTrack, constraints) {
     super(mediaTrack, Track.Kind.Video, constraints);
+    this.simulcastCodecs = new Map();
 
     this.monitorSender = async () => {
       if (!this.sender) {
@@ -11187,7 +11569,13 @@ class LocalVideoTrack extends LocalTrack {
   startMonitor(signalClient) {
     var _a;
 
-    this.signalClient = signalClient; // save original encodings
+    this.signalClient = signalClient;
+
+    if (!isWeb()) {
+      return;
+    } // save original encodings
+    // TODO : merge simulcast tracks stats
+
 
     const params = (_a = this.sender) === null || _a === void 0 ? void 0 : _a.getParameters();
 
@@ -11205,6 +11593,11 @@ class LocalVideoTrack extends LocalTrack {
 
     this._mediaStreamTrack.getConstraints();
 
+    this.simulcastCodecs.forEach(trackInfo => {
+      trackInfo.mediaStreamTrack.stop();
+      trackInfo.sender = undefined;
+    });
+    this.simulcastCodecs.clear();
     super.stop();
   }
 
@@ -11252,7 +11645,7 @@ class LocalVideoTrack extends LocalTrack {
           bytesSent: v.bytesSent,
           framesSent: v.framesSent,
           timestamp: v.timestamp,
-          rid: (_a = v.rid) !== null && _a !== void 0 ? _a : '',
+          rid: (_a = v.rid) !== null && _a !== void 0 ? _a : v.id,
           retransmittedPacketsSent: v.retransmittedPacketsSent,
           qualityLimitationReason: v.qualityLimitationReason,
           qualityLimitationResolutionChanges: v.qualityLimitationResolutionChanges
@@ -11314,6 +11707,58 @@ class LocalVideoTrack extends LocalTrack {
 
     await this.restart(constraints);
   }
+
+  addSimulcastTrack(codec, encodings) {
+    if (this.simulcastCodecs.has(codec)) {
+      throw new Error("".concat(codec, " already added"));
+    }
+
+    const simulcastCodecInfo = {
+      codec,
+      mediaStreamTrack: this.mediaStreamTrack.clone(),
+      sender: undefined,
+      encodings
+    };
+    this.simulcastCodecs.set(codec, simulcastCodecInfo);
+    return simulcastCodecInfo;
+  }
+
+  setSimulcastTrackSender(codec, sender) {
+    const simulcastCodecInfo = this.simulcastCodecs.get(codec);
+
+    if (!simulcastCodecInfo) {
+      return;
+    }
+
+    simulcastCodecInfo.sender = sender;
+  }
+  /**
+   * @internal
+   * Sets codecs that should be publishing
+   */
+
+
+  async setPublishingCodecs(codecs) {
+    livekitLogger.debug('setting publishing codecs', codecs);
+
+    for await (const codec of codecs) {
+      if (this.codec === codec.codec) {
+        await this.setPublishingLayers(codec.qualities);
+      } else {
+        const simulcastCodecInfo = this.simulcastCodecs.get(codec.codec);
+        livekitLogger.debug("try setPublishingCodec for ".concat(codec.codec), simulcastCodecInfo);
+
+        if (!simulcastCodecInfo || !simulcastCodecInfo.sender) {
+          return;
+        }
+
+        if (simulcastCodecInfo.encodings) {
+          livekitLogger.debug("try setPublishingLayersForSender ".concat(codec.codec));
+          await setPublishingLayersForSender(simulcastCodecInfo.sender, simulcastCodecInfo.encodings, codec.qualities);
+        }
+      }
+    }
+  }
   /**
    * @internal
    * Sets layers that should be publishing
@@ -11327,77 +11772,87 @@ class LocalVideoTrack extends LocalTrack {
       return;
     }
 
-    const params = this.sender.getParameters();
-    const {
-      encodings
-    } = params;
+    await setPublishingLayersForSender(this.sender, this.encodings, qualities);
+  }
 
-    if (!encodings) {
-      return;
-    }
+  async handleAppVisibilityChanged() {
+    await super.handleAppVisibilityChanged();
+    if (!isMobile()) return;
 
-    if (encodings.length !== this.encodings.length) {
-      livekitLogger.warn('cannot set publishing layers, encodings mismatch');
-      return;
+    if (this.isInBackground && this.source === Track.Source.Camera) {
+      this._mediaStreamTrack.enabled = false;
     }
+  }
 
-    let hasChanged = false;
-    encodings.forEach((encoding, idx) => {
-      var _a;
-
-      let rid = (_a = encoding.rid) !== null && _a !== void 0 ? _a : '';
+}
 
-      if (rid === '') {
-        rid = 'q';
-      }
+async function setPublishingLayersForSender(sender, senderEncodings, qualities) {
+  livekitLogger.debug('setPublishingLayersForSender', {
+    sender,
+    qualities,
+    senderEncodings
+  });
+  const params = sender.getParameters();
+  const {
+    encodings
+  } = params;
 
-      const quality = videoQualityForRid(rid);
-      const subscribedQuality = qualities.find(q => q.quality === quality);
+  if (!encodings) {
+    return;
+  }
 
-      if (!subscribedQuality) {
-        return;
-      }
+  if (encodings.length !== senderEncodings.length) {
+    livekitLogger.warn('cannot set publishing layers, encodings mismatch');
+    return;
+  }
 
-      if (encoding.active !== subscribedQuality.enabled) {
-        hasChanged = true;
-        encoding.active = subscribedQuality.enabled;
-        livekitLogger.debug("setting layer ".concat(subscribedQuality.quality, " to ").concat(encoding.active ? 'enabled' : 'disabled')); // FireFox does not support setting encoding.active to false, so we
-        // have a workaround of lowering its bitrate and resolution to the min.
+  let hasChanged = false;
+  encodings.forEach((encoding, idx) => {
+    var _a;
 
-        if (isFireFox()) {
-          if (subscribedQuality.enabled) {
-            encoding.scaleResolutionDownBy = this.encodings[idx].scaleResolutionDownBy;
-            encoding.maxBitrate = this.encodings[idx].maxBitrate;
-            /* @ts-ignore */
+    let rid = (_a = encoding.rid) !== null && _a !== void 0 ? _a : '';
 
-            encoding.maxFrameRate = this.encodings[idx].maxFrameRate;
-          } else {
-            encoding.scaleResolutionDownBy = 4;
-            encoding.maxBitrate = 10;
-            /* @ts-ignore */
+    if (rid === '') {
+      rid = 'q';
+    }
 
-            encoding.maxFrameRate = 2;
-          }
-        }
-      }
-    });
+    const quality = videoQualityForRid(rid);
+    const subscribedQuality = qualities.find(q => q.quality === quality);
 
-    if (hasChanged) {
-      params.encodings = encodings;
-      await this.sender.setParameters(params);
+    if (!subscribedQuality) {
+      return;
     }
-  }
 
-  async handleAppVisibilityChanged() {
-    await super.handleAppVisibilityChanged();
-    if (!isMobile()) return;
+    if (encoding.active !== subscribedQuality.enabled) {
+      hasChanged = true;
+      encoding.active = subscribedQuality.enabled;
+      livekitLogger.debug("setting layer ".concat(subscribedQuality.quality, " to ").concat(encoding.active ? 'enabled' : 'disabled')); // FireFox does not support setting encoding.active to false, so we
+      // have a workaround of lowering its bitrate and resolution to the min.
 
-    if (this.isInBackground && this.source === Track.Source.Camera) {
-      this._mediaStreamTrack.enabled = false;
+      if (isFireFox()) {
+        if (subscribedQuality.enabled) {
+          encoding.scaleResolutionDownBy = senderEncodings[idx].scaleResolutionDownBy;
+          encoding.maxBitrate = senderEncodings[idx].maxBitrate;
+          /* @ts-ignore */
+
+          encoding.maxFrameRate = senderEncodings[idx].maxFrameRate;
+        } else {
+          encoding.scaleResolutionDownBy = 4;
+          encoding.maxBitrate = 10;
+          /* @ts-ignore */
+
+          encoding.maxFrameRate = 2;
+        }
+      }
     }
-  }
+  });
 
+  if (hasChanged) {
+    params.encodings = encodings;
+    await sender.setParameters(params);
+  }
 }
+
 function videoQualityForRid(rid) {
   switch (rid) {
     case 'f':
@@ -11448,7 +11903,6 @@ function videoLayersFromEncodings(width, height, encodings) {
 class RemoteTrack extends Track {
   constructor(mediaTrack, sid, kind, receiver) {
     super(mediaTrack, kind);
-    this.streamState = Track.StreamState.Active;
     this.sid = sid;
     this.receiver = receiver;
   }
@@ -11657,21 +12111,6 @@ class RemoteVideoTrack extends RemoteTrack {
       }, monitorFrequency);
     };
 
-    this.handleVisibilityChanged = entry => {
-      const {
-        target,
-        isIntersecting
-      } = entry;
-      const elementInfo = this.elementInfos.find(info => info.element === target);
-
-      if (elementInfo) {
-        elementInfo.visible = isIntersecting;
-        elementInfo.visibilityChangedAt = Date.now();
-      }
-
-      this.updateVisibility();
-    };
-
     this.debouncedHandleResize = r(() => {
       this.updateDimensions();
     }, REACTION_DELAY);
@@ -11718,23 +12157,55 @@ class RemoteVideoTrack extends RemoteTrack {
 
 
     if (this.adaptiveStreamSettings && this.elementInfos.find(info => info.element === element) === undefined) {
-      this.elementInfos.push({
-        element,
-        visible: true // default visible
+      const elementInfo = new HTMLElementInfo(element);
+      this.observeElementInfo(elementInfo);
+    }
 
-      });
-      element.handleResize = this.debouncedHandleResize;
-      element.handleVisibilityChanged = this.handleVisibilityChanged;
-      getIntersectionObserver().observe(element);
-      getResizeObserver().observe(element); // trigger the first resize update cycle
+    this.hasUsedAttach = true;
+    return element;
+  }
+  /**
+   * Observe an ElementInfo for changes when adaptive streaming.
+   * @param elementInfo
+   * @internal
+   */
+
+
+  observeElementInfo(elementInfo) {
+    if (this.adaptiveStreamSettings && this.elementInfos.find(info => info === elementInfo) === undefined) {
+      elementInfo.handleResize = () => {
+        this.debouncedHandleResize();
+      };
+
+      elementInfo.handleVisibilityChanged = () => {
+        this.updateVisibility();
+      };
+
+      this.elementInfos.push(elementInfo);
+      elementInfo.observe(); // trigger the first resize update cycle
       // if the tab is backgrounded, the initial resize event does not fire until
       // the tab comes into focus for the first time.
 
       this.debouncedHandleResize();
+      this.updateVisibility();
     }
+  }
+  /**
+   * Stop observing an ElementInfo for changes.
+   * @param elementInfo
+   * @internal
+   */
 
-    this.hasUsedAttach = true;
-    return element;
+
+  stopObservingElementInfo(elementInfo) {
+    const stopElementInfos = this.elementInfos.filter(info => info === elementInfo);
+
+    for (const info of stopElementInfos) {
+      info.stopObserving();
+    }
+
+    this.elementInfos = this.elementInfos.filter(info => info !== elementInfo);
+    this.updateVisibility();
   }
 
   detach(element) {
@@ -11753,6 +12224,14 @@ class RemoteVideoTrack extends RemoteTrack {
 
     return detachedElements;
   }
+  /** @internal */
+
+
+  getDecoderImplementation() {
+    var _a;
+
+    return (_a = this.prevStats) === null || _a === void 0 ? void 0 : _a.decoderImplementation;
+  }
 
   async getReceiverStats() {
     if (!this.receiver) {
@@ -11777,7 +12256,8 @@ class RemoteVideoTrack extends RemoteTrack {
           nackCount: v.nackCount,
           jitter: v.jitter,
           timestamp: v.timestamp,
-          bytesReceived: v.bytesReceived
+          bytesReceived: v.bytesReceived,
+          decoderImplementation: v.decoderImplementation
         };
       }
     });
@@ -11785,24 +12265,28 @@ class RemoteVideoTrack extends RemoteTrack {
   }
 
   stopObservingElement(element) {
-    var _a, _b;
+    const stopElementInfos = this.elementInfos.filter(info => info.element === element);
+
+    for (const info of stopElementInfos) {
+      info.stopObserving();
+    }
 
-    (_a = getIntersectionObserver()) === null || _a === void 0 ? void 0 : _a.unobserve(element);
-    (_b = getResizeObserver()) === null || _b === void 0 ? void 0 : _b.unobserve(element);
     this.elementInfos = this.elementInfos.filter(info => info.element !== element);
   }
 
   async handleAppVisibilityChanged() {
     await super.handleAppVisibilityChanged();
-    if (!this.isAdaptiveStream) return; // on desktop don't pause when tab is backgrounded
-
-    if (!isMobile()) return;
+    if (!this.isAdaptiveStream) return;
     this.updateVisibility();
   }
 
   updateVisibility() {
+    var _a, _b;
+
     const lastVisibilityChange = this.elementInfos.reduce((prev, info) => Math.max(prev, info.visibilityChangedAt || 0), 0);
-    const isVisible = this.elementInfos.some(info => info.visible) && !this.isInBackground;
+    const backgroundPause = ((_b = (_a = this.adaptiveStreamSettings) === null || _a === void 0 ? void 0 : _a.pauseVideoInBackground) !== null && _b !== void 0 ? _b : true // default to true
+    ) ? this.isInBackground : false;
+    const isVisible = this.elementInfos.some(info => info.visible) && !backgroundPause;
 
     if (this.lastVisible === isVisible) {
       return;
@@ -11829,8 +12313,8 @@ class RemoteVideoTrack extends RemoteTrack {
     for (const info of this.elementInfos) {
       const pixelDensity = (_b = (_a = this.adaptiveStreamSettings) === null || _a === void 0 ? void 0 : _a.pixelDensity) !== null && _b !== void 0 ? _b : 1;
       const pixelDensityValue = pixelDensity === 'screen' ? window.devicePixelRatio : pixelDensity;
-      const currentElementWidth = info.element.clientWidth * pixelDensityValue;
-      const currentElementHeight = info.element.clientHeight * pixelDensityValue;
+      const currentElementWidth = info.width() * pixelDensityValue;
+      const currentElementHeight = info.height() * pixelDensityValue;
 
       if (currentElementWidth + currentElementHeight > maxWidth + maxHeight) {
         maxWidth = currentElementWidth;
@@ -11851,6 +12335,59 @@ class RemoteVideoTrack extends RemoteTrack {
 
 }
 
+class HTMLElementInfo {
+  constructor(element) {
+    let visible = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+
+    this.onVisibilityChanged = entry => {
+      var _a;
+
+      const {
+        target,
+        isIntersecting
+      } = entry;
+
+      if (target === this.element) {
+        this.visible = isIntersecting;
+        this.visibilityChangedAt = Date.now();
+        (_a = this.handleVisibilityChanged) === null || _a === void 0 ? void 0 : _a.call(this);
+      }
+    };
+
+    this.element = element;
+    this.visible = visible;
+    this.visibilityChangedAt = 0;
+  }
+
+  width() {
+    return this.element.clientWidth;
+  }
+
+  height() {
+    return this.element.clientWidth;
+  }
+
+  observe() {
+    this.element.handleResize = () => {
+      var _a;
+
+      (_a = this.handleResize) === null || _a === void 0 ? void 0 : _a.call(this);
+    };
+
+    this.element.handleVisibilityChanged = this.onVisibilityChanged;
+    getIntersectionObserver().observe(this.element);
+    getResizeObserver().observe(this.element);
+  }
+
+  stopObserving() {
+    var _a, _b;
+
+    (_a = getIntersectionObserver()) === null || _a === void 0 ? void 0 : _a.unobserve(this.element);
+    (_b = getResizeObserver()) === null || _b === void 0 ? void 0 : _b.unobserve(this.element);
+  }
+
+}
+
 class TrackPublication extends events.exports.EventEmitter {
   constructor(kind, id, name) {
     super();
@@ -12830,6 +13367,7 @@ class RemoteParticipant extends Participant {
     super.addTrackPublication(publication); // register action events
 
     publication.on(TrackEvent.UpdateSettings, settings => {
+      livekitLogger.debug('send update settings', settings);
       this.signalClient.sendUpdateTrackSettings(settings);
     });
     publication.on(TrackEvent.UpdateSubscription, sub => {
@@ -13067,13 +13605,25 @@ class RemoteParticipant extends Participant {
 
 }
 
+const compatibleCodecForSVC = 'vp8';
 class LocalParticipant extends Participant {
   /** @internal */
   constructor(sid, identity, engine, options) {
     super(sid, identity);
     this.pendingPublishing = new Set();
+    this.participantTrackPermissions = [];
+    this.allParticipantsAllowedToSubscribe = true;
+
+    this.updateTrackSubscriptionPermissions = () => {
+      livekitLogger.debug('updating track subscription permissions', {
+        allParticipantsAllowed: this.allParticipantsAllowedToSubscribe,
+        participantTrackPermissions: this.participantTrackPermissions
+      });
+      this.engine.client.sendUpdateSubscriptionPermissions(this.allParticipantsAllowedToSubscribe, this.participantTrackPermissions.map(p => trackPermissionToProto(p)));
+    };
     /** @internal */
 
+
     this.onTrackUnmuted = track => {
       this.onTrackMuted(track, track.isUpstreamPaused);
     }; // when the local track changes in mute status, we'll notify server as such
@@ -13105,7 +13655,7 @@ class LocalParticipant extends Participant {
     };
 
     this.handleSubscribedQualityUpdate = update => {
-      var _a, _b;
+      var _a, _b, _c;
 
       if (!((_a = this.roomOptions) === null || _a === void 0 ? void 0 : _a.dynacast)) {
         return;
@@ -13121,7 +13671,11 @@ class LocalParticipant extends Participant {
         return;
       }
 
-      (_b = pub.videoTrack) === null || _b === void 0 ? void 0 : _b.setPublishingLayers(update.subscribedQualities);
+      if (update.subscribedCodecs.length > 0) {
+        (_b = pub.videoTrack) === null || _b === void 0 ? void 0 : _b.setPublishingCodecs(update.subscribedCodecs);
+      } else if (update.subscribedQualities.length > 0) {
+        (_c = pub.videoTrack) === null || _c === void 0 ? void 0 : _c.setPublishingLayers(update.subscribedQualities);
+      }
     };
 
     this.handleLocalTrackUnpublished = unpublished => {
@@ -13138,7 +13692,10 @@ class LocalParticipant extends Participant {
       this.unpublishTrack(track.track);
     };
 
-    this.onTrackUnpublish = track => {
+    this.handleTrackEnded = track => {
+      livekitLogger.debug('unpublishing local track due to TrackEnded', {
+        track: track.sid
+      });
       this.unpublishTrack(track);
     };
 
@@ -13164,6 +13721,7 @@ class LocalParticipant extends Participant {
 
     this.engine.client.onSubscribedQualityUpdate = this.handleSubscribedQualityUpdate;
     this.engine.client.onLocalTrackUnpublished = this.handleLocalTrackUnpublished;
+    this.engine.on(EngineEvent.Connected, this.updateTrackSubscriptionPermissions).on(EngineEvent.Restarted, this.updateTrackSubscriptionPermissions).on(EngineEvent.Resumed, this.updateTrackSubscriptionPermissions);
   }
 
   get lastCameraError() {
@@ -13506,7 +14064,7 @@ class LocalParticipant extends Participant {
 
     track.on(TrackEvent.Muted, this.onTrackMuted);
     track.on(TrackEvent.Unmuted, this.onTrackUnmuted);
-    track.on(TrackEvent.Ended, this.onTrackUnpublish);
+    track.on(TrackEvent.Ended, this.handleTrackEnded);
     track.on(TrackEvent.UpstreamPaused, this.onTrackUpstreamPaused);
     track.on(TrackEvent.UpstreamResumed, this.onTrackUpstreamResumed); // create track publication from track
 
@@ -13521,6 +14079,8 @@ class LocalParticipant extends Participant {
     }); // compute encodings and layers for video
 
     let encodings;
+    let simEncodings;
+    let simulcastTracks;
 
     if (track.kind === Track.Kind.Video) {
       // TODO: support react native, which doesn't expose getSettings
@@ -13529,21 +14089,32 @@ class LocalParticipant extends Participant {
       const height = (_e = settings.height) !== null && _e !== void 0 ? _e : (_f = track.dimensions) === null || _f === void 0 ? void 0 : _f.height; // width and height should be defined for video
 
       req.width = width !== null && width !== void 0 ? width : 0;
-      req.height = height !== null && height !== void 0 ? height : 0; // for svc codecs, disable simulcast and enable scalability L3T3
-      // by default
-
-      if (track instanceof LocalVideoTrack) {
-        if ((opts === null || opts === void 0 ? void 0 : opts.videoCodec) === 'vp9' || (opts === null || opts === void 0 ? void 0 : opts.videoCodec) === 'av1') {
-          opts.simulcast = false;
-          opts.scalabilityMode = (_g = opts.scalabilityMode) !== null && _g !== void 0 ? _g : 'L3T3';
-        } else {
-          // other codecs, unset scalability
-          opts.scalabilityMode = undefined;
-        }
+      req.height = height !== null && height !== void 0 ? height : 0; // for svc codecs, disable simulcast and use vp8 for backup codec
+
+      if (track instanceof LocalVideoTrack && ((opts === null || opts === void 0 ? void 0 : opts.videoCodec) === 'vp9' || (opts === null || opts === void 0 ? void 0 : opts.videoCodec) === 'av1')) {
+        // set scalabilityMode to 'L3T3' by default
+        opts.scalabilityMode = (_g = opts.scalabilityMode) !== null && _g !== void 0 ? _g : 'L3T3'; // add backup codec track
+
+        const simOpts = _objectSpread2({}, opts);
+
+        simOpts.simulcast = true;
+        simOpts.scalabilityMode = undefined;
+        simEncodings = computeVideoEncodings(track.source === Track.Source.ScreenShare, width, height, simOpts);
+        const simulcastTrack = track.addSimulcastTrack(compatibleCodecForSVC, simEncodings);
+        simulcastTracks = [simulcastTrack];
+        req.simulcastCodecs = [{
+          codec: opts.videoCodec,
+          cid: track.mediaStreamTrack.id,
+          enableSimulcastLayers: true
+        }, {
+          codec: simulcastTrack.codec,
+          cid: simulcastTrack.mediaStreamTrack.id,
+          enableSimulcastLayers: true
+        }];
       }
 
       encodings = computeVideoEncodings(track.source === Track.Source.ScreenShare, width, height, opts);
-      req.layers = videoLayersFromEncodings(req.width, req.height, encodings);
+      req.layers = videoLayersFromEncodings(req.width, req.height, simEncodings !== null && simEncodings !== void 0 ? simEncodings : encodings);
     } else if (track.kind === Track.Kind.Audio && opts.audioBitrate) {
       encodings = [{
         maxBitrate: opts.audioBitrate
@@ -13555,7 +14126,9 @@ class LocalParticipant extends Participant {
     }
 
     const ti = await this.engine.addTrack(req);
-    const publication = new LocalTrackPublication(track.kind, ti, track);
+    const publication = new LocalTrackPublication(track.kind, ti, track); // save options for when it needs to be republished again
+
+    publication.options = opts;
     track.sid = ti.sid;
 
     if (!this.engine.publisher) {
@@ -13572,12 +14145,32 @@ class LocalParticipant extends Participant {
 
     if (encodings) {
       transceiverInit.sendEncodings = encodings;
-    }
+    } // addTransceiver for react-native is async. web is synchronous, but await won't effect it.
 
-    const transceiver = this.engine.publisher.pc.addTransceiver(track.mediaStreamTrack, transceiverInit);
 
-    if (opts.videoCodec) {
+    const transceiver = await this.engine.publisher.pc.addTransceiver(track.mediaStreamTrack, transceiverInit);
+
+    if (track.kind === Track.Kind.Video && opts.videoCodec) {
       this.setPreferredCodec(transceiver, track.kind, opts.videoCodec);
+      track.codec = opts.videoCodec;
+    }
+
+    const localTrack = track;
+
+    if (simulcastTracks) {
+      for await (const simulcastTrack of simulcastTracks) {
+        const simTransceiverInit = {
+          direction: 'sendonly'
+        };
+
+        if (simulcastTrack.encodings) {
+          simTransceiverInit.sendEncodings = simulcastTrack.encodings;
+        }
+
+        const simTransceiver = await this.engine.publisher.pc.addTransceiver(simulcastTrack.mediaStreamTrack, simTransceiverInit);
+        this.setPreferredCodec(simTransceiver, localTrack.kind, simulcastTrack.codec);
+        localTrack.setSimulcastTrackSender(simulcastTrack.codec, simTransceiver.sender);
+      }
     }
 
     this.engine.negotiate(); // store RTPSender
@@ -13615,9 +14208,10 @@ class LocalParticipant extends Participant {
     }
 
     track = publication.track;
+    track.sender = undefined;
     track.off(TrackEvent.Muted, this.onTrackMuted);
     track.off(TrackEvent.Unmuted, this.onTrackUnmuted);
-    track.off(TrackEvent.Ended, this.onTrackUnpublish);
+    track.off(TrackEvent.Ended, this.handleTrackEnded);
     track.off(TrackEvent.UpstreamPaused, this.onTrackUpstreamPaused);
     track.off(TrackEvent.UpstreamResumed, this.onTrackUpstreamResumed);
 
@@ -13633,7 +14227,7 @@ class LocalParticipant extends Participant {
       mediaStreamTrack
     } = track;
 
-    if (this.engine.publisher) {
+    if (this.engine.publisher && this.engine.publisher.pc.connectionState !== 'closed') {
       const senders = this.engine.publisher.pc.getSenders();
       senders.forEach(sender => {
         var _a;
@@ -13738,7 +14332,12 @@ class LocalParticipant extends Participant {
 
   setTrackSubscriptionPermissions(allParticipantsAllowed) {
     let participantTrackPermissions = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
-    this.engine.client.sendUpdateSubscriptionPermissions(allParticipantsAllowed, participantTrackPermissions.map(p => trackPermissionToProto(p)));
+    this.participantTrackPermissions = participantTrackPermissions;
+    this.allParticipantsAllowedToSubscribe = allParticipantsAllowed;
+
+    if (this.engine.client.isConnected) {
+      this.updateTrackSubscriptionPermissions();
+    }
   }
 
   getPublicationForTrack(track) {
@@ -13771,6 +14370,7 @@ class LocalParticipant extends Participant {
 
     const cap = RTCRtpSender.getCapabilities(kind);
     if (!cap) return;
+    livekitLogger.debug('get capabilities', cap);
     let selected;
     const codecs = [];
     cap.codecs.forEach(c => {
@@ -17620,8 +18220,8 @@ class SignalClient {
     });
   }
 
-  sendLeave() {
-    this.sendRequest(SignalRequest.fromPartial({
+  async sendLeave() {
+    await this.sendRequest(SignalRequest.fromPartial({
       leave: {}
     }));
   }
@@ -17930,6 +18530,7 @@ class RTCEngine extends events.exports.EventEmitter {
     this.reconnectAttempts = 0;
     this.reconnectStart = 0;
     this.fullReconnectOnNext = false;
+    this.attemptingReconnect = false;
 
     this.handleDataChannel = async _ref => {
       let {
@@ -18006,18 +18607,27 @@ class RTCEngine extends events.exports.EventEmitter {
 
       const delay = this.reconnectAttempts * this.reconnectAttempts * 300;
       setTimeout(async () => {
-        var _a;
+        var _a, _b, _c;
 
         if (this._isClosed) {
           return;
+        } // guard for attempting reconnection multiple times while one attempt is still not finished
+
+
+        if (this.attemptingReconnect) {
+          return;
         }
 
         if (isFireFox() || // TODO remove once clientConfiguration handles firefox case server side
-        ((_a = this.clientConfiguration) === null || _a === void 0 ? void 0 : _a.resumeConnection) === ClientConfigSetting.DISABLED) {
+        ((_a = this.clientConfiguration) === null || _a === void 0 ? void 0 : _a.resumeConnection) === ClientConfigSetting.DISABLED || // signaling state could change to closed due to hardware sleep
+        // those connections cannot be resumed
+        ((_c = (_b = this.primaryPC) === null || _b === void 0 ? void 0 : _b.signalingState) !== null && _c !== void 0 ? _c : 'closed') === 'closed') {
           this.fullReconnectOnNext = true;
         }
 
         try {
+          this.attemptingReconnect = true;
+
           if (this.fullReconnectOnNext) {
             await this.restartConnection();
           } else {
@@ -18028,6 +18638,7 @@ class RTCEngine extends events.exports.EventEmitter {
           this.fullReconnectOnNext = false;
         } catch (e) {
           this.reconnectAttempts += 1;
+          let reconnectRequired = false;
           let recoverable = true;
 
           if (e instanceof UnexpectedConnectionState) {
@@ -18038,7 +18649,14 @@ class RTCEngine extends events.exports.EventEmitter {
             recoverable = false;
           } else if (!(e instanceof SignalReconnectError)) {
             // cannot resume
+            reconnectRequired = true;
+          } // when we flip from resume to reconnect, we need to reset reconnectAttempts
+          // this is needed to fire the right reconnecting events
+
+
+          if (reconnectRequired && !this.fullReconnectOnNext) {
             this.fullReconnectOnNext = true;
+            this.reconnectAttempts = 0;
           }
 
           const duration = Date.now() - this.reconnectStart;
@@ -18054,6 +18672,8 @@ class RTCEngine extends events.exports.EventEmitter {
             this.emit(EngineEvent.Disconnected);
             this.close();
           }
+        } finally {
+          this.attemptingReconnect = false;
         }
       }, delay);
     };
@@ -18202,7 +18822,7 @@ class RTCEngine extends events.exports.EventEmitter {
     this.primaryPC = primaryPC;
 
     primaryPC.onconnectionstatechange = async () => {
-      livekitLogger.trace('connection state changed', {
+      livekitLogger.debug('primary PC state changed', {
         state: primaryPC.connectionState
       });
 
@@ -18231,7 +18851,10 @@ class RTCEngine extends events.exports.EventEmitter {
     };
 
     secondaryPC.onconnectionstatechange = async () => {
-      // also reconnect if secondary peerconnection fails
+      livekitLogger.debug('secondary PC state changed', {
+        state: secondaryPC.connectionState
+      }); // also reconnect if secondary peerconnection fails
+
       if (secondaryPC.connectionState === 'failed') {
         this.handleDisconnect('secondary peerconnection');
       }
@@ -18359,6 +18982,11 @@ class RTCEngine extends events.exports.EventEmitter {
       this.emit(EngineEvent.Restarting);
     }
 
+    if (this.client.isConnected) {
+      this.client.sendLeave();
+    }
+
+    this.client.close();
     this.primaryPC = undefined;
     (_a = this.publisher) === null || _a === void 0 ? void 0 : _a.close();
     this.publisher = undefined;
@@ -18721,6 +19349,7 @@ class Room extends events.exports.EventEmitter {
         this.name = joinResponse.room.name;
         this.sid = joinResponse.room.sid;
         this.metadata = joinResponse.room.metadata;
+        this.emit(RoomEvent.SignalConnected);
       } catch (err) {
         this.engine.close();
         this.setAndEmitConnectionState(ConnectionState.Disconnected);
@@ -18775,7 +19404,7 @@ class Room extends events.exports.EventEmitter {
     this.disconnect = function () {
       let stopTracks = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
 
-      var _a;
+      var _a, _b;
 
       if (_this.state === ConnectionState.Connecting) {
         // try aborting pending connection attempt
@@ -18785,9 +19414,12 @@ class Room extends events.exports.EventEmitter {
       } // send leave
 
 
-      if (_this.engine) {
+      if ((_b = _this.engine) === null || _b === void 0 ? void 0 : _b.client.isConnected) {
         _this.engine.client.sendLeave();
+      } // close engine (also closes client)
 
+
+      if (_this.engine) {
         _this.engine.close();
       }
 
@@ -18803,8 +19435,10 @@ class Room extends events.exports.EventEmitter {
     };
 
     this.handleRestarting = () => {
-      this.setAndEmitConnectionState(ConnectionState.Reconnecting);
-      this.emit(RoomEvent.Reconnecting); // also unwind existing participants & existing subscriptions
+      if (this.setAndEmitConnectionState(ConnectionState.Reconnecting)) {
+        this.emit(RoomEvent.Reconnecting);
+      } // also unwind existing participants & existing subscriptions
+
 
       for (const p of this.participants.values()) {
         this.handleParticipantDisconnected(p.sid, p);
@@ -18812,7 +19446,9 @@ class Room extends events.exports.EventEmitter {
     };
 
     this.handleRestarted = async joinResponse => {
-      livekitLogger.debug("reconnected to server region ".concat(joinResponse.serverRegion));
+      livekitLogger.debug("reconnected to server", {
+        region: joinResponse.serverRegion
+      });
       this.setAndEmitConnectionState(ConnectionState.Connected);
       this.emit(RoomEvent.Reconnected); // rehydrate participants
 
@@ -18833,7 +19469,19 @@ class Room extends events.exports.EventEmitter {
       await Promise.all(localPubs.map(async pub => {
         const track = pub.track;
         this.localParticipant.unpublishTrack(track, false);
-        this.localParticipant.publishTrack(track, pub.options);
+
+        if (!track.isMuted) {
+          if (track instanceof LocalAudioTrack || track instanceof LocalVideoTrack) {
+            // we need to restart the track before publishing, often a full reconnect
+            // is necessary because computer had gone to sleep.
+            livekitLogger.debug('restarting existing track', {
+              track: pub.trackSid
+            });
+            await track.restartTrack();
+          }
+
+          await this.localParticipant.publishTrack(track, pub.options);
+        }
       }));
     };
 
@@ -18843,6 +19491,14 @@ class Room extends events.exports.EventEmitter {
         if (info.sid === this.localParticipant.sid || info.identity === this.localParticipant.identity) {
           this.localParticipant.updateInfo(info);
           return;
+        } // ensure identity <=> sid mapping
+
+
+        const sid = this.identityToSid.get(info.identity);
+
+        if (sid && sid !== info.sid) {
+          // sid had changed, need to remove previous participant
+          this.handleParticipantDisconnected(sid, this.participants.get(sid));
         }
 
         let remoteParticipant = this.participants.get(info.sid);
@@ -18853,7 +19509,8 @@ class Room extends events.exports.EventEmitter {
         if (info.state === ParticipantInfo_State.DISCONNECTED) {
           this.handleParticipantDisconnected(info.sid, remoteParticipant);
         } else if (isNewParticipant) {
-          // fire connected event
+          this.identityToSid.set(info.identity, info.sid); // fire connected event
+
           this.emit(RoomEvent.ParticipantConnected, remoteParticipant);
         } else {
           // just update, no events
@@ -19022,6 +19679,7 @@ class Room extends events.exports.EventEmitter {
     };
 
     this.participants = new Map();
+    this.identityToSid = new Map();
     this.options = options || {};
 
     switch ((_b = (_a = this.options) === null || _a === void 0 ? void 0 : _a.publishDefaults) === null || _b === void 0 ? void 0 : _b.videoCodec) {
@@ -19056,8 +19714,9 @@ class Room extends events.exports.EventEmitter {
     }).on(EngineEvent.Disconnected, () => {
       this.handleDisconnect();
     }).on(EngineEvent.ActiveSpeakersUpdate, this.handleActiveSpeakersUpdate).on(EngineEvent.DataPacketReceived, this.handleDataPacket).on(EngineEvent.Resuming, () => {
-      this.setAndEmitConnectionState(ConnectionState.Reconnecting);
-      this.emit(RoomEvent.Reconnecting);
+      if (this.setAndEmitConnectionState(ConnectionState.Reconnecting)) {
+        this.emit(RoomEvent.Reconnecting);
+      }
     }).on(EngineEvent.Resumed, () => {
       this.setAndEmitConnectionState(ConnectionState.Connected);
       this.emit(RoomEvent.Reconnected);
@@ -19090,15 +19749,15 @@ class Room extends events.exports.EventEmitter {
 
 
   getParticipantByIdentity(identity) {
-    for (const [, p] of this.participants) {
-      if (p.identity === identity) {
-        return p;
-      }
-    }
-
     if (this.localParticipant.identity === identity) {
       return this.localParticipant;
     }
+
+    const sid = this.identityToSid.get(identity);
+
+    if (sid) {
+      return this.participants.get(sid);
+    }
   }
   /**
    * @internal for testing
@@ -19106,6 +19765,8 @@ class Room extends events.exports.EventEmitter {
 
 
   simulateScenario(scenario) {
+    let postAction = () => {};
+
     let req;
 
     switch (scenario) {
@@ -19132,10 +19793,26 @@ class Room extends events.exports.EventEmitter {
           migration: true
         });
         break;
+
+      case 'switch-candidate':
+        req = SimulateScenario.fromPartial({
+          switchCandidateProtocol: 1
+        });
+
+        postAction = () => {
+          var _a;
+
+          (_a = this.engine.publisher) === null || _a === void 0 ? void 0 : _a.createAndSendOffer({
+            iceRestart: true
+          });
+        };
+
+        break;
     }
 
     if (req) {
       this.engine.client.sendSimulateScenario(req);
+      postAction();
     }
   }
   /**
@@ -19258,7 +19935,7 @@ class Room extends events.exports.EventEmitter {
       var _a, _b;
 
       if (pub.track) {
-        this.localParticipant.unpublishTrack(pub.track);
+        this.localParticipant.unpublishTrack(pub.track, shouldStopTracks);
       }
 
       if (shouldStopTracks) {
@@ -19291,8 +19968,9 @@ class Room extends events.exports.EventEmitter {
       return;
     }
 
+    this.identityToSid.delete(participant.identity);
     participant.tracks.forEach(publication => {
-      participant.unpublishTrack(publication.trackSid);
+      participant.unpublishTrack(publication.trackSid, true);
     });
     this.emit(RoomEvent.ParticipantDisconnected, participant);
   }
@@ -19420,11 +20098,13 @@ class Room extends events.exports.EventEmitter {
 
   setAndEmitConnectionState(state) {
     if (state === this.state) {
-      return;
+      // unchanged
+      return false;
     }
 
     this.state = state;
     this.emit(RoomEvent.ConnectionStateChanged, this.state);
+    return true;
   } // /** @internal */