livekit-client 0.18.6 → 1.0.2

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;
   }
 
@@ -9260,10 +9609,15 @@ var RoomEvent;
   /**
    * Whenever the connection state of the room changes
    *
-   * args: ([[RoomState]])
+   * args: ([[ConnectionState]])
+   */
+
+  RoomEvent["ConnectionStateChanged"] = "connectionStateChanged";
+  /**
+   * @deprecated StateChanged has been renamed to ConnectionStateChanged
    */
 
-  RoomEvent["StateChanged"] = "stateChanged";
+  RoomEvent["StateChanged"] = "connectionStateChanged";
   /**
    * When input or output devices on the machine have changed.
    */
@@ -9370,12 +9724,6 @@ var RoomEvent;
    */
 
   RoomEvent["ActiveSpeakersChanged"] = "activeSpeakersChanged";
-  /**
-   * @deprecated Use ParticipantMetadataChanged instead
-   * @internal
-   */
-
-  RoomEvent["MetadataChanged"] = "metadataChanged";
   /**
    * Participant metadata is a simple way for app-specific state to be pushed to
    * all users.
@@ -9463,6 +9811,11 @@ var RoomEvent;
    */
 
   RoomEvent["ParticipantPermissionsChanged"] = "participantPermissionsChanged";
+  /**
+   * Signal connected, can publish tracks.
+   */
+
+  RoomEvent["SignalConnected"] = "signalConnected";
 })(RoomEvent || (RoomEvent = {}));
 
 var ParticipantEvent;
@@ -9541,12 +9894,6 @@ var ParticipantEvent;
    */
 
   ParticipantEvent["LocalTrackUnpublished"] = "localTrackUnpublished";
-  /**
-   * @deprecated Use ParticipantMetadataChanged instead
-   * @internal
-   */
-
-  ParticipantEvent["MetadataChanged"] = "metadataChanged";
   /**
    * Participant metadata is a simple way for app-specific state to be pushed to
    * all users.
@@ -9711,80 +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'
-        };
-        await navigator.mediaDevices.getUserMedia(permissionsToAcquire);
-        devices = await navigator.mediaDevices.enumerateDevices();
-      }
-    }
-
-    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.2";
 
-const version = '0.18.6';
-const protocolVersion = 7;
+const version = version$1;
+const protocolVersion = 8;
 
 const separator = '|';
 function unpackStreamId(packed) {
@@ -9891,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;
@@ -10336,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 = [];
@@ -10344,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;
@@ -10773,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);
@@ -10783,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;
     }
@@ -10820,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);
@@ -11094,6 +11467,10 @@ class LocalAudioTrack extends LocalTrack {
 
 
   startMonitor() {
+    if (!isWeb()) {
+      return;
+    }
+
     setTimeout(() => {
       this.monitorSender();
     }, monitorFrequency);
@@ -11140,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) {
@@ -11191,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();
 
@@ -11209,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();
   }
 
@@ -11256,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
@@ -11318,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
@@ -11331,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':
@@ -11452,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;
   }
@@ -11661,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);
@@ -11722,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
+   */
+
+
+  stopObservingElementInfo(elementInfo) {
+    const stopElementInfos = this.elementInfos.filter(info => info === elementInfo);
+
+    for (const info of stopElementInfos) {
+      info.stopObserving();
     }
 
-    this.hasUsedAttach = true;
-    return element;
+    this.elementInfos = this.elementInfos.filter(info => info !== elementInfo);
+    this.updateVisibility();
   }
 
   detach(element) {
@@ -11757,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) {
@@ -11781,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
         };
       }
     });
@@ -11789,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;
@@ -11833,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;
@@ -11855,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();
@@ -12092,22 +12625,7 @@ const VideoPresets = {
   h720: new VideoPreset(1280, 720, 1700000, 30),
   h1080: new VideoPreset(1920, 1080, 3000000, 30),
   h1440: new VideoPreset(2560, 1440, 5000000, 30),
-  h2160: new VideoPreset(3840, 2160, 8000000, 30),
-
-  /** @deprecated */
-  qvga: new VideoPreset(320, 180, 120000, 10),
-
-  /** @deprecated */
-  vga: new VideoPreset(640, 360, 300000, 20),
-
-  /** @deprecated */
-  qhd: new VideoPreset(960, 540, 600000, 25),
-
-  /** @deprecated */
-  hd: new VideoPreset(1280, 720, 1700000, 30),
-
-  /** @deprecated */
-  fhd: new VideoPreset(1920, 1080, 3000000, 30)
+  h2160: new VideoPreset(3840, 2160, 8000000, 30)
 };
 /**
  * Four by three presets
@@ -12122,44 +12640,14 @@ const VideoPresets43 = {
   h540: new VideoPreset(720, 540, 450000, 25),
   h720: new VideoPreset(960, 720, 1500000, 30),
   h1080: new VideoPreset(1440, 1080, 2500000, 30),
-  h1440: new VideoPreset(1920, 1440, 3500000, 30),
-
-  /** @deprecated */
-  qvga: new VideoPreset(240, 180, 90000, 10),
-
-  /** @deprecated */
-  vga: new VideoPreset(480, 360, 225000, 20),
-
-  /** @deprecated */
-  qhd: new VideoPreset(720, 540, 450000, 25),
-
-  /** @deprecated */
-  hd: new VideoPreset(960, 720, 1500000, 30),
-
-  /** @deprecated */
-  fhd: new VideoPreset(1440, 1080, 2800000, 30)
+  h1440: new VideoPreset(1920, 1440, 3500000, 30)
 };
 const ScreenSharePresets = {
   h360fps3: new VideoPreset(640, 360, 200000, 3),
   h720fps5: new VideoPreset(1280, 720, 400000, 5),
   h720fps15: new VideoPreset(1280, 720, 1000000, 15),
   h1080fps15: new VideoPreset(1920, 1080, 1500000, 15),
-  h1080fps30: new VideoPreset(1920, 1080, 3000000, 30),
-
-  /** @deprecated */
-  vga: new VideoPreset(640, 360, 200000, 3),
-
-  /** @deprecated */
-  hd_8: new VideoPreset(1280, 720, 400000, 5),
-
-  /** @deprecated */
-  hd_15: new VideoPreset(1280, 720, 1000000, 15),
-
-  /** @deprecated */
-  fhd_15: new VideoPreset(1920, 1080, 1500000, 15),
-
-  /** @deprecated */
-  fhd_30: new VideoPreset(1920, 1080, 3000000, 30)
+  h1080fps30: new VideoPreset(1920, 1080, 3000000, 30)
 };
 
 var ConnectionQuality;
@@ -12317,7 +12805,6 @@ class Participant extends events.exports.EventEmitter {
     this.metadata = md;
 
     if (changed) {
-      this.emit(ParticipantEvent.MetadataChanged, prevMetadata);
       this.emit(ParticipantEvent.ParticipantMetadataChanged, prevMetadata);
     }
   }
@@ -12880,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 => {
@@ -12909,29 +13397,32 @@ class RemoteParticipant extends Participant {
     }
   }
   /**
-   * sets the volume on the participant's microphone track if it exists.
+   * sets the volume on the participant's microphone track
+   * if no track exists the volume will be applied when the microphone track is added
    */
 
 
   setVolume(volume) {
+    this.volume = volume;
     const audioPublication = this.getTrack(Track.Source.Microphone);
 
-    if (audioPublication) {
+    if (audioPublication && audioPublication.track) {
       audioPublication.track.setVolume(volume);
     }
   }
   /**
    * gets the volume on the participant's microphone track
-   * returns undefined if no microphone track exists
    */
 
 
   getVolume() {
     const audioPublication = this.getTrack(Track.Source.Microphone);
 
-    if (audioPublication) {
+    if (audioPublication && audioPublication.track) {
       return audioPublication.track.getVolume();
     }
+
+    return this.volume;
   }
   /** @internal */
 
@@ -12987,7 +13478,12 @@ class RemoteParticipant extends Participant {
     track.isMuted = publication.isMuted;
     track.setMediaStream(mediaStream);
     track.start();
-    publication.setTrack(track);
+    publication.setTrack(track); // set participant volume on new microphone tracks
+
+    if (this.volume !== undefined && track instanceof RemoteAudioTrack && track.source === Track.Source.Microphone) {
+      track.setVolume(this.volume);
+    }
+
     this.emit(ParticipantEvent.TrackSubscribed, track, publication);
     return publication;
   }
@@ -13109,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
@@ -13147,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;
@@ -13163,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 => {
@@ -13180,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);
     };
 
@@ -13206,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() {
@@ -13548,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
 
@@ -13563,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
@@ -13571,29 +14089,46 @@ 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
       }];
     }
 
+    if (!this.engine || this.engine.isClosed) {
+      throw new UnexpectedConnectionState('cannot publish track when not connected');
+    }
+
     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) {
@@ -13610,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);
+    const transceiver = await this.engine.publisher.pc.addTransceiver(track.mediaStreamTrack, transceiverInit);
 
-    if (opts.videoCodec) {
+    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
@@ -13653,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);
 
@@ -13671,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;
@@ -13776,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) {
@@ -13809,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 => {
@@ -17441,7 +18003,7 @@ class SignalClient {
     this.requestQueue = new Queue();
   }
 
-  async join(url, token, opts) {
+  async join(url, token, opts, abortSignal) {
     // during a full reconnect, we'd want to start the sequence even if currently
     // connected
     this.isConnected = false;
@@ -17449,7 +18011,7 @@ class SignalClient {
       autoSubscribe: opts === null || opts === void 0 ? void 0 : opts.autoSubscribe,
       publishOnly: opts === null || opts === void 0 ? void 0 : opts.publishOnly,
       adaptiveStream: opts === null || opts === void 0 ? void 0 : opts.adaptiveStream
-    });
+    }, abortSignal);
     return res;
   }
 
@@ -17460,7 +18022,7 @@ class SignalClient {
     });
   }
 
-  connect(url, token, opts) {
+  connect(url, token, opts, abortSignal) {
     if (url.startsWith('http')) {
       url = url.replace('http', 'ws');
     } // strip trailing slash
@@ -17471,6 +18033,17 @@ class SignalClient {
     const clientInfo = getClientInfo();
     const params = createConnectionParams(token, clientInfo, opts);
     return new Promise((resolve, reject) => {
+      const abortHandler = () => {
+        ws.close();
+        this.close();
+        reject(new ConnectionError('room connection has been cancelled'));
+      };
+
+      if (abortSignal === null || abortSignal === void 0 ? void 0 : abortSignal.aborted) {
+        abortHandler();
+      }
+
+      abortSignal === null || abortSignal === void 0 ? void 0 : abortSignal.addEventListener('abort', abortHandler);
       livekitLogger.debug("connecting to ".concat(url + params));
       this.ws = undefined;
       const ws = new WebSocket(url + params);
@@ -17526,6 +18099,7 @@ class SignalClient {
           // handle join message only
           if (msg.join) {
             this.isConnected = true;
+            abortSignal === null || abortSignal === void 0 ? void 0 : abortSignal.removeEventListener('abort', abortHandler);
             resolve(msg.join);
           } else {
             reject(new ConnectionError('did not receive join response'));
@@ -17646,8 +18220,8 @@ class SignalClient {
     });
   }
 
-  sendLeave() {
-    this.sendRequest(SignalRequest.fromPartial({
+  async sendLeave() {
+    await this.sendRequest(SignalRequest.fromPartial({
       leave: {}
     }));
   }
@@ -17948,7 +18522,7 @@ class RTCEngine extends events.exports.EventEmitter {
     this.rtcConfig = {};
     this.subscriberPrimary = false;
     this.pcState = PCState.New;
-    this.isClosed = true;
+    this._isClosed = true;
     this.pendingTrackResolvers = {}; // true if publisher connection has already been established.
     // this is helpful to know if we need to restart ICE on the publisher connection
 
@@ -17956,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 {
@@ -18019,7 +18594,7 @@ class RTCEngine extends events.exports.EventEmitter {
 
 
     this.handleDisconnect = connection => {
-      if (this.isClosed) {
+      if (this._isClosed) {
         return;
       }
 
@@ -18032,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.isClosed) {
+        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 {
@@ -18054,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) {
@@ -18064,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;
@@ -18080,6 +18672,8 @@ class RTCEngine extends events.exports.EventEmitter {
             this.emit(EngineEvent.Disconnected);
             this.close();
           }
+        } finally {
+          this.attemptingReconnect = false;
         }
       }, delay);
     };
@@ -18087,12 +18681,16 @@ class RTCEngine extends events.exports.EventEmitter {
     this.client = new SignalClient();
   }
 
-  async join(url, token, opts) {
+  get isClosed() {
+    return this._isClosed;
+  }
+
+  async join(url, token, opts, abortSignal) {
     this.url = url;
     this.token = token;
     this.signalOpts = opts;
-    const joinResponse = await this.client.join(url, token, opts);
-    this.isClosed = false;
+    const joinResponse = await this.client.join(url, token, opts, abortSignal);
+    this._isClosed = false;
     this.subscriberPrimary = joinResponse.subscriberPrimary;
 
     if (!this.publisher) {
@@ -18109,7 +18707,7 @@ class RTCEngine extends events.exports.EventEmitter {
   }
 
   close() {
-    this.isClosed = true;
+    this._isClosed = true;
     this.removeAllListeners();
 
     if (this.publisher && this.publisher.pc.signalingState !== 'closed') {
@@ -18224,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
       });
 
@@ -18253,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');
       }
@@ -18381,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;
@@ -18619,13 +19225,18 @@ const videoDefaults = {
   resolution: VideoPresets.h720.resolution
 };
 
-var RoomState;
+var ConnectionState;
 
-(function (RoomState) {
-  RoomState["Disconnected"] = "disconnected";
-  RoomState["Connected"] = "connected";
-  RoomState["Reconnecting"] = "reconnecting";
-})(RoomState || (RoomState = {}));
+(function (ConnectionState) {
+  ConnectionState["Disconnected"] = "disconnected";
+  ConnectionState["Connecting"] = "connecting";
+  ConnectionState["Connected"] = "connected";
+  ConnectionState["Reconnecting"] = "reconnecting";
+})(ConnectionState || (ConnectionState = {}));
+/** @deprecated RoomState has been renamed to [[ConnectionState]] */
+
+
+const RoomState = ConnectionState;
 /**
  * In LiveKit, a room is the logical grouping for a list of participants.
  * Participants in a room can publish tracks, and subscribe to others' tracks.
@@ -18635,7 +19246,6 @@ var RoomState;
  * @noInheritDoc
  */
 
-
 class Room extends events.exports.EventEmitter {
   /**
    * Creates a new Room, the primary construct for a LiveKit session.
@@ -18648,7 +19258,7 @@ class Room extends events.exports.EventEmitter {
 
     super();
     _this = this;
-    this.state = RoomState.Disconnected;
+    this.state = ConnectionState.Disconnected;
     /**
      * list of participants that are actively speaking. when this changes
      * a [[RoomEvent.ActiveSpeakersChanged]] event is fired
@@ -18671,9 +19281,15 @@ class Room extends events.exports.EventEmitter {
       var _a, _b; // guard against calling connect
 
 
-      if (this.state !== RoomState.Disconnected) {
+      if (this.state !== ConnectionState.Disconnected) {
         livekitLogger.warn("already connected to room ".concat(this.name));
         return;
+      }
+
+      this.setAndEmitConnectionState(ConnectionState.Connecting);
+
+      if (!this.abortController || this.abortController.signal.aborted) {
+        this.abortController = new AbortController();
       } // recreate engine if previously disconnected
 
 
@@ -18691,7 +19307,7 @@ class Room extends events.exports.EventEmitter {
           autoSubscribe: opts === null || opts === void 0 ? void 0 : opts.autoSubscribe,
           publishOnly: opts === null || opts === void 0 ? void 0 : opts.publishOnly,
           adaptiveStream: typeof ((_a = this.options) === null || _a === void 0 ? void 0 : _a.adaptiveStream) === 'object' ? true : (_b = this.options) === null || _b === void 0 ? void 0 : _b.adaptiveStream
-        });
+        }, this.abortController.signal);
         livekitLogger.debug("connected to Livekit Server version: ".concat(joinResponse.serverVersion, ", region: ").concat(joinResponse.serverRegion));
 
         if (!joinResponse.serverVersion) {
@@ -18704,15 +19320,12 @@ class Room extends events.exports.EventEmitter {
           this.options.dynacast = false;
         }
 
-        this.state = RoomState.Connected;
         const pi = joinResponse.participant;
         this.localParticipant.sid = pi.sid;
         this.localParticipant.identity = pi.identity;
         this.localParticipant.updateInfo(pi); // forward metadata changed for the local participant
 
-        this.localParticipant.on(ParticipantEvent.MetadataChanged, metadata => {
-          this.emit(RoomEvent.MetadataChanged, metadata, this.localParticipant);
-        }).on(ParticipantEvent.ParticipantMetadataChanged, metadata => {
+        this.localParticipant.on(ParticipantEvent.ParticipantMetadataChanged, metadata => {
           this.emit(RoomEvent.ParticipantMetadataChanged, metadata, this.localParticipant);
         }).on(ParticipantEvent.TrackMuted, pub => {
           this.emit(RoomEvent.TrackMuted, pub, this.localParticipant);
@@ -18736,29 +19349,49 @@ class Room extends events.exports.EventEmitter {
         this.name = joinResponse.room.name;
         this.sid = joinResponse.room.sid;
         this.metadata = joinResponse.room.metadata;
-        this.emit(RoomEvent.StateChanged, this.state);
+        this.emit(RoomEvent.SignalConnected);
       } catch (err) {
         this.engine.close();
+        this.setAndEmitConnectionState(ConnectionState.Disconnected);
         throw err;
       } // don't return until ICE connected
 
 
       return new Promise((resolve, reject) => {
+        var _a, _b;
+
         const connectTimeout = setTimeout(() => {
           // timeout
           this.engine.close();
+          this.setAndEmitConnectionState(ConnectionState.Disconnected);
           reject(new ConnectionError('could not connect after timeout'));
         }, maxICEConnectTimeout);
+
+        const abortHandler = () => {
+          livekitLogger.warn('closing engine');
+          clearTimeout(connectTimeout);
+          this.engine.close();
+          this.setAndEmitConnectionState(ConnectionState.Disconnected);
+          reject(new ConnectionError('room connection has been cancelled'));
+        };
+
+        if ((_a = this.abortController) === null || _a === void 0 ? void 0 : _a.signal.aborted) {
+          abortHandler();
+        }
+
+        (_b = this.abortController) === null || _b === void 0 ? void 0 : _b.signal.addEventListener('abort', abortHandler);
         this.engine.once(EngineEvent.Connected, () => {
-          var _a;
+          var _a, _b;
 
-          clearTimeout(connectTimeout); // also hook unload event
+          clearTimeout(connectTimeout);
+          (_a = this.abortController) === null || _a === void 0 ? void 0 : _a.signal.removeEventListener('abort', abortHandler); // also hook unload event
 
           if (isWeb()) {
             window.addEventListener('beforeunload', this.onBeforeUnload);
-            (_a = navigator.mediaDevices) === null || _a === void 0 ? void 0 : _a.addEventListener('devicechange', this.handleDeviceChange);
+            (_b = navigator.mediaDevices) === null || _b === void 0 ? void 0 : _b.addEventListener('devicechange', this.handleDeviceChange);
           }
 
+          this.setAndEmitConnectionState(ConnectionState.Connected);
           resolve(this);
         });
       });
@@ -18771,10 +19404,22 @@ class Room extends events.exports.EventEmitter {
     this.disconnect = function () {
       let stopTracks = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
 
-      // send leave
-      if (_this.engine) {
+      var _a, _b;
+
+      if (_this.state === ConnectionState.Connecting) {
+        // try aborting pending connection attempt
+        livekitLogger.warn('abort connection attempt');
+        (_a = _this.abortController) === null || _a === void 0 ? void 0 : _a.abort();
+        return;
+      } // send leave
+
+
+      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();
       }
 
@@ -18790,9 +19435,10 @@ class Room extends events.exports.EventEmitter {
     };
 
     this.handleRestarting = () => {
-      this.state = RoomState.Reconnecting;
-      this.emit(RoomEvent.Reconnecting);
-      this.emit(RoomEvent.StateChanged, this.state); // 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);
@@ -18800,10 +19446,11 @@ class Room extends events.exports.EventEmitter {
     };
 
     this.handleRestarted = async joinResponse => {
-      livekitLogger.debug("reconnected to server region ".concat(joinResponse.serverRegion));
-      this.state = RoomState.Connected;
-      this.emit(RoomEvent.Reconnected);
-      this.emit(RoomEvent.StateChanged, this.state); // rehydrate participants
+      livekitLogger.debug("reconnected to server", {
+        region: joinResponse.serverRegion
+      });
+      this.setAndEmitConnectionState(ConnectionState.Connected);
+      this.emit(RoomEvent.Reconnected); // rehydrate participants
 
       if (joinResponse.participant) {
         // with a restart, the sid will have changed, we'll map our understanding to it
@@ -18822,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);
+        }
       }));
     };
 
@@ -18832,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);
@@ -18842,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
@@ -19011,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) {
@@ -19045,16 +19714,15 @@ 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.state = RoomState.Reconnecting;
-      this.emit(RoomEvent.Reconnecting);
-      this.emit(RoomEvent.StateChanged, this.state);
+      if (this.setAndEmitConnectionState(ConnectionState.Reconnecting)) {
+        this.emit(RoomEvent.Reconnecting);
+      }
     }).on(EngineEvent.Resumed, () => {
-      this.state = RoomState.Connected;
+      this.setAndEmitConnectionState(ConnectionState.Connected);
       this.emit(RoomEvent.Reconnected);
-      this.emit(RoomEvent.StateChanged, this.state);
       this.updateSubscriptions();
     }).on(EngineEvent.SignalResumed, () => {
-      if (this.state === RoomState.Reconnecting) {
+      if (this.state === ConnectionState.Reconnecting) {
         this.sendSyncState();
       }
     }).on(EngineEvent.Restarting, this.handleRestarting).on(EngineEvent.Restarted, this.handleRestarted);
@@ -19081,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
@@ -19097,6 +19765,8 @@ class Room extends events.exports.EventEmitter {
 
 
   simulateScenario(scenario) {
+    let postAction = () => {};
+
     let req;
 
     switch (scenario) {
@@ -19123,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();
     }
   }
   /**
@@ -19240,10 +19926,6 @@ class Room extends events.exports.EventEmitter {
 
     var _a;
 
-    if (this.state === RoomState.Disconnected) {
-      return;
-    }
-
     this.participants.forEach(p => {
       p.tracks.forEach(pub => {
         p.unpublishTrack(pub.trackSid);
@@ -19253,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) {
@@ -19274,9 +19956,8 @@ class Room extends events.exports.EventEmitter {
       (_a = navigator.mediaDevices) === null || _a === void 0 ? void 0 : _a.removeEventListener('devicechange', this.handleDeviceChange);
     }
 
-    this.state = RoomState.Disconnected;
+    this.setAndEmitConnectionState(ConnectionState.Disconnected);
     this.emit(RoomEvent.Disconnected);
-    this.emit(RoomEvent.StateChanged, this.state);
   }
 
   handleParticipantDisconnected(sid, participant) {
@@ -19287,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);
   }
@@ -19351,8 +20033,6 @@ class Room extends events.exports.EventEmitter {
       this.emit(RoomEvent.TrackMuted, pub, participant);
     }).on(ParticipantEvent.TrackUnmuted, pub => {
       this.emit(RoomEvent.TrackUnmuted, pub, participant);
-    }).on(ParticipantEvent.MetadataChanged, metadata => {
-      this.emit(RoomEvent.MetadataChanged, metadata, participant);
     }).on(ParticipantEvent.ParticipantMetadataChanged, metadata => {
       this.emit(RoomEvent.ParticipantMetadataChanged, metadata, participant);
     }).on(ParticipantEvent.ConnectionQualityChanged, quality => {
@@ -19414,6 +20094,17 @@ class Room extends events.exports.EventEmitter {
         }
       }
     }
+  }
+
+  setAndEmitConnectionState(state) {
+    if (state === this.state) {
+      // unchanged
+      return false;
+    }
+
+    this.state = state;
+    this.emit(RoomEvent.ConnectionStateChanged, this.state);
+    return true;
   } // /** @internal */
 
 
@@ -19431,101 +20122,6 @@ class Room extends events.exports.EventEmitter {
 
 }
 
-/**
- * @deprecated Use room.connect() instead
- *
- * Connects to a LiveKit room, shorthand for `new Room()` and [[Room.connect]]
- *
- * ```typescript
- * connect('wss://myhost.livekit.io', token, {
- *   // publish audio and video tracks on joining
- *   audio: true,
- *   video: true,
- *   captureDefaults: {
- *    facingMode: 'user',
- *   },
- * })
- * ```
- * @param url URL to LiveKit server
- * @param token AccessToken, a JWT token that includes authentication and room details
- * @param options
- */
-
-async function connect(url, token, options) {
-  var _a, _b, _c, _d;
-
-  options !== null && options !== void 0 ? options : options = {};
-
-  if (options.adaptiveStream === undefined) {
-    options.adaptiveStream = options.autoManageVideo === true ? {} : undefined;
-  }
-
-  setLogLevel((_a = options.logLevel) !== null && _a !== void 0 ? _a : LogLevel.warn);
-  const config = (_b = options.rtcConfig) !== null && _b !== void 0 ? _b : {};
-
-  if (options.iceServers) {
-    config.iceServers = options.iceServers;
-  }
-
-  const room = new Room(options); // connect to room
-
-  await room.connect(url, token, options);
-  const publishAudio = (_c = options.audio) !== null && _c !== void 0 ? _c : false;
-  const publishVideo = (_d = options.video) !== null && _d !== void 0 ? _d : false;
-
-  if (publishAudio || publishVideo) {
-    setTimeout(async () => {
-      // if publishing both
-      let err;
-
-      if (publishAudio && publishVideo) {
-        try {
-          await room.localParticipant.enableCameraAndMicrophone();
-        } catch (e) {
-          const errKind = MediaDeviceFailure.getFailure(e);
-          livekitLogger.warn('received error while creating media', {
-            error: errKind
-          });
-
-          if (e instanceof Error) {
-            livekitLogger.warn(e.message);
-          } // when it's a device issue, try to publish the other kind
-
-
-          if (errKind === MediaDeviceFailure.NotFound || errKind === MediaDeviceFailure.DeviceInUse) {
-            try {
-              await room.localParticipant.setMicrophoneEnabled(true);
-            } catch (audioErr) {
-              err = audioErr;
-            }
-          } else {
-            err = e;
-          }
-        }
-      } else if (publishAudio) {
-        try {
-          await room.localParticipant.setMicrophoneEnabled(true);
-        } catch (e) {
-          err = e;
-        }
-      } else if (publishVideo) {
-        try {
-          await room.localParticipant.setCameraEnabled(true);
-        } catch (e) {
-          err = e;
-        }
-      }
-
-      if (err) {
-        room.emit(RoomEvent.MediaDevicesError, err);
-        livekitLogger.error('could not create media', err);
-      }
-    });
-  }
-
-  return room;
-}
-
 /**
  * Creates a local video and audio track at the same time. When acquiring both
  * audio and video tracks together, it'll display a single permission prompt to
@@ -19599,7 +20195,7 @@ async function createLocalScreenTracks(options) {
   }
 
   if (options.resolution === undefined) {
-    options.resolution = VideoPresets.fhd.resolution;
+    options.resolution = VideoPresets.h1080.resolution;
   }
 
   let videoConstraints = true;
@@ -19636,5 +20232,5 @@ async function createLocalScreenTracks(options) {
   return localTracks;
 }
 
-export { AudioPresets, ConnectionError, ConnectionQuality, DataPacket_Kind, EngineEvent, LivekitError, LocalAudioTrack, LocalParticipant, LocalTrack, LocalTrackPublication, LocalVideoTrack, LogLevel, MediaDeviceFailure, Participant, ParticipantEvent, PublishDataError, RemoteAudioTrack, RemoteParticipant, RemoteTrack, RemoteTrackPublication, RemoteVideoTrack, Room, RoomEvent, RoomState, ScreenSharePresets, Track, TrackEvent, TrackInvalidError, TrackPublication, UnexpectedConnectionState, UnsupportedServer, VideoPreset, VideoPresets, VideoPresets43, VideoQuality, attachToElement, connect, createLocalAudioTrack, createLocalScreenTracks, createLocalTracks, createLocalVideoTrack, detachTrack, protocolVersion, setLogExtension, setLogLevel, version };
+export { AudioPresets, ConnectionError, ConnectionQuality, ConnectionState, DataPacket_Kind, EngineEvent, LivekitError, LocalAudioTrack, LocalParticipant, LocalTrack, LocalTrackPublication, LocalVideoTrack, LogLevel, MediaDeviceFailure, Participant, ParticipantEvent, PublishDataError, RemoteAudioTrack, RemoteParticipant, RemoteTrack, RemoteTrackPublication, RemoteVideoTrack, Room, RoomEvent, RoomState, ScreenSharePresets, Track, TrackEvent, TrackInvalidError, TrackPublication, UnexpectedConnectionState, UnsupportedServer, VideoPreset, VideoPresets, VideoPresets43, VideoQuality, attachToElement, createLocalAudioTrack, createLocalScreenTracks, createLocalTracks, createLocalVideoTrack, detachTrack, protocolVersion, setLogExtension, setLogLevel, version };
 //# sourceMappingURL=livekit-client.esm.mjs.map