@fishjam-cloud/webrtc-client 0.14.0

package/dist/index.mjs

@@ -0,0 +1,4952 @@
+// ../protobufs/fishjam/media_events/peer/peer.ts
+import { BinaryReader as BinaryReader2, BinaryWriter as BinaryWriter2 } from "@bufbuild/protobuf/wire";
+
+// ../protobufs/fishjam/media_events/shared.ts
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
+var Variant = /* @__PURE__ */ ((Variant4) => {
+  Variant4[Variant4["VARIANT_UNSPECIFIED"] = 0] = "VARIANT_UNSPECIFIED";
+  Variant4[Variant4["VARIANT_LOW"] = 1] = "VARIANT_LOW";
+  Variant4[Variant4["VARIANT_MEDIUM"] = 2] = "VARIANT_MEDIUM";
+  Variant4[Variant4["VARIANT_HIGH"] = 3] = "VARIANT_HIGH";
+  Variant4[Variant4["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+  return Variant4;
+})(Variant || {});
+function variantFromJSON(object) {
+  switch (object) {
+    case 0:
+    case "VARIANT_UNSPECIFIED":
+      return 0 /* VARIANT_UNSPECIFIED */;
+    case 1:
+    case "VARIANT_LOW":
+      return 1 /* VARIANT_LOW */;
+    case 2:
+    case "VARIANT_MEDIUM":
+      return 2 /* VARIANT_MEDIUM */;
+    case 3:
+    case "VARIANT_HIGH":
+      return 3 /* VARIANT_HIGH */;
+    case -1:
+    case "UNRECOGNIZED":
+    default:
+      return -1 /* UNRECOGNIZED */;
+  }
+}
+function variantToJSON(object) {
+  switch (object) {
+    case 0 /* VARIANT_UNSPECIFIED */:
+      return "VARIANT_UNSPECIFIED";
+    case 1 /* VARIANT_LOW */:
+      return "VARIANT_LOW";
+    case 2 /* VARIANT_MEDIUM */:
+      return "VARIANT_MEDIUM";
+    case 3 /* VARIANT_HIGH */:
+      return "VARIANT_HIGH";
+    case -1 /* UNRECOGNIZED */:
+    default:
+      return "UNRECOGNIZED";
+  }
+}
+function createBaseCandidate() {
+  return { candidate: "", sdpMLineIndex: 0, sdpMid: "", usernameFragment: "" };
+}
+var Candidate = {
+  encode(message, writer = new BinaryWriter()) {
+    if (message.candidate !== "") {
+      writer.uint32(10).string(message.candidate);
+    }
+    if (message.sdpMLineIndex !== 0) {
+      writer.uint32(16).int32(message.sdpMLineIndex);
+    }
+    if (message.sdpMid !== "") {
+      writer.uint32(26).string(message.sdpMid);
+    }
+    if (message.usernameFragment !== "") {
+      writer.uint32(34).string(message.usernameFragment);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseCandidate();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.candidate = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 16) {
+            break;
+          }
+          message.sdpMLineIndex = reader.int32();
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+          message.sdpMid = reader.string();
+          continue;
+        }
+        case 4: {
+          if (tag !== 34) {
+            break;
+          }
+          message.usernameFragment = reader.string();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      candidate: isSet(object.candidate) ? globalThis.String(object.candidate) : "",
+      sdpMLineIndex: isSet(object.sdpMLineIndex) ? globalThis.Number(object.sdpMLineIndex) : 0,
+      sdpMid: isSet(object.sdpMid) ? globalThis.String(object.sdpMid) : "",
+      usernameFragment: isSet(object.usernameFragment) ? globalThis.String(object.usernameFragment) : ""
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.candidate !== "") {
+      obj.candidate = message.candidate;
+    }
+    if (message.sdpMLineIndex !== 0) {
+      obj.sdpMLineIndex = Math.round(message.sdpMLineIndex);
+    }
+    if (message.sdpMid !== "") {
+      obj.sdpMid = message.sdpMid;
+    }
+    if (message.usernameFragment !== "") {
+      obj.usernameFragment = message.usernameFragment;
+    }
+    return obj;
+  },
+  create(base) {
+    return Candidate.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseCandidate();
+    message.candidate = object.candidate ?? "";
+    message.sdpMLineIndex = object.sdpMLineIndex ?? 0;
+    message.sdpMid = object.sdpMid ?? "";
+    message.usernameFragment = object.usernameFragment ?? "";
+    return message;
+  }
+};
+function isSet(value) {
+  return value !== null && value !== void 0;
+}
+
+// ../protobufs/fishjam/media_events/peer/peer.ts
+function createBaseMediaEvent() {
+  return {
+    connect: void 0,
+    disconnect: void 0,
+    updateEndpointMetadata: void 0,
+    updateTrackMetadata: void 0,
+    renegotiateTracks: void 0,
+    candidate: void 0,
+    sdpOffer: void 0,
+    trackBitrates: void 0,
+    enableTrackVariant: void 0,
+    disableTrackVariant: void 0,
+    setTargetTrackVariant: void 0
+  };
+}
+var MediaEvent = {
+  encode(message, writer = new BinaryWriter2()) {
+    if (message.connect !== void 0) {
+      MediaEvent_Connect.encode(message.connect, writer.uint32(10).fork()).join();
+    }
+    if (message.disconnect !== void 0) {
+      MediaEvent_Disconnect.encode(message.disconnect, writer.uint32(18).fork()).join();
+    }
+    if (message.updateEndpointMetadata !== void 0) {
+      MediaEvent_UpdateEndpointMetadata.encode(message.updateEndpointMetadata, writer.uint32(26).fork()).join();
+    }
+    if (message.updateTrackMetadata !== void 0) {
+      MediaEvent_UpdateTrackMetadata.encode(message.updateTrackMetadata, writer.uint32(34).fork()).join();
+    }
+    if (message.renegotiateTracks !== void 0) {
+      MediaEvent_RenegotiateTracks.encode(message.renegotiateTracks, writer.uint32(42).fork()).join();
+    }
+    if (message.candidate !== void 0) {
+      Candidate.encode(message.candidate, writer.uint32(50).fork()).join();
+    }
+    if (message.sdpOffer !== void 0) {
+      MediaEvent_SdpOffer.encode(message.sdpOffer, writer.uint32(58).fork()).join();
+    }
+    if (message.trackBitrates !== void 0) {
+      MediaEvent_TrackBitrates.encode(message.trackBitrates, writer.uint32(66).fork()).join();
+    }
+    if (message.enableTrackVariant !== void 0) {
+      MediaEvent_EnableTrackVariant.encode(message.enableTrackVariant, writer.uint32(74).fork()).join();
+    }
+    if (message.disableTrackVariant !== void 0) {
+      MediaEvent_DisableTrackVariant.encode(message.disableTrackVariant, writer.uint32(82).fork()).join();
+    }
+    if (message.setTargetTrackVariant !== void 0) {
+      MediaEvent_SetTargetTrackVariant.encode(message.setTargetTrackVariant, writer.uint32(90).fork()).join();
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof BinaryReader2 ? input : new BinaryReader2(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseMediaEvent();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.connect = MediaEvent_Connect.decode(reader, reader.uint32());
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.disconnect = MediaEvent_Disconnect.decode(reader, reader.uint32());
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+          message.updateEndpointMetadata = MediaEvent_UpdateEndpointMetadata.decode(reader, reader.uint32());
+          continue;
+        }
+        case 4: {
+          if (tag !== 34) {
+            break;
+          }
+          message.updateTrackMetadata = MediaEvent_UpdateTrackMetadata.decode(reader, reader.uint32());
+          continue;
+        }
+        case 5: {
+          if (tag !== 42) {
+            break;
+          }
+          message.renegotiateTracks = MediaEvent_RenegotiateTracks.decode(reader, reader.uint32());
+          continue;
+        }
+        case 6: {
+          if (tag !== 50) {
+            break;
+          }
+          message.candidate = Candidate.decode(reader, reader.uint32());
+          continue;
+        }
+        case 7: {
+          if (tag !== 58) {
+            break;
+          }
+          message.sdpOffer = MediaEvent_SdpOffer.decode(reader, reader.uint32());
+          continue;
+        }
+        case 8: {
+          if (tag !== 66) {
+            break;
+          }
+          message.trackBitrates = MediaEvent_TrackBitrates.decode(reader, reader.uint32());
+          continue;
+        }
+        case 9: {
+          if (tag !== 74) {
+            break;
+          }
+          message.enableTrackVariant = MediaEvent_EnableTrackVariant.decode(reader, reader.uint32());
+          continue;
+        }
+        case 10: {
+          if (tag !== 82) {
+            break;
+          }
+          message.disableTrackVariant = MediaEvent_DisableTrackVariant.decode(reader, reader.uint32());
+          continue;
+        }
+        case 11: {
+          if (tag !== 90) {
+            break;
+          }
+          message.setTargetTrackVariant = MediaEvent_SetTargetTrackVariant.decode(reader, reader.uint32());
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      connect: isSet2(object.connect) ? MediaEvent_Connect.fromJSON(object.connect) : void 0,
+      disconnect: isSet2(object.disconnect) ? MediaEvent_Disconnect.fromJSON(object.disconnect) : void 0,
+      updateEndpointMetadata: isSet2(object.updateEndpointMetadata) ? MediaEvent_UpdateEndpointMetadata.fromJSON(object.updateEndpointMetadata) : void 0,
+      updateTrackMetadata: isSet2(object.updateTrackMetadata) ? MediaEvent_UpdateTrackMetadata.fromJSON(object.updateTrackMetadata) : void 0,
+      renegotiateTracks: isSet2(object.renegotiateTracks) ? MediaEvent_RenegotiateTracks.fromJSON(object.renegotiateTracks) : void 0,
+      candidate: isSet2(object.candidate) ? Candidate.fromJSON(object.candidate) : void 0,
+      sdpOffer: isSet2(object.sdpOffer) ? MediaEvent_SdpOffer.fromJSON(object.sdpOffer) : void 0,
+      trackBitrates: isSet2(object.trackBitrates) ? MediaEvent_TrackBitrates.fromJSON(object.trackBitrates) : void 0,
+      enableTrackVariant: isSet2(object.enableTrackVariant) ? MediaEvent_EnableTrackVariant.fromJSON(object.enableTrackVariant) : void 0,
+      disableTrackVariant: isSet2(object.disableTrackVariant) ? MediaEvent_DisableTrackVariant.fromJSON(object.disableTrackVariant) : void 0,
+      setTargetTrackVariant: isSet2(object.setTargetTrackVariant) ? MediaEvent_SetTargetTrackVariant.fromJSON(object.setTargetTrackVariant) : void 0
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.connect !== void 0) {
+      obj.connect = MediaEvent_Connect.toJSON(message.connect);
+    }
+    if (message.disconnect !== void 0) {
+      obj.disconnect = MediaEvent_Disconnect.toJSON(message.disconnect);
+    }
+    if (message.updateEndpointMetadata !== void 0) {
+      obj.updateEndpointMetadata = MediaEvent_UpdateEndpointMetadata.toJSON(message.updateEndpointMetadata);
+    }
+    if (message.updateTrackMetadata !== void 0) {
+      obj.updateTrackMetadata = MediaEvent_UpdateTrackMetadata.toJSON(message.updateTrackMetadata);
+    }
+    if (message.renegotiateTracks !== void 0) {
+      obj.renegotiateTracks = MediaEvent_RenegotiateTracks.toJSON(message.renegotiateTracks);
+    }
+    if (message.candidate !== void 0) {
+      obj.candidate = Candidate.toJSON(message.candidate);
+    }
+    if (message.sdpOffer !== void 0) {
+      obj.sdpOffer = MediaEvent_SdpOffer.toJSON(message.sdpOffer);
+    }
+    if (message.trackBitrates !== void 0) {
+      obj.trackBitrates = MediaEvent_TrackBitrates.toJSON(message.trackBitrates);
+    }
+    if (message.enableTrackVariant !== void 0) {
+      obj.enableTrackVariant = MediaEvent_EnableTrackVariant.toJSON(message.enableTrackVariant);
+    }
+    if (message.disableTrackVariant !== void 0) {
+      obj.disableTrackVariant = MediaEvent_DisableTrackVariant.toJSON(message.disableTrackVariant);
+    }
+    if (message.setTargetTrackVariant !== void 0) {
+      obj.setTargetTrackVariant = MediaEvent_SetTargetTrackVariant.toJSON(message.setTargetTrackVariant);
+    }
+    return obj;
+  },
+  create(base) {
+    return MediaEvent.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseMediaEvent();
+    message.connect = object.connect !== void 0 && object.connect !== null ? MediaEvent_Connect.fromPartial(object.connect) : void 0;
+    message.disconnect = object.disconnect !== void 0 && object.disconnect !== null ? MediaEvent_Disconnect.fromPartial(object.disconnect) : void 0;
+    message.updateEndpointMetadata = object.updateEndpointMetadata !== void 0 && object.updateEndpointMetadata !== null ? MediaEvent_UpdateEndpointMetadata.fromPartial(object.updateEndpointMetadata) : void 0;
+    message.updateTrackMetadata = object.updateTrackMetadata !== void 0 && object.updateTrackMetadata !== null ? MediaEvent_UpdateTrackMetadata.fromPartial(object.updateTrackMetadata) : void 0;
+    message.renegotiateTracks = object.renegotiateTracks !== void 0 && object.renegotiateTracks !== null ? MediaEvent_RenegotiateTracks.fromPartial(object.renegotiateTracks) : void 0;
+    message.candidate = object.candidate !== void 0 && object.candidate !== null ? Candidate.fromPartial(object.candidate) : void 0;
+    message.sdpOffer = object.sdpOffer !== void 0 && object.sdpOffer !== null ? MediaEvent_SdpOffer.fromPartial(object.sdpOffer) : void 0;
+    message.trackBitrates = object.trackBitrates !== void 0 && object.trackBitrates !== null ? MediaEvent_TrackBitrates.fromPartial(object.trackBitrates) : void 0;
+    message.enableTrackVariant = object.enableTrackVariant !== void 0 && object.enableTrackVariant !== null ? MediaEvent_EnableTrackVariant.fromPartial(object.enableTrackVariant) : void 0;
+    message.disableTrackVariant = object.disableTrackVariant !== void 0 && object.disableTrackVariant !== null ? MediaEvent_DisableTrackVariant.fromPartial(object.disableTrackVariant) : void 0;
+    message.setTargetTrackVariant = object.setTargetTrackVariant !== void 0 && object.setTargetTrackVariant !== null ? MediaEvent_SetTargetTrackVariant.fromPartial(object.setTargetTrackVariant) : void 0;
+    return message;
+  }
+};
+function createBaseMediaEvent_VariantBitrate() {
+  return { variant: 0, bitrate: 0 };
+}
+var MediaEvent_VariantBitrate = {
+  encode(message, writer = new BinaryWriter2()) {
+    if (message.variant !== 0) {
+      writer.uint32(8).int32(message.variant);
+    }
+    if (message.bitrate !== 0) {
+      writer.uint32(16).int32(message.bitrate);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof BinaryReader2 ? input : new BinaryReader2(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseMediaEvent_VariantBitrate();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 8) {
+            break;
+          }
+          message.variant = reader.int32();
+          continue;
+        }
+        case 2: {
+          if (tag !== 16) {
+            break;
+          }
+          message.bitrate = reader.int32();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      variant: isSet2(object.variant) ? variantFromJSON(object.variant) : 0,
+      bitrate: isSet2(object.bitrate) ? globalThis.Number(object.bitrate) : 0
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.variant !== 0) {
+      obj.variant = variantToJSON(message.variant);
+    }
+    if (message.bitrate !== 0) {
+      obj.bitrate = Math.round(message.bitrate);
+    }
+    return obj;
+  },
+  create(base) {
+    return MediaEvent_VariantBitrate.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseMediaEvent_VariantBitrate();
+    message.variant = object.variant ?? 0;
+    message.bitrate = object.bitrate ?? 0;
+    return message;
+  }
+};
+function createBaseMediaEvent_Connect() {
+  return { metadataJson: "" };
+}
+var MediaEvent_Connect = {
+  encode(message, writer = new BinaryWriter2()) {
+    if (message.metadataJson !== "") {
+      writer.uint32(10).string(message.metadataJson);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof BinaryReader2 ? input : new BinaryReader2(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseMediaEvent_Connect();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.metadataJson = reader.string();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return { metadataJson: isSet2(object.metadataJson) ? globalThis.String(object.metadataJson) : "" };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.metadataJson !== "") {
+      obj.metadataJson = message.metadataJson;
+    }
+    return obj;
+  },
+  create(base) {
+    return MediaEvent_Connect.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseMediaEvent_Connect();
+    message.metadataJson = object.metadataJson ?? "";
+    return message;
+  }
+};
+function createBaseMediaEvent_Disconnect() {
+  return {};
+}
+var MediaEvent_Disconnect = {
+  encode(_, writer = new BinaryWriter2()) {
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof BinaryReader2 ? input : new BinaryReader2(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseMediaEvent_Disconnect();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(_) {
+    return {};
+  },
+  toJSON(_) {
+    const obj = {};
+    return obj;
+  },
+  create(base) {
+    return MediaEvent_Disconnect.fromPartial(base ?? {});
+  },
+  fromPartial(_) {
+    const message = createBaseMediaEvent_Disconnect();
+    return message;
+  }
+};
+function createBaseMediaEvent_UpdateEndpointMetadata() {
+  return { metadataJson: "" };
+}
+var MediaEvent_UpdateEndpointMetadata = {
+  encode(message, writer = new BinaryWriter2()) {
+    if (message.metadataJson !== "") {
+      writer.uint32(10).string(message.metadataJson);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof BinaryReader2 ? input : new BinaryReader2(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseMediaEvent_UpdateEndpointMetadata();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.metadataJson = reader.string();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return { metadataJson: isSet2(object.metadataJson) ? globalThis.String(object.metadataJson) : "" };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.metadataJson !== "") {
+      obj.metadataJson = message.metadataJson;
+    }
+    return obj;
+  },
+  create(base) {
+    return MediaEvent_UpdateEndpointMetadata.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseMediaEvent_UpdateEndpointMetadata();
+    message.metadataJson = object.metadataJson ?? "";
+    return message;
+  }
+};
+function createBaseMediaEvent_UpdateTrackMetadata() {
+  return { trackId: "", metadataJson: "" };
+}
+var MediaEvent_UpdateTrackMetadata = {
+  encode(message, writer = new BinaryWriter2()) {
+    if (message.trackId !== "") {
+      writer.uint32(10).string(message.trackId);
+    }
+    if (message.metadataJson !== "") {
+      writer.uint32(18).string(message.metadataJson);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof BinaryReader2 ? input : new BinaryReader2(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseMediaEvent_UpdateTrackMetadata();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.trackId = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.metadataJson = reader.string();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      trackId: isSet2(object.trackId) ? globalThis.String(object.trackId) : "",
+      metadataJson: isSet2(object.metadataJson) ? globalThis.String(object.metadataJson) : ""
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.trackId !== "") {
+      obj.trackId = message.trackId;
+    }
+    if (message.metadataJson !== "") {
+      obj.metadataJson = message.metadataJson;
+    }
+    return obj;
+  },
+  create(base) {
+    return MediaEvent_UpdateTrackMetadata.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseMediaEvent_UpdateTrackMetadata();
+    message.trackId = object.trackId ?? "";
+    message.metadataJson = object.metadataJson ?? "";
+    return message;
+  }
+};
+function createBaseMediaEvent_RenegotiateTracks() {
+  return {};
+}
+var MediaEvent_RenegotiateTracks = {
+  encode(_, writer = new BinaryWriter2()) {
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof BinaryReader2 ? input : new BinaryReader2(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseMediaEvent_RenegotiateTracks();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(_) {
+    return {};
+  },
+  toJSON(_) {
+    const obj = {};
+    return obj;
+  },
+  create(base) {
+    return MediaEvent_RenegotiateTracks.fromPartial(base ?? {});
+  },
+  fromPartial(_) {
+    const message = createBaseMediaEvent_RenegotiateTracks();
+    return message;
+  }
+};
+function createBaseMediaEvent_SdpOffer() {
+  return { sdp: "", trackIdToMetadataJson: {}, trackIdToBitrates: {}, midToTrackId: {} };
+}
+var MediaEvent_SdpOffer = {
+  encode(message, writer = new BinaryWriter2()) {
+    if (message.sdp !== "") {
+      writer.uint32(10).string(message.sdp);
+    }
+    Object.entries(message.trackIdToMetadataJson).forEach(([key, value]) => {
+      MediaEvent_SdpOffer_TrackIdToMetadataJsonEntry.encode({ key, value }, writer.uint32(18).fork()).join();
+    });
+    Object.entries(message.trackIdToBitrates).forEach(([key, value]) => {
+      MediaEvent_SdpOffer_TrackIdToBitratesEntry.encode({ key, value }, writer.uint32(26).fork()).join();
+    });
+    Object.entries(message.midToTrackId).forEach(([key, value]) => {
+      MediaEvent_SdpOffer_MidToTrackIdEntry.encode({ key, value }, writer.uint32(34).fork()).join();
+    });
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof BinaryReader2 ? input : new BinaryReader2(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseMediaEvent_SdpOffer();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.sdp = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          const entry2 = MediaEvent_SdpOffer_TrackIdToMetadataJsonEntry.decode(reader, reader.uint32());
+          if (entry2.value !== void 0) {
+            message.trackIdToMetadataJson[entry2.key] = entry2.value;
+          }
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+          const entry3 = MediaEvent_SdpOffer_TrackIdToBitratesEntry.decode(reader, reader.uint32());
+          if (entry3.value !== void 0) {
+            message.trackIdToBitrates[entry3.key] = entry3.value;
+          }
+          continue;
+        }
+        case 4: {
+          if (tag !== 34) {
+            break;
+          }
+          const entry4 = MediaEvent_SdpOffer_MidToTrackIdEntry.decode(reader, reader.uint32());
+          if (entry4.value !== void 0) {
+            message.midToTrackId[entry4.key] = entry4.value;
+          }
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      sdp: isSet2(object.sdp) ? globalThis.String(object.sdp) : "",
+      trackIdToMetadataJson: isObject(object.trackIdToMetadataJson) ? Object.entries(object.trackIdToMetadataJson).reduce((acc, [key, value]) => {
+        acc[key] = String(value);
+        return acc;
+      }, {}) : {},
+      trackIdToBitrates: isObject(object.trackIdToBitrates) ? Object.entries(object.trackIdToBitrates).reduce(
+        (acc, [key, value]) => {
+          acc[key] = MediaEvent_TrackBitrates.fromJSON(value);
+          return acc;
+        },
+        {}
+      ) : {},
+      midToTrackId: isObject(object.midToTrackId) ? Object.entries(object.midToTrackId).reduce((acc, [key, value]) => {
+        acc[key] = String(value);
+        return acc;
+      }, {}) : {}
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.sdp !== "") {
+      obj.sdp = message.sdp;
+    }
+    if (message.trackIdToMetadataJson) {
+      const entries = Object.entries(message.trackIdToMetadataJson);
+      if (entries.length > 0) {
+        obj.trackIdToMetadataJson = {};
+        entries.forEach(([k, v]) => {
+          obj.trackIdToMetadataJson[k] = v;
+        });
+      }
+    }
+    if (message.trackIdToBitrates) {
+      const entries = Object.entries(message.trackIdToBitrates);
+      if (entries.length > 0) {
+        obj.trackIdToBitrates = {};
+        entries.forEach(([k, v]) => {
+          obj.trackIdToBitrates[k] = MediaEvent_TrackBitrates.toJSON(v);
+        });
+      }
+    }
+    if (message.midToTrackId) {
+      const entries = Object.entries(message.midToTrackId);
+      if (entries.length > 0) {
+        obj.midToTrackId = {};
+        entries.forEach(([k, v]) => {
+          obj.midToTrackId[k] = v;
+        });
+      }
+    }
+    return obj;
+  },
+  create(base) {
+    return MediaEvent_SdpOffer.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseMediaEvent_SdpOffer();
+    message.sdp = object.sdp ?? "";
+    message.trackIdToMetadataJson = Object.entries(object.trackIdToMetadataJson ?? {}).reduce((acc, [key, value]) => {
+      if (value !== void 0) {
+        acc[key] = globalThis.String(value);
+      }
+      return acc;
+    }, {});
+    message.trackIdToBitrates = Object.entries(object.trackIdToBitrates ?? {}).reduce((acc, [key, value]) => {
+      if (value !== void 0) {
+        acc[key] = MediaEvent_TrackBitrates.fromPartial(value);
+      }
+      return acc;
+    }, {});
+    message.midToTrackId = Object.entries(object.midToTrackId ?? {}).reduce(
+      (acc, [key, value]) => {
+        if (value !== void 0) {
+          acc[key] = globalThis.String(value);
+        }
+        return acc;
+      },
+      {}
+    );
+    return message;
+  }
+};
+function createBaseMediaEvent_SdpOffer_TrackIdToMetadataJsonEntry() {
+  return { key: "", value: "" };
+}
+var MediaEvent_SdpOffer_TrackIdToMetadataJsonEntry = {
+  encode(message, writer = new BinaryWriter2()) {
+    if (message.key !== "") {
+      writer.uint32(10).string(message.key);
+    }
+    if (message.value !== "") {
+      writer.uint32(18).string(message.value);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof BinaryReader2 ? input : new BinaryReader2(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseMediaEvent_SdpOffer_TrackIdToMetadataJsonEntry();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.key = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.value = reader.string();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      key: isSet2(object.key) ? globalThis.String(object.key) : "",
+      value: isSet2(object.value) ? globalThis.String(object.value) : ""
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.key !== "") {
+      obj.key = message.key;
+    }
+    if (message.value !== "") {
+      obj.value = message.value;
+    }
+    return obj;
+  },
+  create(base) {
+    return MediaEvent_SdpOffer_TrackIdToMetadataJsonEntry.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseMediaEvent_SdpOffer_TrackIdToMetadataJsonEntry();
+    message.key = object.key ?? "";
+    message.value = object.value ?? "";
+    return message;
+  }
+};
+function createBaseMediaEvent_SdpOffer_TrackIdToBitratesEntry() {
+  return { key: "", value: void 0 };
+}
+var MediaEvent_SdpOffer_TrackIdToBitratesEntry = {
+  encode(message, writer = new BinaryWriter2()) {
+    if (message.key !== "") {
+      writer.uint32(10).string(message.key);
+    }
+    if (message.value !== void 0) {
+      MediaEvent_TrackBitrates.encode(message.value, writer.uint32(18).fork()).join();
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof BinaryReader2 ? input : new BinaryReader2(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseMediaEvent_SdpOffer_TrackIdToBitratesEntry();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.key = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.value = MediaEvent_TrackBitrates.decode(reader, reader.uint32());
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      key: isSet2(object.key) ? globalThis.String(object.key) : "",
+      value: isSet2(object.value) ? MediaEvent_TrackBitrates.fromJSON(object.value) : void 0
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.key !== "") {
+      obj.key = message.key;
+    }
+    if (message.value !== void 0) {
+      obj.value = MediaEvent_TrackBitrates.toJSON(message.value);
+    }
+    return obj;
+  },
+  create(base) {
+    return MediaEvent_SdpOffer_TrackIdToBitratesEntry.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseMediaEvent_SdpOffer_TrackIdToBitratesEntry();
+    message.key = object.key ?? "";
+    message.value = object.value !== void 0 && object.value !== null ? MediaEvent_TrackBitrates.fromPartial(object.value) : void 0;
+    return message;
+  }
+};
+function createBaseMediaEvent_SdpOffer_MidToTrackIdEntry() {
+  return { key: "", value: "" };
+}
+var MediaEvent_SdpOffer_MidToTrackIdEntry = {
+  encode(message, writer = new BinaryWriter2()) {
+    if (message.key !== "") {
+      writer.uint32(10).string(message.key);
+    }
+    if (message.value !== "") {
+      writer.uint32(18).string(message.value);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof BinaryReader2 ? input : new BinaryReader2(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseMediaEvent_SdpOffer_MidToTrackIdEntry();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.key = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.value = reader.string();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      key: isSet2(object.key) ? globalThis.String(object.key) : "",
+      value: isSet2(object.value) ? globalThis.String(object.value) : ""
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.key !== "") {
+      obj.key = message.key;
+    }
+    if (message.value !== "") {
+      obj.value = message.value;
+    }
+    return obj;
+  },
+  create(base) {
+    return MediaEvent_SdpOffer_MidToTrackIdEntry.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseMediaEvent_SdpOffer_MidToTrackIdEntry();
+    message.key = object.key ?? "";
+    message.value = object.value ?? "";
+    return message;
+  }
+};
+function createBaseMediaEvent_TrackBitrates() {
+  return { trackId: "", variantBitrates: [] };
+}
+var MediaEvent_TrackBitrates = {
+  encode(message, writer = new BinaryWriter2()) {
+    if (message.trackId !== "") {
+      writer.uint32(10).string(message.trackId);
+    }
+    for (const v of message.variantBitrates) {
+      MediaEvent_VariantBitrate.encode(v, writer.uint32(18).fork()).join();
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof BinaryReader2 ? input : new BinaryReader2(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseMediaEvent_TrackBitrates();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.trackId = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.variantBitrates.push(MediaEvent_VariantBitrate.decode(reader, reader.uint32()));
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      trackId: isSet2(object.trackId) ? globalThis.String(object.trackId) : "",
+      variantBitrates: globalThis.Array.isArray(object?.variantBitrates) ? object.variantBitrates.map((e) => MediaEvent_VariantBitrate.fromJSON(e)) : []
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.trackId !== "") {
+      obj.trackId = message.trackId;
+    }
+    if (message.variantBitrates?.length) {
+      obj.variantBitrates = message.variantBitrates.map((e) => MediaEvent_VariantBitrate.toJSON(e));
+    }
+    return obj;
+  },
+  create(base) {
+    return MediaEvent_TrackBitrates.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseMediaEvent_TrackBitrates();
+    message.trackId = object.trackId ?? "";
+    message.variantBitrates = object.variantBitrates?.map((e) => MediaEvent_VariantBitrate.fromPartial(e)) || [];
+    return message;
+  }
+};
+function createBaseMediaEvent_DisableTrackVariant() {
+  return { trackId: "", variant: 0 };
+}
+var MediaEvent_DisableTrackVariant = {
+  encode(message, writer = new BinaryWriter2()) {
+    if (message.trackId !== "") {
+      writer.uint32(10).string(message.trackId);
+    }
+    if (message.variant !== 0) {
+      writer.uint32(16).int32(message.variant);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof BinaryReader2 ? input : new BinaryReader2(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseMediaEvent_DisableTrackVariant();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.trackId = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 16) {
+            break;
+          }
+          message.variant = reader.int32();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      trackId: isSet2(object.trackId) ? globalThis.String(object.trackId) : "",
+      variant: isSet2(object.variant) ? variantFromJSON(object.variant) : 0
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.trackId !== "") {
+      obj.trackId = message.trackId;
+    }
+    if (message.variant !== 0) {
+      obj.variant = variantToJSON(message.variant);
+    }
+    return obj;
+  },
+  create(base) {
+    return MediaEvent_DisableTrackVariant.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseMediaEvent_DisableTrackVariant();
+    message.trackId = object.trackId ?? "";
+    message.variant = object.variant ?? 0;
+    return message;
+  }
+};
+function createBaseMediaEvent_EnableTrackVariant() {
+  return { trackId: "", variant: 0 };
+}
+var MediaEvent_EnableTrackVariant = {
+  encode(message, writer = new BinaryWriter2()) {
+    if (message.trackId !== "") {
+      writer.uint32(10).string(message.trackId);
+    }
+    if (message.variant !== 0) {
+      writer.uint32(16).int32(message.variant);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof BinaryReader2 ? input : new BinaryReader2(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseMediaEvent_EnableTrackVariant();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.trackId = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 16) {
+            break;
+          }
+          message.variant = reader.int32();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      trackId: isSet2(object.trackId) ? globalThis.String(object.trackId) : "",
+      variant: isSet2(object.variant) ? variantFromJSON(object.variant) : 0
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.trackId !== "") {
+      obj.trackId = message.trackId;
+    }
+    if (message.variant !== 0) {
+      obj.variant = variantToJSON(message.variant);
+    }
+    return obj;
+  },
+  create(base) {
+    return MediaEvent_EnableTrackVariant.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseMediaEvent_EnableTrackVariant();
+    message.trackId = object.trackId ?? "";
+    message.variant = object.variant ?? 0;
+    return message;
+  }
+};
+function createBaseMediaEvent_SetTargetTrackVariant() {
+  return { trackId: "", variant: 0 };
+}
+var MediaEvent_SetTargetTrackVariant = {
+  encode(message, writer = new BinaryWriter2()) {
+    if (message.trackId !== "") {
+      writer.uint32(10).string(message.trackId);
+    }
+    if (message.variant !== 0) {
+      writer.uint32(16).int32(message.variant);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof BinaryReader2 ? input : new BinaryReader2(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseMediaEvent_SetTargetTrackVariant();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.trackId = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 16) {
+            break;
+          }
+          message.variant = reader.int32();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      trackId: isSet2(object.trackId) ? globalThis.String(object.trackId) : "",
+      variant: isSet2(object.variant) ? variantFromJSON(object.variant) : 0
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.trackId !== "") {
+      obj.trackId = message.trackId;
+    }
+    if (message.variant !== 0) {
+      obj.variant = variantToJSON(message.variant);
+    }
+    return obj;
+  },
+  create(base) {
+    return MediaEvent_SetTargetTrackVariant.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseMediaEvent_SetTargetTrackVariant();
+    message.trackId = object.trackId ?? "";
+    message.variant = object.variant ?? 0;
+    return message;
+  }
+};
+function isObject(value) {
+  return typeof value === "object" && value !== null;
+}
+function isSet2(value) {
+  return value !== null && value !== void 0;
+}
+
+// src/webRTCEndpoint.ts
+import EventEmitter2 from "events";
+import { v4 as uuidv4 } from "uuid";
+
+// src/CommandsQueue.ts
+var CommandsQueue = class {
+  localTrackManager;
+  connection = null;
+  clearConnectionCallbacks = null;
+  constructor(localTrackManager) {
+    this.localTrackManager = localTrackManager;
+  }
+  initConnection = (connection) => {
+    this.connection = connection;
+    const onSignalingStateChange = () => {
+      if (connection.getConnection().signalingState === "stable") {
+        this.processNextCommand();
+      }
+    };
+    const onIceGatheringStateChange = () => {
+      if (connection.getConnection().iceGatheringState === "complete") {
+        this.processNextCommand();
+      }
+    };
+    const onConnectionStateChange = () => {
+      if (connection.getConnection().connectionState === "connected") {
+        this.processNextCommand();
+      }
+    };
+    const onIceConnectionStateChange = () => {
+      if (connection.getConnection().iceConnectionState === "connected") {
+        this.processNextCommand();
+      }
+    };
+    this.clearConnectionCallbacks = () => {
+      connection.getConnection().removeEventListener("signalingstatechange", onSignalingStateChange);
+      connection.getConnection().removeEventListener("icegatheringstatechange", onIceGatheringStateChange);
+      connection.getConnection().removeEventListener("connectionstatechange", onConnectionStateChange);
+      connection.getConnection().removeEventListener("iceconnectionstatechange", onIceConnectionStateChange);
+    };
+    connection.getConnection().addEventListener("icegatheringstatechange", onIceConnectionStateChange);
+    connection.getConnection().addEventListener("connectionstatechange", onConnectionStateChange);
+    connection.getConnection().addEventListener("iceconnectionstatechange", onIceConnectionStateChange);
+    connection.getConnection().addEventListener("signalingstatechange", onSignalingStateChange);
+  };
+  commandsQueue = [];
+  commandResolutionNotifier = null;
+  pushCommand = (command) => {
+    this.commandsQueue.push(command);
+    this.processNextCommand();
+  };
+  processNextCommand = () => {
+    if (this.localTrackManager.isNegotiationInProgress()) return;
+    if (this.connection?.isConnectionUnstable()) return;
+    this.resolvePreviousCommand();
+    const command = this.commandsQueue.shift();
+    if (!command) return;
+    this.commandResolutionNotifier = command.resolutionNotifier;
+    this.handleCommand(command);
+  };
+  handleCommand = async (command) => {
+    try {
+      command.parse?.();
+      const promise = command.handler();
+      if (command.resolve === "on-handler-resolve") {
+        await promise;
+        this.resolvePreviousCommand();
+        this.processNextCommand();
+      }
+    } catch (error) {
+      this.commandResolutionNotifier?.reject(error);
+      this.commandResolutionNotifier = null;
+      this.processNextCommand();
+    }
+  };
+  resolvePreviousCommand = () => {
+    if (!this.commandResolutionNotifier) return;
+    this.commandResolutionNotifier.resolve();
+    this.commandResolutionNotifier = null;
+  };
+  cleanUp = () => {
+    this.commandResolutionNotifier?.reject("Disconnected");
+    this.commandResolutionNotifier = null;
+    this.commandsQueue = [];
+    this.clearConnectionCallbacks?.();
+  };
+};
+
+// src/ConnectionManager.ts
+var ConnectionManager = class {
+  connection;
+  constructor(iceServers) {
+    this.connection = new RTCPeerConnection({
+      bundlePolicy: "max-bundle",
+      iceServers,
+      iceTransportPolicy: "all"
+    });
+  }
+  isConnectionUnstable = () => {
+    if (!this.connection) return false;
+    const isSignalingUnstable = this.connection.signalingState !== "stable";
+    const isConnectionNotConnected = this.connection.connectionState !== "connected";
+    const isIceNotConnected = this.connection.iceConnectionState !== "connected";
+    return isSignalingUnstable && isConnectionNotConnected && isIceNotConnected;
+  };
+  getConnection = () => {
+    return this.connection;
+  };
+  addTransceiversIfNeeded = (serverTracks) => {
+    const recvTransceivers = this.connection.getTransceivers().filter((elem) => elem.direction === "recvonly");
+    const videoTransceiversAmount = recvTransceivers.filter((elem) => elem.receiver.track.kind === "video").length;
+    const audioTransceiversAmount = recvTransceivers.filter((elem) => elem.receiver.track.kind === "audio").length;
+    const videoNeededTypes = Array(serverTracks.video - videoTransceiversAmount).fill("video");
+    const audioNeededTypes = Array(serverTracks.audio - audioTransceiversAmount).fill("audio");
+    [...videoNeededTypes, ...audioNeededTypes].forEach(
+      (kind) => this.connection.addTransceiver(kind, { direction: "recvonly" })
+    );
+  };
+  addTransceiver = (track, transceiverConfig) => {
+    this.connection.addTransceiver(track, transceiverConfig);
+  };
+  setOnTrackReady = (onTrackReady) => {
+    this.connection.ontrack = onTrackReady;
+  };
+  setRemoteDescription = async (data) => {
+    await this.connection.setRemoteDescription(data);
+  };
+  isTrackInUse = (track) => this.connection.getSenders().some((val) => val.track === track);
+  removeTrack = (sender) => {
+    this.connection.removeTrack(sender);
+  };
+  findSender = (mediaStreamTrackId) => this.connection.getSenders().find((sender) => sender.track && sender.track.id === mediaStreamTrackId);
+  addIceCandidate = async (iceCandidate) => {
+    await this.connection.addIceCandidate(iceCandidate);
+  };
+};
+
+// src/deferred.ts
+var Deferred = class {
+  promise;
+  resolveFn = () => null;
+  rejectFn = () => null;
+  constructor() {
+    this.promise = new Promise((resolve, reject) => {
+      this.resolveFn = resolve;
+      this.rejectFn = reject;
+    });
+  }
+  resolve(value) {
+    this.resolveFn(value);
+  }
+  reject(reason) {
+    this.rejectFn(reason);
+  }
+};
+
+// ../protobufs/fishjam/media_events/server/server.ts
+import { BinaryReader as BinaryReader3, BinaryWriter as BinaryWriter3 } from "@bufbuild/protobuf/wire";
+function mediaEvent_VadNotification_StatusFromJSON(object) {
+  switch (object) {
+    case 0:
+    case "STATUS_UNSPECIFIED":
+      return 0 /* STATUS_UNSPECIFIED */;
+    case 1:
+    case "STATUS_SILENCE":
+      return 1 /* STATUS_SILENCE */;
+    case 2:
+    case "STATUS_SPEECH":
+      return 2 /* STATUS_SPEECH */;
+    case -1:
+    case "UNRECOGNIZED":
+    default:
+      return -1 /* UNRECOGNIZED */;
+  }
+}
+function mediaEvent_VadNotification_StatusToJSON(object) {
+  switch (object) {
+    case 0 /* STATUS_UNSPECIFIED */:
+      return "STATUS_UNSPECIFIED";
+    case 1 /* STATUS_SILENCE */:
+      return "STATUS_SILENCE";
+    case 2 /* STATUS_SPEECH */:
+      return "STATUS_SPEECH";
+    case -1 /* UNRECOGNIZED */:
+    default:
+      return "UNRECOGNIZED";
+  }
+}
+function createBaseMediaEvent2() {
+  return {
+    endpointUpdated: void 0,
+    trackUpdated: void 0,
+    tracksAdded: void 0,
+    tracksRemoved: void 0,
+    endpointAdded: void 0,
+    endpointRemoved: void 0,
+    connected: void 0,
+    error: void 0,
+    offerData: void 0,
+    candidate: void 0,
+    sdpAnswer: void 0,
+    vadNotification: void 0,
+    trackVariantSwitched: void 0,
+    trackVariantDisabled: void 0,
+    trackVariantEnabled: void 0
+  };
+}
+var MediaEvent2 = {
+  encode(message, writer = new BinaryWriter3()) {
+    if (message.endpointUpdated !== void 0) {
+      MediaEvent_EndpointUpdated.encode(message.endpointUpdated, writer.uint32(10).fork()).join();
+    }
+    if (message.trackUpdated !== void 0) {
+      MediaEvent_TrackUpdated.encode(message.trackUpdated, writer.uint32(18).fork()).join();
+    }
+    if (message.tracksAdded !== void 0) {
+      MediaEvent_TracksAdded.encode(message.tracksAdded, writer.uint32(26).fork()).join();
+    }
+    if (message.tracksRemoved !== void 0) {
+      MediaEvent_TracksRemoved.encode(message.tracksRemoved, writer.uint32(34).fork()).join();
+    }
+    if (message.endpointAdded !== void 0) {
+      MediaEvent_EndpointAdded.encode(message.endpointAdded, writer.uint32(42).fork()).join();
+    }
+    if (message.endpointRemoved !== void 0) {
+      MediaEvent_EndpointRemoved.encode(message.endpointRemoved, writer.uint32(50).fork()).join();
+    }
+    if (message.connected !== void 0) {
+      MediaEvent_Connected.encode(message.connected, writer.uint32(58).fork()).join();
+    }
+    if (message.error !== void 0) {
+      MediaEvent_Error.encode(message.error, writer.uint32(66).fork()).join();
+    }
+    if (message.offerData !== void 0) {
+      MediaEvent_OfferData.encode(message.offerData, writer.uint32(74).fork()).join();
+    }
+    if (message.candidate !== void 0) {
+      Candidate.encode(message.candidate, writer.uint32(82).fork()).join();
+    }
+    if (message.sdpAnswer !== void 0) {
+      MediaEvent_SdpAnswer.encode(message.sdpAnswer, writer.uint32(90).fork()).join();
+    }
+    if (message.vadNotification !== void 0) {
+      MediaEvent_VadNotification.encode(message.vadNotification, writer.uint32(98).fork()).join();
+    }
+    if (message.trackVariantSwitched !== void 0) {
+      MediaEvent_TrackVariantSwitched.encode(message.trackVariantSwitched, writer.uint32(106).fork()).join();
+    }
+    if (message.trackVariantDisabled !== void 0) {
+      MediaEvent_TrackVariantDisabled.encode(message.trackVariantDisabled, writer.uint32(114).fork()).join();
+    }
+    if (message.trackVariantEnabled !== void 0) {
+      MediaEvent_TrackVariantEnabled.encode(message.trackVariantEnabled, writer.uint32(122).fork()).join();
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof BinaryReader3 ? input : new BinaryReader3(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseMediaEvent2();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.endpointUpdated = MediaEvent_EndpointUpdated.decode(reader, reader.uint32());
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.trackUpdated = MediaEvent_TrackUpdated.decode(reader, reader.uint32());
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+          message.tracksAdded = MediaEvent_TracksAdded.decode(reader, reader.uint32());
+          continue;
+        }
+        case 4: {
+          if (tag !== 34) {
+            break;
+          }
+          message.tracksRemoved = MediaEvent_TracksRemoved.decode(reader, reader.uint32());
+          continue;
+        }
+        case 5: {
+          if (tag !== 42) {
+            break;
+          }
+          message.endpointAdded = MediaEvent_EndpointAdded.decode(reader, reader.uint32());
+          continue;
+        }
+        case 6: {
+          if (tag !== 50) {
+            break;
+          }
+          message.endpointRemoved = MediaEvent_EndpointRemoved.decode(reader, reader.uint32());
+          continue;
+        }
+        case 7: {
+          if (tag !== 58) {
+            break;
+          }
+          message.connected = MediaEvent_Connected.decode(reader, reader.uint32());
+          continue;
+        }
+        case 8: {
+          if (tag !== 66) {
+            break;
+          }
+          message.error = MediaEvent_Error.decode(reader, reader.uint32());
+          continue;
+        }
+        case 9: {
+          if (tag !== 74) {
+            break;
+          }
+          message.offerData = MediaEvent_OfferData.decode(reader, reader.uint32());
+          continue;
+        }
+        case 10: {
+          if (tag !== 82) {
+            break;
+          }
+          message.candidate = Candidate.decode(reader, reader.uint32());
+          continue;
+        }
+        case 11: {
+          if (tag !== 90) {
+            break;
+          }
+          message.sdpAnswer = MediaEvent_SdpAnswer.decode(reader, reader.uint32());
+          continue;
+        }
+        case 12: {
+          if (tag !== 98) {
+            break;
+          }
+          message.vadNotification = MediaEvent_VadNotification.decode(reader, reader.uint32());
+          continue;
+        }
+        case 13: {
+          if (tag !== 106) {
+            break;
+          }
+          message.trackVariantSwitched = MediaEvent_TrackVariantSwitched.decode(reader, reader.uint32());
+          continue;
+        }
+        case 14: {
+          if (tag !== 114) {
+            break;
+          }
+          message.trackVariantDisabled = MediaEvent_TrackVariantDisabled.decode(reader, reader.uint32());
+          continue;
+        }
+        case 15: {
+          if (tag !== 122) {
+            break;
+          }
+          message.trackVariantEnabled = MediaEvent_TrackVariantEnabled.decode(reader, reader.uint32());
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      endpointUpdated: isSet3(object.endpointUpdated) ? MediaEvent_EndpointUpdated.fromJSON(object.endpointUpdated) : void 0,
+      trackUpdated: isSet3(object.trackUpdated) ? MediaEvent_TrackUpdated.fromJSON(object.trackUpdated) : void 0,
+      tracksAdded: isSet3(object.tracksAdded) ? MediaEvent_TracksAdded.fromJSON(object.tracksAdded) : void 0,
+      tracksRemoved: isSet3(object.tracksRemoved) ? MediaEvent_TracksRemoved.fromJSON(object.tracksRemoved) : void 0,
+      endpointAdded: isSet3(object.endpointAdded) ? MediaEvent_EndpointAdded.fromJSON(object.endpointAdded) : void 0,
+      endpointRemoved: isSet3(object.endpointRemoved) ? MediaEvent_EndpointRemoved.fromJSON(object.endpointRemoved) : void 0,
+      connected: isSet3(object.connected) ? MediaEvent_Connected.fromJSON(object.connected) : void 0,
+      error: isSet3(object.error) ? MediaEvent_Error.fromJSON(object.error) : void 0,
+      offerData: isSet3(object.offerData) ? MediaEvent_OfferData.fromJSON(object.offerData) : void 0,
+      candidate: isSet3(object.candidate) ? Candidate.fromJSON(object.candidate) : void 0,
+      sdpAnswer: isSet3(object.sdpAnswer) ? MediaEvent_SdpAnswer.fromJSON(object.sdpAnswer) : void 0,
+      vadNotification: isSet3(object.vadNotification) ? MediaEvent_VadNotification.fromJSON(object.vadNotification) : void 0,
+      trackVariantSwitched: isSet3(object.trackVariantSwitched) ? MediaEvent_TrackVariantSwitched.fromJSON(object.trackVariantSwitched) : void 0,
+      trackVariantDisabled: isSet3(object.trackVariantDisabled) ? MediaEvent_TrackVariantDisabled.fromJSON(object.trackVariantDisabled) : void 0,
+      trackVariantEnabled: isSet3(object.trackVariantEnabled) ? MediaEvent_TrackVariantEnabled.fromJSON(object.trackVariantEnabled) : void 0
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.endpointUpdated !== void 0) {
+      obj.endpointUpdated = MediaEvent_EndpointUpdated.toJSON(message.endpointUpdated);
+    }
+    if (message.trackUpdated !== void 0) {
+      obj.trackUpdated = MediaEvent_TrackUpdated.toJSON(message.trackUpdated);
+    }
+    if (message.tracksAdded !== void 0) {
+      obj.tracksAdded = MediaEvent_TracksAdded.toJSON(message.tracksAdded);
+    }
+    if (message.tracksRemoved !== void 0) {
+      obj.tracksRemoved = MediaEvent_TracksRemoved.toJSON(message.tracksRemoved);
+    }
+    if (message.endpointAdded !== void 0) {
+      obj.endpointAdded = MediaEvent_EndpointAdded.toJSON(message.endpointAdded);
+    }
+    if (message.endpointRemoved !== void 0) {
+      obj.endpointRemoved = MediaEvent_EndpointRemoved.toJSON(message.endpointRemoved);
+    }
+    if (message.connected !== void 0) {
+      obj.connected = MediaEvent_Connected.toJSON(message.connected);
+    }
+    if (message.error !== void 0) {
+      obj.error = MediaEvent_Error.toJSON(message.error);
+    }
+    if (message.offerData !== void 0) {
+      obj.offerData = MediaEvent_OfferData.toJSON(message.offerData);
+    }
+    if (message.candidate !== void 0) {
+      obj.candidate = Candidate.toJSON(message.candidate);
+    }
+    if (message.sdpAnswer !== void 0) {
+      obj.sdpAnswer = MediaEvent_SdpAnswer.toJSON(message.sdpAnswer);
+    }
+    if (message.vadNotification !== void 0) {
+      obj.vadNotification = MediaEvent_VadNotification.toJSON(message.vadNotification);
+    }
+    if (message.trackVariantSwitched !== void 0) {
+      obj.trackVariantSwitched = MediaEvent_TrackVariantSwitched.toJSON(message.trackVariantSwitched);
+    }
+    if (message.trackVariantDisabled !== void 0) {
+      obj.trackVariantDisabled = MediaEvent_TrackVariantDisabled.toJSON(message.trackVariantDisabled);
+    }
+    if (message.trackVariantEnabled !== void 0) {
+      obj.trackVariantEnabled = MediaEvent_TrackVariantEnabled.toJSON(message.trackVariantEnabled);
+    }
+    return obj;
+  },
+  create(base) {
+    return MediaEvent2.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseMediaEvent2();
+    message.endpointUpdated = object.endpointUpdated !== void 0 && object.endpointUpdated !== null ? MediaEvent_EndpointUpdated.fromPartial(object.endpointUpdated) : void 0;
+    message.trackUpdated = object.trackUpdated !== void 0 && object.trackUpdated !== null ? MediaEvent_TrackUpdated.fromPartial(object.trackUpdated) : void 0;
+    message.tracksAdded = object.tracksAdded !== void 0 && object.tracksAdded !== null ? MediaEvent_TracksAdded.fromPartial(object.tracksAdded) : void 0;
+    message.tracksRemoved = object.tracksRemoved !== void 0 && object.tracksRemoved !== null ? MediaEvent_TracksRemoved.fromPartial(object.tracksRemoved) : void 0;
+    message.endpointAdded = object.endpointAdded !== void 0 && object.endpointAdded !== null ? MediaEvent_EndpointAdded.fromPartial(object.endpointAdded) : void 0;
+    message.endpointRemoved = object.endpointRemoved !== void 0 && object.endpointRemoved !== null ? MediaEvent_EndpointRemoved.fromPartial(object.endpointRemoved) : void 0;
+    message.connected = object.connected !== void 0 && object.connected !== null ? MediaEvent_Connected.fromPartial(object.connected) : void 0;
+    message.error = object.error !== void 0 && object.error !== null ? MediaEvent_Error.fromPartial(object.error) : void 0;
+    message.offerData = object.offerData !== void 0 && object.offerData !== null ? MediaEvent_OfferData.fromPartial(object.offerData) : void 0;
+    message.candidate = object.candidate !== void 0 && object.candidate !== null ? Candidate.fromPartial(object.candidate) : void 0;
+    message.sdpAnswer = object.sdpAnswer !== void 0 && object.sdpAnswer !== null ? MediaEvent_SdpAnswer.fromPartial(object.sdpAnswer) : void 0;
+    message.vadNotification = object.vadNotification !== void 0 && object.vadNotification !== null ? MediaEvent_VadNotification.fromPartial(object.vadNotification) : void 0;
+    message.trackVariantSwitched = object.trackVariantSwitched !== void 0 && object.trackVariantSwitched !== null ? MediaEvent_TrackVariantSwitched.fromPartial(object.trackVariantSwitched) : void 0;
+    message.trackVariantDisabled = object.trackVariantDisabled !== void 0 && object.trackVariantDisabled !== null ? MediaEvent_TrackVariantDisabled.fromPartial(object.trackVariantDisabled) : void 0;
+    message.trackVariantEnabled = object.trackVariantEnabled !== void 0 && object.trackVariantEnabled !== null ? MediaEvent_TrackVariantEnabled.fromPartial(object.trackVariantEnabled) : void 0;
+    return message;
+  }
+};
+function createBaseMediaEvent_Track() {
+  return { metadataJson: "", simulcastConfig: void 0 };
+}
+var MediaEvent_Track = {
+  encode(message, writer = new BinaryWriter3()) {
+    if (message.metadataJson !== "") {
+      writer.uint32(10).string(message.metadataJson);
+    }
+    if (message.simulcastConfig !== void 0) {
+      MediaEvent_Track_SimulcastConfig.encode(message.simulcastConfig, writer.uint32(18).fork()).join();
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof BinaryReader3 ? input : new BinaryReader3(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseMediaEvent_Track();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.metadataJson = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.simulcastConfig = MediaEvent_Track_SimulcastConfig.decode(reader, reader.uint32());
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      metadataJson: isSet3(object.metadataJson) ? globalThis.String(object.metadataJson) : "",
+      simulcastConfig: isSet3(object.simulcastConfig) ? MediaEvent_Track_SimulcastConfig.fromJSON(object.simulcastConfig) : void 0
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.metadataJson !== "") {
+      obj.metadataJson = message.metadataJson;
+    }
+    if (message.simulcastConfig !== void 0) {
+      obj.simulcastConfig = MediaEvent_Track_SimulcastConfig.toJSON(message.simulcastConfig);
+    }
+    return obj;
+  },
+  create(base) {
+    return MediaEvent_Track.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseMediaEvent_Track();
+    message.metadataJson = object.metadataJson ?? "";
+    message.simulcastConfig = object.simulcastConfig !== void 0 && object.simulcastConfig !== null ? MediaEvent_Track_SimulcastConfig.fromPartial(object.simulcastConfig) : void 0;
+    return message;
+  }
+};
+function createBaseMediaEvent_Track_SimulcastConfig() {
+  return { enabled: false, enabledVariants: [], disabledVariants: [] };
+}
+var MediaEvent_Track_SimulcastConfig = {
+  encode(message, writer = new BinaryWriter3()) {
+    if (message.enabled !== false) {
+      writer.uint32(8).bool(message.enabled);
+    }
+    writer.uint32(18).fork();
+    for (const v of message.enabledVariants) {
+      writer.int32(v);
+    }
+    writer.join();
+    writer.uint32(26).fork();
+    for (const v of message.disabledVariants) {
+      writer.int32(v);
+    }
+    writer.join();
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof BinaryReader3 ? input : new BinaryReader3(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseMediaEvent_Track_SimulcastConfig();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 8) {
+            break;
+          }
+          message.enabled = reader.bool();
+          continue;
+        }
+        case 2: {
+          if (tag === 16) {
+            message.enabledVariants.push(reader.int32());
+            continue;
+          }
+          if (tag === 18) {
+            const end2 = reader.uint32() + reader.pos;
+            while (reader.pos < end2) {
+              message.enabledVariants.push(reader.int32());
+            }
+            continue;
+          }
+          break;
+        }
+        case 3: {
+          if (tag === 24) {
+            message.disabledVariants.push(reader.int32());
+            continue;
+          }
+          if (tag === 26) {
+            const end2 = reader.uint32() + reader.pos;
+            while (reader.pos < end2) {
+              message.disabledVariants.push(reader.int32());
+            }
+            continue;
+          }
+          break;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      enabled: isSet3(object.enabled) ? globalThis.Boolean(object.enabled) : false,
+      enabledVariants: globalThis.Array.isArray(object?.enabledVariants) ? object.enabledVariants.map((e) => variantFromJSON(e)) : [],
+      disabledVariants: globalThis.Array.isArray(object?.disabledVariants) ? object.disabledVariants.map((e) => variantFromJSON(e)) : []
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.enabled !== false) {
+      obj.enabled = message.enabled;
+    }
+    if (message.enabledVariants?.length) {
+      obj.enabledVariants = message.enabledVariants.map((e) => variantToJSON(e));
+    }
+    if (message.disabledVariants?.length) {
+      obj.disabledVariants = message.disabledVariants.map((e) => variantToJSON(e));
+    }
+    return obj;
+  },
+  create(base) {
+    return MediaEvent_Track_SimulcastConfig.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseMediaEvent_Track_SimulcastConfig();
+    message.enabled = object.enabled ?? false;
+    message.enabledVariants = object.enabledVariants?.map((e) => e) || [];
+    message.disabledVariants = object.disabledVariants?.map((e) => e) || [];
+    return message;
+  }
+};
+function createBaseMediaEvent_Endpoint() {
+  return { endpointType: "", metadataJson: "", trackIdToTrack: {} };
+}
+var MediaEvent_Endpoint = {
+  encode(message, writer = new BinaryWriter3()) {
+    if (message.endpointType !== "") {
+      writer.uint32(18).string(message.endpointType);
+    }
+    if (message.metadataJson !== "") {
+      writer.uint32(26).string(message.metadataJson);
+    }
+    Object.entries(message.trackIdToTrack).forEach(([key, value]) => {
+      MediaEvent_Endpoint_TrackIdToTrackEntry.encode({ key, value }, writer.uint32(34).fork()).join();
+    });
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof BinaryReader3 ? input : new BinaryReader3(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseMediaEvent_Endpoint();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.endpointType = reader.string();
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+          message.metadataJson = reader.string();
+          continue;
+        }
+        case 4: {
+          if (tag !== 34) {
+            break;
+          }
+          const entry4 = MediaEvent_Endpoint_TrackIdToTrackEntry.decode(reader, reader.uint32());
+          if (entry4.value !== void 0) {
+            message.trackIdToTrack[entry4.key] = entry4.value;
+          }
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      endpointType: isSet3(object.endpointType) ? globalThis.String(object.endpointType) : "",
+      metadataJson: isSet3(object.metadataJson) ? globalThis.String(object.metadataJson) : "",
+      trackIdToTrack: isObject2(object.trackIdToTrack) ? Object.entries(object.trackIdToTrack).reduce((acc, [key, value]) => {
+        acc[key] = MediaEvent_Track.fromJSON(value);
+        return acc;
+      }, {}) : {}
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.endpointType !== "") {
+      obj.endpointType = message.endpointType;
+    }
+    if (message.metadataJson !== "") {
+      obj.metadataJson = message.metadataJson;
+    }
+    if (message.trackIdToTrack) {
+      const entries = Object.entries(message.trackIdToTrack);
+      if (entries.length > 0) {
+        obj.trackIdToTrack = {};
+        entries.forEach(([k, v]) => {
+          obj.trackIdToTrack[k] = MediaEvent_Track.toJSON(v);
+        });
+      }
+    }
+    return obj;
+  },
+  create(base) {
+    return MediaEvent_Endpoint.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseMediaEvent_Endpoint();
+    message.endpointType = object.endpointType ?? "";
+    message.metadataJson = object.metadataJson ?? "";
+    message.trackIdToTrack = Object.entries(object.trackIdToTrack ?? {}).reduce(
+      (acc, [key, value]) => {
+        if (value !== void 0) {
+          acc[key] = MediaEvent_Track.fromPartial(value);
+        }
+        return acc;
+      },
+      {}
+    );
+    return message;
+  }
+};
+function createBaseMediaEvent_Endpoint_TrackIdToTrackEntry() {
+  return { key: "", value: void 0 };
+}
+var MediaEvent_Endpoint_TrackIdToTrackEntry = {
+  encode(message, writer = new BinaryWriter3()) {
+    if (message.key !== "") {
+      writer.uint32(10).string(message.key);
+    }
+    if (message.value !== void 0) {
+      MediaEvent_Track.encode(message.value, writer.uint32(18).fork()).join();
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof BinaryReader3 ? input : new BinaryReader3(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseMediaEvent_Endpoint_TrackIdToTrackEntry();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.key = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.value = MediaEvent_Track.decode(reader, reader.uint32());
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      key: isSet3(object.key) ? globalThis.String(object.key) : "",
+      value: isSet3(object.value) ? MediaEvent_Track.fromJSON(object.value) : void 0
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.key !== "") {
+      obj.key = message.key;
+    }
+    if (message.value !== void 0) {
+      obj.value = MediaEvent_Track.toJSON(message.value);
+    }
+    return obj;
+  },
+  create(base) {
+    return MediaEvent_Endpoint_TrackIdToTrackEntry.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseMediaEvent_Endpoint_TrackIdToTrackEntry();
+    message.key = object.key ?? "";
+    message.value = object.value !== void 0 && object.value !== null ? MediaEvent_Track.fromPartial(object.value) : void 0;
+    return message;
+  }
+};
+function createBaseMediaEvent_IceServer() {
+  return { credential: "", urls: [], username: "" };
+}
+var MediaEvent_IceServer = {
+  encode(message, writer = new BinaryWriter3()) {
+    if (message.credential !== "") {
+      writer.uint32(10).string(message.credential);
+    }
+    for (const v of message.urls) {
+      writer.uint32(18).string(v);
+    }
+    if (message.username !== "") {
+      writer.uint32(26).string(message.username);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof BinaryReader3 ? input : new BinaryReader3(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseMediaEvent_IceServer();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.credential = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.urls.push(reader.string());
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+          message.username = reader.string();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      credential: isSet3(object.credential) ? globalThis.String(object.credential) : "",
+      urls: globalThis.Array.isArray(object?.urls) ? object.urls.map((e) => globalThis.String(e)) : [],
+      username: isSet3(object.username) ? globalThis.String(object.username) : ""
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.credential !== "") {
+      obj.credential = message.credential;
+    }
+    if (message.urls?.length) {
+      obj.urls = message.urls;
+    }
+    if (message.username !== "") {
+      obj.username = message.username;
+    }
+    return obj;
+  },
+  create(base) {
+    return MediaEvent_IceServer.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseMediaEvent_IceServer();
+    message.credential = object.credential ?? "";
+    message.urls = object.urls?.map((e) => e) || [];
+    message.username = object.username ?? "";
+    return message;
+  }
+};
+function createBaseMediaEvent_EndpointUpdated() {
+  return { endpointId: "", metadataJson: "" };
+}
+var MediaEvent_EndpointUpdated = {
+  encode(message, writer = new BinaryWriter3()) {
+    if (message.endpointId !== "") {
+      writer.uint32(10).string(message.endpointId);
+    }
+    if (message.metadataJson !== "") {
+      writer.uint32(18).string(message.metadataJson);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof BinaryReader3 ? input : new BinaryReader3(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseMediaEvent_EndpointUpdated();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.endpointId = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.metadataJson = reader.string();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      endpointId: isSet3(object.endpointId) ? globalThis.String(object.endpointId) : "",
+      metadataJson: isSet3(object.metadataJson) ? globalThis.String(object.metadataJson) : ""
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.endpointId !== "") {
+      obj.endpointId = message.endpointId;
+    }
+    if (message.metadataJson !== "") {
+      obj.metadataJson = message.metadataJson;
+    }
+    return obj;
+  },
+  create(base) {
+    return MediaEvent_EndpointUpdated.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseMediaEvent_EndpointUpdated();
+    message.endpointId = object.endpointId ?? "";
+    message.metadataJson = object.metadataJson ?? "";
+    return message;
+  }
+};
+function createBaseMediaEvent_TrackUpdated() {
+  return { endpointId: "", trackId: "", metadataJson: "" };
+}
+var MediaEvent_TrackUpdated = {
+  encode(message, writer = new BinaryWriter3()) {
+    if (message.endpointId !== "") {
+      writer.uint32(10).string(message.endpointId);
+    }
+    if (message.trackId !== "") {
+      writer.uint32(18).string(message.trackId);
+    }
+    if (message.metadataJson !== "") {
+      writer.uint32(26).string(message.metadataJson);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof BinaryReader3 ? input : new BinaryReader3(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseMediaEvent_TrackUpdated();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.endpointId = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.trackId = reader.string();
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+          message.metadataJson = reader.string();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      endpointId: isSet3(object.endpointId) ? globalThis.String(object.endpointId) : "",
+      trackId: isSet3(object.trackId) ? globalThis.String(object.trackId) : "",
+      metadataJson: isSet3(object.metadataJson) ? globalThis.String(object.metadataJson) : ""
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.endpointId !== "") {
+      obj.endpointId = message.endpointId;
+    }
+    if (message.trackId !== "") {
+      obj.trackId = message.trackId;
+    }
+    if (message.metadataJson !== "") {
+      obj.metadataJson = message.metadataJson;
+    }
+    return obj;
+  },
+  create(base) {
+    return MediaEvent_TrackUpdated.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseMediaEvent_TrackUpdated();
+    message.endpointId = object.endpointId ?? "";
+    message.trackId = object.trackId ?? "";
+    message.metadataJson = object.metadataJson ?? "";
+    return message;
+  }
+};
+function createBaseMediaEvent_TracksAdded() {
+  return { endpointId: "", trackIdToTrack: {} };
+}
+var MediaEvent_TracksAdded = {
+  encode(message, writer = new BinaryWriter3()) {
+    if (message.endpointId !== "") {
+      writer.uint32(10).string(message.endpointId);
+    }
+    Object.entries(message.trackIdToTrack).forEach(([key, value]) => {
+      MediaEvent_TracksAdded_TrackIdToTrackEntry.encode({ key, value }, writer.uint32(18).fork()).join();
+    });
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof BinaryReader3 ? input : new BinaryReader3(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseMediaEvent_TracksAdded();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.endpointId = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          const entry2 = MediaEvent_TracksAdded_TrackIdToTrackEntry.decode(reader, reader.uint32());
+          if (entry2.value !== void 0) {
+            message.trackIdToTrack[entry2.key] = entry2.value;
+          }
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      endpointId: isSet3(object.endpointId) ? globalThis.String(object.endpointId) : "",
+      trackIdToTrack: isObject2(object.trackIdToTrack) ? Object.entries(object.trackIdToTrack).reduce((acc, [key, value]) => {
+        acc[key] = MediaEvent_Track.fromJSON(value);
+        return acc;
+      }, {}) : {}
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.endpointId !== "") {
+      obj.endpointId = message.endpointId;
+    }
+    if (message.trackIdToTrack) {
+      const entries = Object.entries(message.trackIdToTrack);
+      if (entries.length > 0) {
+        obj.trackIdToTrack = {};
+        entries.forEach(([k, v]) => {
+          obj.trackIdToTrack[k] = MediaEvent_Track.toJSON(v);
+        });
+      }
+    }
+    return obj;
+  },
+  create(base) {
+    return MediaEvent_TracksAdded.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseMediaEvent_TracksAdded();
+    message.endpointId = object.endpointId ?? "";
+    message.trackIdToTrack = Object.entries(object.trackIdToTrack ?? {}).reduce(
+      (acc, [key, value]) => {
+        if (value !== void 0) {
+          acc[key] = MediaEvent_Track.fromPartial(value);
+        }
+        return acc;
+      },
+      {}
+    );
+    return message;
+  }
+};
+function createBaseMediaEvent_TracksAdded_TrackIdToTrackEntry() {
+  return { key: "", value: void 0 };
+}
+var MediaEvent_TracksAdded_TrackIdToTrackEntry = {
+  encode(message, writer = new BinaryWriter3()) {
+    if (message.key !== "") {
+      writer.uint32(10).string(message.key);
+    }
+    if (message.value !== void 0) {
+      MediaEvent_Track.encode(message.value, writer.uint32(18).fork()).join();
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof BinaryReader3 ? input : new BinaryReader3(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseMediaEvent_TracksAdded_TrackIdToTrackEntry();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.key = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.value = MediaEvent_Track.decode(reader, reader.uint32());
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      key: isSet3(object.key) ? globalThis.String(object.key) : "",
+      value: isSet3(object.value) ? MediaEvent_Track.fromJSON(object.value) : void 0
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.key !== "") {
+      obj.key = message.key;
+    }
+    if (message.value !== void 0) {
+      obj.value = MediaEvent_Track.toJSON(message.value);
+    }
+    return obj;
+  },
+  create(base) {
+    return MediaEvent_TracksAdded_TrackIdToTrackEntry.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseMediaEvent_TracksAdded_TrackIdToTrackEntry();
+    message.key = object.key ?? "";
+    message.value = object.value !== void 0 && object.value !== null ? MediaEvent_Track.fromPartial(object.value) : void 0;
+    return message;
+  }
+};
+function createBaseMediaEvent_TracksRemoved() {
+  return { endpointId: "", trackIds: [] };
+}
+var MediaEvent_TracksRemoved = {
+  encode(message, writer = new BinaryWriter3()) {
+    if (message.endpointId !== "") {
+      writer.uint32(10).string(message.endpointId);
+    }
+    for (const v of message.trackIds) {
+      writer.uint32(18).string(v);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof BinaryReader3 ? input : new BinaryReader3(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseMediaEvent_TracksRemoved();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.endpointId = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.trackIds.push(reader.string());
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      endpointId: isSet3(object.endpointId) ? globalThis.String(object.endpointId) : "",
+      trackIds: globalThis.Array.isArray(object?.trackIds) ? object.trackIds.map((e) => globalThis.String(e)) : []
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.endpointId !== "") {
+      obj.endpointId = message.endpointId;
+    }
+    if (message.trackIds?.length) {
+      obj.trackIds = message.trackIds;
+    }
+    return obj;
+  },
+  create(base) {
+    return MediaEvent_TracksRemoved.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseMediaEvent_TracksRemoved();
+    message.endpointId = object.endpointId ?? "";
+    message.trackIds = object.trackIds?.map((e) => e) || [];
+    return message;
+  }
+};
+function createBaseMediaEvent_EndpointAdded() {
+  return { endpointId: "", metadataJson: "" };
+}
+var MediaEvent_EndpointAdded = {
+  encode(message, writer = new BinaryWriter3()) {
+    if (message.endpointId !== "") {
+      writer.uint32(10).string(message.endpointId);
+    }
+    if (message.metadataJson !== "") {
+      writer.uint32(18).string(message.metadataJson);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof BinaryReader3 ? input : new BinaryReader3(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseMediaEvent_EndpointAdded();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.endpointId = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.metadataJson = reader.string();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      endpointId: isSet3(object.endpointId) ? globalThis.String(object.endpointId) : "",
+      metadataJson: isSet3(object.metadataJson) ? globalThis.String(object.metadataJson) : ""
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.endpointId !== "") {
+      obj.endpointId = message.endpointId;
+    }
+    if (message.metadataJson !== "") {
+      obj.metadataJson = message.metadataJson;
+    }
+    return obj;
+  },
+  create(base) {
+    return MediaEvent_EndpointAdded.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseMediaEvent_EndpointAdded();
+    message.endpointId = object.endpointId ?? "";
+    message.metadataJson = object.metadataJson ?? "";
+    return message;
+  }
+};
+function createBaseMediaEvent_Connected() {
+  return { endpointId: "", endpointIdToEndpoint: {}, iceServers: [] };
+}
+var MediaEvent_Connected = {
+  encode(message, writer = new BinaryWriter3()) {
+    if (message.endpointId !== "") {
+      writer.uint32(10).string(message.endpointId);
+    }
+    Object.entries(message.endpointIdToEndpoint).forEach(([key, value]) => {
+      MediaEvent_Connected_EndpointIdToEndpointEntry.encode({ key, value }, writer.uint32(18).fork()).join();
+    });
+    for (const v of message.iceServers) {
+      MediaEvent_IceServer.encode(v, writer.uint32(26).fork()).join();
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof BinaryReader3 ? input : new BinaryReader3(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseMediaEvent_Connected();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.endpointId = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          const entry2 = MediaEvent_Connected_EndpointIdToEndpointEntry.decode(reader, reader.uint32());
+          if (entry2.value !== void 0) {
+            message.endpointIdToEndpoint[entry2.key] = entry2.value;
+          }
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+          message.iceServers.push(MediaEvent_IceServer.decode(reader, reader.uint32()));
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      endpointId: isSet3(object.endpointId) ? globalThis.String(object.endpointId) : "",
+      endpointIdToEndpoint: isObject2(object.endpointIdToEndpoint) ? Object.entries(object.endpointIdToEndpoint).reduce(
+        (acc, [key, value]) => {
+          acc[key] = MediaEvent_Endpoint.fromJSON(value);
+          return acc;
+        },
+        {}
+      ) : {},
+      iceServers: globalThis.Array.isArray(object?.iceServers) ? object.iceServers.map((e) => MediaEvent_IceServer.fromJSON(e)) : []
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.endpointId !== "") {
+      obj.endpointId = message.endpointId;
+    }
+    if (message.endpointIdToEndpoint) {
+      const entries = Object.entries(message.endpointIdToEndpoint);
+      if (entries.length > 0) {
+        obj.endpointIdToEndpoint = {};
+        entries.forEach(([k, v]) => {
+          obj.endpointIdToEndpoint[k] = MediaEvent_Endpoint.toJSON(v);
+        });
+      }
+    }
+    if (message.iceServers?.length) {
+      obj.iceServers = message.iceServers.map((e) => MediaEvent_IceServer.toJSON(e));
+    }
+    return obj;
+  },
+  create(base) {
+    return MediaEvent_Connected.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseMediaEvent_Connected();
+    message.endpointId = object.endpointId ?? "";
+    message.endpointIdToEndpoint = Object.entries(object.endpointIdToEndpoint ?? {}).reduce((acc, [key, value]) => {
+      if (value !== void 0) {
+        acc[key] = MediaEvent_Endpoint.fromPartial(value);
+      }
+      return acc;
+    }, {});
+    message.iceServers = object.iceServers?.map((e) => MediaEvent_IceServer.fromPartial(e)) || [];
+    return message;
+  }
+};
+function createBaseMediaEvent_Connected_EndpointIdToEndpointEntry() {
+  return { key: "", value: void 0 };
+}
+var MediaEvent_Connected_EndpointIdToEndpointEntry = {
+  encode(message, writer = new BinaryWriter3()) {
+    if (message.key !== "") {
+      writer.uint32(10).string(message.key);
+    }
+    if (message.value !== void 0) {
+      MediaEvent_Endpoint.encode(message.value, writer.uint32(18).fork()).join();
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof BinaryReader3 ? input : new BinaryReader3(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseMediaEvent_Connected_EndpointIdToEndpointEntry();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.key = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.value = MediaEvent_Endpoint.decode(reader, reader.uint32());
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      key: isSet3(object.key) ? globalThis.String(object.key) : "",
+      value: isSet3(object.value) ? MediaEvent_Endpoint.fromJSON(object.value) : void 0
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.key !== "") {
+      obj.key = message.key;
+    }
+    if (message.value !== void 0) {
+      obj.value = MediaEvent_Endpoint.toJSON(message.value);
+    }
+    return obj;
+  },
+  create(base) {
+    return MediaEvent_Connected_EndpointIdToEndpointEntry.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseMediaEvent_Connected_EndpointIdToEndpointEntry();
+    message.key = object.key ?? "";
+    message.value = object.value !== void 0 && object.value !== null ? MediaEvent_Endpoint.fromPartial(object.value) : void 0;
+    return message;
+  }
+};
+function createBaseMediaEvent_EndpointRemoved() {
+  return { endpointId: "" };
+}
+var MediaEvent_EndpointRemoved = {
+  encode(message, writer = new BinaryWriter3()) {
+    if (message.endpointId !== "") {
+      writer.uint32(10).string(message.endpointId);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof BinaryReader3 ? input : new BinaryReader3(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseMediaEvent_EndpointRemoved();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.endpointId = reader.string();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return { endpointId: isSet3(object.endpointId) ? globalThis.String(object.endpointId) : "" };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.endpointId !== "") {
+      obj.endpointId = message.endpointId;
+    }
+    return obj;
+  },
+  create(base) {
+    return MediaEvent_EndpointRemoved.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseMediaEvent_EndpointRemoved();
+    message.endpointId = object.endpointId ?? "";
+    return message;
+  }
+};
+function createBaseMediaEvent_Error() {
+  return { message: "" };
+}
+var MediaEvent_Error = {
+  encode(message, writer = new BinaryWriter3()) {
+    if (message.message !== "") {
+      writer.uint32(10).string(message.message);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof BinaryReader3 ? input : new BinaryReader3(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseMediaEvent_Error();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.message = reader.string();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return { message: isSet3(object.message) ? globalThis.String(object.message) : "" };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.message !== "") {
+      obj.message = message.message;
+    }
+    return obj;
+  },
+  create(base) {
+    return MediaEvent_Error.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseMediaEvent_Error();
+    message.message = object.message ?? "";
+    return message;
+  }
+};
+function createBaseMediaEvent_OfferData() {
+  return { tracksTypes: void 0 };
+}
+var MediaEvent_OfferData = {
+  encode(message, writer = new BinaryWriter3()) {
+    if (message.tracksTypes !== void 0) {
+      MediaEvent_OfferData_TrackTypes.encode(message.tracksTypes, writer.uint32(10).fork()).join();
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof BinaryReader3 ? input : new BinaryReader3(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseMediaEvent_OfferData();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.tracksTypes = MediaEvent_OfferData_TrackTypes.decode(reader, reader.uint32());
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      tracksTypes: isSet3(object.tracksTypes) ? MediaEvent_OfferData_TrackTypes.fromJSON(object.tracksTypes) : void 0
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.tracksTypes !== void 0) {
+      obj.tracksTypes = MediaEvent_OfferData_TrackTypes.toJSON(message.tracksTypes);
+    }
+    return obj;
+  },
+  create(base) {
+    return MediaEvent_OfferData.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseMediaEvent_OfferData();
+    message.tracksTypes = object.tracksTypes !== void 0 && object.tracksTypes !== null ? MediaEvent_OfferData_TrackTypes.fromPartial(object.tracksTypes) : void 0;
+    return message;
+  }
+};
+function createBaseMediaEvent_OfferData_TrackTypes() {
+  return { audio: 0, video: 0 };
+}
+var MediaEvent_OfferData_TrackTypes = {
+  encode(message, writer = new BinaryWriter3()) {
+    if (message.audio !== 0) {
+      writer.uint32(8).int32(message.audio);
+    }
+    if (message.video !== 0) {
+      writer.uint32(16).int32(message.video);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof BinaryReader3 ? input : new BinaryReader3(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseMediaEvent_OfferData_TrackTypes();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 8) {
+            break;
+          }
+          message.audio = reader.int32();
+          continue;
+        }
+        case 2: {
+          if (tag !== 16) {
+            break;
+          }
+          message.video = reader.int32();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      audio: isSet3(object.audio) ? globalThis.Number(object.audio) : 0,
+      video: isSet3(object.video) ? globalThis.Number(object.video) : 0
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.audio !== 0) {
+      obj.audio = Math.round(message.audio);
+    }
+    if (message.video !== 0) {
+      obj.video = Math.round(message.video);
+    }
+    return obj;
+  },
+  create(base) {
+    return MediaEvent_OfferData_TrackTypes.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseMediaEvent_OfferData_TrackTypes();
+    message.audio = object.audio ?? 0;
+    message.video = object.video ?? 0;
+    return message;
+  }
+};
+function createBaseMediaEvent_SdpAnswer() {
+  return { sdp: "", midToTrackId: {} };
+}
+var MediaEvent_SdpAnswer = {
+  encode(message, writer = new BinaryWriter3()) {
+    if (message.sdp !== "") {
+      writer.uint32(10).string(message.sdp);
+    }
+    Object.entries(message.midToTrackId).forEach(([key, value]) => {
+      MediaEvent_SdpAnswer_MidToTrackIdEntry.encode({ key, value }, writer.uint32(18).fork()).join();
+    });
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof BinaryReader3 ? input : new BinaryReader3(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseMediaEvent_SdpAnswer();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.sdp = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          const entry2 = MediaEvent_SdpAnswer_MidToTrackIdEntry.decode(reader, reader.uint32());
+          if (entry2.value !== void 0) {
+            message.midToTrackId[entry2.key] = entry2.value;
+          }
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      sdp: isSet3(object.sdp) ? globalThis.String(object.sdp) : "",
+      midToTrackId: isObject2(object.midToTrackId) ? Object.entries(object.midToTrackId).reduce((acc, [key, value]) => {
+        acc[key] = String(value);
+        return acc;
+      }, {}) : {}
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.sdp !== "") {
+      obj.sdp = message.sdp;
+    }
+    if (message.midToTrackId) {
+      const entries = Object.entries(message.midToTrackId);
+      if (entries.length > 0) {
+        obj.midToTrackId = {};
+        entries.forEach(([k, v]) => {
+          obj.midToTrackId[k] = v;
+        });
+      }
+    }
+    return obj;
+  },
+  create(base) {
+    return MediaEvent_SdpAnswer.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseMediaEvent_SdpAnswer();
+    message.sdp = object.sdp ?? "";
+    message.midToTrackId = Object.entries(object.midToTrackId ?? {}).reduce(
+      (acc, [key, value]) => {
+        if (value !== void 0) {
+          acc[key] = globalThis.String(value);
+        }
+        return acc;
+      },
+      {}
+    );
+    return message;
+  }
+};
+function createBaseMediaEvent_SdpAnswer_MidToTrackIdEntry() {
+  return { key: "", value: "" };
+}
+var MediaEvent_SdpAnswer_MidToTrackIdEntry = {
+  encode(message, writer = new BinaryWriter3()) {
+    if (message.key !== "") {
+      writer.uint32(10).string(message.key);
+    }
+    if (message.value !== "") {
+      writer.uint32(18).string(message.value);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof BinaryReader3 ? input : new BinaryReader3(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseMediaEvent_SdpAnswer_MidToTrackIdEntry();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.key = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.value = reader.string();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      key: isSet3(object.key) ? globalThis.String(object.key) : "",
+      value: isSet3(object.value) ? globalThis.String(object.value) : ""
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.key !== "") {
+      obj.key = message.key;
+    }
+    if (message.value !== "") {
+      obj.value = message.value;
+    }
+    return obj;
+  },
+  create(base) {
+    return MediaEvent_SdpAnswer_MidToTrackIdEntry.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseMediaEvent_SdpAnswer_MidToTrackIdEntry();
+    message.key = object.key ?? "";
+    message.value = object.value ?? "";
+    return message;
+  }
+};
+function createBaseMediaEvent_VadNotification() {
+  return { trackId: "", status: 0 };
+}
+var MediaEvent_VadNotification = {
+  encode(message, writer = new BinaryWriter3()) {
+    if (message.trackId !== "") {
+      writer.uint32(10).string(message.trackId);
+    }
+    if (message.status !== 0) {
+      writer.uint32(16).int32(message.status);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof BinaryReader3 ? input : new BinaryReader3(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseMediaEvent_VadNotification();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.trackId = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 16) {
+            break;
+          }
+          message.status = reader.int32();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      trackId: isSet3(object.trackId) ? globalThis.String(object.trackId) : "",
+      status: isSet3(object.status) ? mediaEvent_VadNotification_StatusFromJSON(object.status) : 0
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.trackId !== "") {
+      obj.trackId = message.trackId;
+    }
+    if (message.status !== 0) {
+      obj.status = mediaEvent_VadNotification_StatusToJSON(message.status);
+    }
+    return obj;
+  },
+  create(base) {
+    return MediaEvent_VadNotification.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseMediaEvent_VadNotification();
+    message.trackId = object.trackId ?? "";
+    message.status = object.status ?? 0;
+    return message;
+  }
+};
+function createBaseMediaEvent_TrackVariantSwitched() {
+  return { endpointId: "", trackId: "", variant: 0 };
+}
+var MediaEvent_TrackVariantSwitched = {
+  encode(message, writer = new BinaryWriter3()) {
+    if (message.endpointId !== "") {
+      writer.uint32(10).string(message.endpointId);
+    }
+    if (message.trackId !== "") {
+      writer.uint32(18).string(message.trackId);
+    }
+    if (message.variant !== 0) {
+      writer.uint32(24).int32(message.variant);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof BinaryReader3 ? input : new BinaryReader3(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseMediaEvent_TrackVariantSwitched();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.endpointId = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.trackId = reader.string();
+          continue;
+        }
+        case 3: {
+          if (tag !== 24) {
+            break;
+          }
+          message.variant = reader.int32();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      endpointId: isSet3(object.endpointId) ? globalThis.String(object.endpointId) : "",
+      trackId: isSet3(object.trackId) ? globalThis.String(object.trackId) : "",
+      variant: isSet3(object.variant) ? variantFromJSON(object.variant) : 0
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.endpointId !== "") {
+      obj.endpointId = message.endpointId;
+    }
+    if (message.trackId !== "") {
+      obj.trackId = message.trackId;
+    }
+    if (message.variant !== 0) {
+      obj.variant = variantToJSON(message.variant);
+    }
+    return obj;
+  },
+  create(base) {
+    return MediaEvent_TrackVariantSwitched.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseMediaEvent_TrackVariantSwitched();
+    message.endpointId = object.endpointId ?? "";
+    message.trackId = object.trackId ?? "";
+    message.variant = object.variant ?? 0;
+    return message;
+  }
+};
+function createBaseMediaEvent_TrackVariantDisabled() {
+  return { endpointId: "", trackId: "", variant: 0 };
+}
+var MediaEvent_TrackVariantDisabled = {
+  encode(message, writer = new BinaryWriter3()) {
+    if (message.endpointId !== "") {
+      writer.uint32(10).string(message.endpointId);
+    }
+    if (message.trackId !== "") {
+      writer.uint32(18).string(message.trackId);
+    }
+    if (message.variant !== 0) {
+      writer.uint32(24).int32(message.variant);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof BinaryReader3 ? input : new BinaryReader3(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseMediaEvent_TrackVariantDisabled();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.endpointId = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.trackId = reader.string();
+          continue;
+        }
+        case 3: {
+          if (tag !== 24) {
+            break;
+          }
+          message.variant = reader.int32();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      endpointId: isSet3(object.endpointId) ? globalThis.String(object.endpointId) : "",
+      trackId: isSet3(object.trackId) ? globalThis.String(object.trackId) : "",
+      variant: isSet3(object.variant) ? variantFromJSON(object.variant) : 0
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.endpointId !== "") {
+      obj.endpointId = message.endpointId;
+    }
+    if (message.trackId !== "") {
+      obj.trackId = message.trackId;
+    }
+    if (message.variant !== 0) {
+      obj.variant = variantToJSON(message.variant);
+    }
+    return obj;
+  },
+  create(base) {
+    return MediaEvent_TrackVariantDisabled.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseMediaEvent_TrackVariantDisabled();
+    message.endpointId = object.endpointId ?? "";
+    message.trackId = object.trackId ?? "";
+    message.variant = object.variant ?? 0;
+    return message;
+  }
+};
+function createBaseMediaEvent_TrackVariantEnabled() {
+  return { endpointId: "", trackId: "", variant: 0 };
+}
+var MediaEvent_TrackVariantEnabled = {
+  encode(message, writer = new BinaryWriter3()) {
+    if (message.endpointId !== "") {
+      writer.uint32(10).string(message.endpointId);
+    }
+    if (message.trackId !== "") {
+      writer.uint32(18).string(message.trackId);
+    }
+    if (message.variant !== 0) {
+      writer.uint32(24).int32(message.variant);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof BinaryReader3 ? input : new BinaryReader3(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseMediaEvent_TrackVariantEnabled();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.endpointId = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.trackId = reader.string();
+          continue;
+        }
+        case 3: {
+          if (tag !== 24) {
+            break;
+          }
+          message.variant = reader.int32();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      endpointId: isSet3(object.endpointId) ? globalThis.String(object.endpointId) : "",
+      trackId: isSet3(object.trackId) ? globalThis.String(object.trackId) : "",
+      variant: isSet3(object.variant) ? variantFromJSON(object.variant) : 0
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.endpointId !== "") {
+      obj.endpointId = message.endpointId;
+    }
+    if (message.trackId !== "") {
+      obj.trackId = message.trackId;
+    }
+    if (message.variant !== 0) {
+      obj.variant = variantToJSON(message.variant);
+    }
+    return obj;
+  },
+  create(base) {
+    return MediaEvent_TrackVariantEnabled.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseMediaEvent_TrackVariantEnabled();
+    message.endpointId = object.endpointId ?? "";
+    message.trackId = object.trackId ?? "";
+    message.variant = object.variant ?? 0;
+    return message;
+  }
+};
+function isObject2(value) {
+  return typeof value === "object" && value !== null;
+}
+function isSet3(value) {
+  return value !== null && value !== void 0;
+}
+
+// src/mediaEvent.ts
+function serializePeerMediaEvent(mediaEvent) {
+  const encodedEvent = MediaEvent.encode(mediaEvent).finish();
+  return encodedEvent;
+}
+function deserializeServerMediaEvent(serializedMediaEvent) {
+  return MediaEvent2.decode(serializedMediaEvent);
+}
+
+// src/internal.ts
+import EventEmitter from "events";
+var isTrackKind = (kind) => kind === "audio" || kind === "video";
+var TrackContextImpl = class extends EventEmitter {
+  constructor(endpoint, trackId, metadata, simulcastConfig = { enabled: false, enabledVariants: [], disabledVariants: [] }) {
+    super();
+    this.endpoint = endpoint;
+    this.trackId = trackId;
+    this.track = null;
+    this.trackKind = null;
+    this.stream = null;
+    this.metadata = metadata;
+    this.simulcastConfig = simulcastConfig;
+    this.maxBandwidth = 0;
+    this.vadStatus = "silence";
+    this.negotiationStatus = "awaiting";
+    this.pendingMetadataUpdate = false;
+  }
+};
+
+// src/bitrate.ts
+var defaultBitrates = {
+  audio: 5e4,
+  video: 25e5
+};
+var UNLIMITED_BANDWIDTH = 0;
+var defaultSimulcastBitrates = {
+  [3 /* VARIANT_HIGH */]: 25e5,
+  [2 /* VARIANT_MEDIUM */]: 5e5,
+  [1 /* VARIANT_LOW */]: 15e4,
+  [0 /* VARIANT_UNSPECIFIED */]: 0,
+  [-1 /* UNRECOGNIZED */]: 0
+};
+
+// src/tracks/bandwidth.ts
+var splitBandwidth = (rtcRtpEncodingParameters, maxBandwidth) => {
+  const bandwidth = maxBandwidth * 1024;
+  if (bandwidth === 0) {
+    return rtcRtpEncodingParameters.map((encoding) => ({
+      ...encoding,
+      maxBitrate: void 0
+    }));
+  }
+  if (rtcRtpEncodingParameters.length === 0) {
+    console.error("Attempted to limit bandwidth of the track that doesn't have any encodings");
+    return rtcRtpEncodingParameters.map((encoding) => ({ ...encoding }));
+  }
+  if (!rtcRtpEncodingParameters[0]) throw new Error("RTCRtpEncodingParameters is in invalid state");
+  const firstScaleDownBy = rtcRtpEncodingParameters[0].scaleResolutionDownBy || 1;
+  const bitrate_parts = rtcRtpEncodingParameters.reduce(
+    (acc, value) => acc + (firstScaleDownBy / (value.scaleResolutionDownBy || 1)) ** 2,
+    0
+  );
+  const x = bandwidth / bitrate_parts;
+  return rtcRtpEncodingParameters.map((encoding) => ({
+    ...encoding,
+    maxBitrate: x * (firstScaleDownBy / (encoding.scaleResolutionDownBy || 1)) ** 2
+  }));
+};
+
+// src/tracks/encodings.ts
+var getEncodingParameters = (parameters, bandwidth) => {
+  const unlimitedEncodings = [{}];
+  return parameters.encodings.length === 0 ? unlimitedEncodings : splitBandwidth(parameters.encodings, bandwidth);
+};
+var encodingToVariantMap = {
+  l: 1 /* VARIANT_LOW */,
+  m: 2 /* VARIANT_MEDIUM */,
+  h: 3 /* VARIANT_HIGH */
+};
+
+// src/tracks/muteTrackUtils.ts
+function emitMutableEvents(action, webrtc, trackId) {
+  const localEventType = action === "mute" ? "localTrackMuted" : "localTrackUnmuted";
+  webrtc.emit(localEventType, { trackId });
+}
+function getActionType(currentTrack, newTrack) {
+  if (currentTrack && !newTrack) {
+    return "mute";
+  } else if (!currentTrack && newTrack) {
+    return "unmute";
+  } else {
+    return "replace";
+  }
+}
+
+// src/tracks/transceivers.ts
+var createTransceiverConfig = (trackContext) => {
+  if (!trackContext.track) throw new Error(`Cannot create transceiver config for `);
+  if (trackContext.track.kind === "audio") {
+    return createAudioTransceiverConfig(trackContext.stream);
+  }
+  return createVideoTransceiverConfig(trackContext, trackContext.maxBandwidth);
+};
+var createAudioTransceiverConfig = (stream) => {
+  return {
+    direction: "sendonly",
+    streams: stream ? [stream] : []
+  };
+};
+var createVideoTransceiverConfig = (trackContext, maxBandwidth) => {
+  if (!trackContext.simulcastConfig) throw new Error(`Simulcast config for track ${trackContext.trackId} not found.`);
+  if (trackContext.simulcastConfig.enabled) {
+    let simulcastConfig;
+    if (maxBandwidth === 0) {
+      simulcastConfig = /* @__PURE__ */ new Map([
+        [1 /* VARIANT_LOW */, 0],
+        [2 /* VARIANT_MEDIUM */, 0],
+        [3 /* VARIANT_HIGH */, 0]
+      ]);
+    } else if (typeof maxBandwidth === "number") {
+      throw new Error("Invalid bandwidth limit for simulcast track.");
+    } else {
+      simulcastConfig = maxBandwidth;
+    }
+    return createSimulcastTransceiverConfig(trackContext, simulcastConfig);
+  }
+  if (typeof maxBandwidth === "number") {
+    return createNonSimulcastTransceiverConfig(trackContext, maxBandwidth);
+  }
+  throw new Error("LocalTrack is in invalid state!");
+};
+var createNonSimulcastTransceiverConfig = (trackContext, maxBandwidth) => {
+  return {
+    direction: "sendonly",
+    sendEncodings: splitBandwidth([{ active: true }], maxBandwidth),
+    streams: trackContext.stream ? [trackContext.stream] : []
+  };
+};
+var createSimulcastTransceiverConfig = (trackContext, maxBandwidth) => {
+  if (!trackContext.simulcastConfig) throw new Error(`Simulcast config for track ${trackContext.trackId} not found.`);
+  const activeEncodings = trackContext.simulcastConfig.enabledVariants;
+  const encodings = [
+    {
+      rid: "l",
+      active: activeEncodings.includes(1 /* VARIANT_LOW */),
+      // maxBitrate: 4_000_000,
+      scaleResolutionDownBy: 4
+      //   scalabilityMode: "L1T" + TEMPORAL_LAYERS_COUNT,
+    },
+    {
+      rid: "m",
+      active: activeEncodings.includes(2 /* VARIANT_MEDIUM */),
+      scaleResolutionDownBy: 2
+    },
+    {
+      rid: "h",
+      active: activeEncodings.includes(3 /* VARIANT_HIGH */)
+      // maxBitrate: 4_000_000,
+      // scalabilityMode: "L1T" + TEMPORAL_LAYERS_COUNT,
+    }
+  ];
+  return {
+    direction: "sendonly",
+    // keep this array from low resolution to high resolution
+    // in other case lower resolution encoding can get
+    // higher max_bitrate
+    sendEncodings: calculateSimulcastEncodings(encodings, maxBandwidth)
+  };
+};
+var calculateSimulcastEncodings = (encodings, maxBandwidth) => {
+  return encodings.filter((encoding) => encoding.rid).map((encoding) => {
+    const variant = !!encoding.rid && encodingToVariantMap[encoding.rid] || 0 /* VARIANT_UNSPECIFIED */;
+    const limit = maxBandwidth.get(variant) || 0;
+    return {
+      ...encoding,
+      maxBitrate: limit > 0 ? limit * 1024 : void 0
+    };
+  });
+};
+
+// src/tracks/LocalTrack.ts
+var LocalTrack = class {
+  id;
+  mediaStreamTrackId = null;
+  mLineId = null;
+  trackContext;
+  sender = null;
+  encodings = {
+    [-1 /* UNRECOGNIZED */]: false,
+    [0 /* VARIANT_UNSPECIFIED */]: false,
+    [1 /* VARIANT_LOW */]: false,
+    [2 /* VARIANT_MEDIUM */]: false,
+    [3 /* VARIANT_HIGH */]: false
+  };
+  connection;
+  constructor(connection, id, trackContext) {
+    this.connection = connection;
+    this.id = id;
+    this.trackContext = trackContext;
+    if (trackContext.track?.id) {
+      this.mediaStreamTrackId = trackContext.track?.id;
+    }
+  }
+  updateSender = () => {
+    if (this.mediaStreamTrackId && this.connection) {
+      this.sender = this.connection.findSender(this.mediaStreamTrackId);
+    }
+  };
+  updateConnection = (connection) => {
+    this.connection = connection;
+  };
+  disableTrackEncoding = async (encoding) => {
+    if (!this.sender) throw new Error(`RTCRtpSender for track ${this.id} not found`);
+    const params = this.sender.getParameters();
+    const encodings = params.encodings;
+    const encodingParameter = encodings.find((en) => en.rid && encodingToVariantMap[en.rid] === encoding);
+    if (!encodingParameter) throw new Error(`RTCRtpEncodingParameters for track ${this.id} not found`);
+    encodingParameter.active = false;
+    this.encodings[encoding] = false;
+    await this.sender.setParameters(params);
+  };
+  addTrackToConnection = () => {
+    if (!this.trackContext.track) throw Error(`MediaStreamTrack for track ${this.id} does not exist`);
+    if (!this.connection) throw new Error(`There is no active RTCPeerConnection`);
+    const transceiverConfig = createTransceiverConfig(this.trackContext);
+    this.updateEncodings();
+    this.connection.addTransceiver(this.trackContext.track, transceiverConfig);
+  };
+  updateEncodings = () => {
+    const enabledVariants = this.trackContext.simulcastConfig?.enabledVariants;
+    if (this.trackContext?.track?.kind === "video" && enabledVariants) {
+      this.encodings[1 /* VARIANT_LOW */] = enabledVariants.some((e) => e === 1 /* VARIANT_LOW */);
+      this.encodings[2 /* VARIANT_MEDIUM */] = enabledVariants.some((e) => e === 2 /* VARIANT_MEDIUM */);
+      this.encodings[3 /* VARIANT_HIGH */] = enabledVariants.some((e) => e === 3 /* VARIANT_HIGH */);
+    }
+  };
+  removeFromConnection = () => {
+    if (!this.sender) throw new Error(`RTCRtpSender for track ${this.id} not found`);
+    if (!this.connection) throw new Error(`There is no active RTCPeerConnection`);
+    this.connection.removeTrack(this.sender);
+  };
+  replaceTrack = async (newTrack, webrtc) => {
+    const trackId = this.id;
+    const stream = this.trackContext.stream;
+    const oldTrack = this.trackContext.track;
+    if (!this.sender) throw Error("There is no RTCRtpSender for this track id!");
+    stream?.getTracks().forEach((track) => {
+      stream?.removeTrack(track);
+    });
+    if (newTrack) {
+      stream?.addTrack(newTrack);
+    }
+    this.trackContext.track = newTrack;
+    this.mediaStreamTrackId = newTrack?.id ?? null;
+    const action = getActionType(this.trackContext.track, newTrack);
+    if (action === "mute" || action === "unmute") {
+      emitMutableEvents(action, webrtc, trackId);
+    }
+    try {
+      await this.sender.replaceTrack(newTrack);
+    } catch (_error) {
+      if (action === "mute") {
+        emitMutableEvents("unmute", webrtc, trackId);
+      } else if (action === "unmute") {
+        emitMutableEvents("mute", webrtc, trackId);
+      }
+      this.trackContext.track = oldTrack;
+      this.mediaStreamTrackId = oldTrack?.id ?? null;
+    }
+  };
+  setTrackBandwidth = (bandwidth) => {
+    if (!this.sender) throw new Error(`RTCRtpSender for track ${this.id} not found`);
+    const parameters = this.sender.getParameters();
+    parameters.encodings = getEncodingParameters(parameters, bandwidth);
+    return this.sender.setParameters(parameters);
+  };
+  setEncodingBandwidth(variant, bandwidth) {
+    if (!this.sender) throw new Error(`RTCRtpSender for track ${this.id} not found`);
+    const parameters = this.sender.getParameters();
+    const encoding = parameters.encodings.find((enc) => enc.rid && encodingToVariantMap[enc.rid] === variant);
+    if (!encoding) {
+      return Promise.reject(`Encoding with Variant '${variant}' doesn't exist`);
+    } else if (bandwidth === 0) {
+      delete encoding.maxBitrate;
+    } else {
+      encoding.maxBitrate = bandwidth * 1024;
+    }
+    return this.sender.setParameters(parameters);
+  }
+  updateTrackMetadata = (metadata) => {
+    this.trackContext.metadata = metadata;
+  };
+  enableTrackEncoding = (encoding) => {
+    if (!this.sender) throw new Error(`RTCRtpSender for track ${this.id} not found`);
+    const params = this.sender.getParameters();
+    const encodingParameters = params.encodings.find((en) => en.rid && encodingToVariantMap[en.rid] === encoding);
+    if (!encodingParameters) throw new Error(`RTCRtEncodingParameters ${encoding} for track ${this.id} not found`);
+    encodingParameters.active = true;
+    this.encodings[encoding] = true;
+    return this.sender.setParameters(params);
+  };
+  setMLineId = (mLineId) => {
+    this.mLineId = mLineId;
+  };
+  isNotSimulcastTrack = (encodings) => encodings.length === 1 && !encodings[0].rid;
+  getTrackBitrates = () => {
+    const trackContext = this.trackContext;
+    const kind = this.trackContext.track?.kind;
+    if (!trackContext.track) {
+      if (!trackContext.trackKind) {
+        throw new Error("trackContext.trackKind is empty");
+      }
+      return defaultBitrates[trackContext.trackKind];
+    }
+    if (!this.sender) return void 0;
+    const encodings = this.sender.getParameters().encodings;
+    if (this.isNotSimulcastTrack(encodings)) {
+      return encodings[0].maxBitrate || (kind ? defaultBitrates[kind] : UNLIMITED_BANDWIDTH);
+    } else if (kind === "audio") {
+      throw "Audio track cannot have multiple encodings";
+    }
+    return encodings.filter((encoding) => encoding.rid).reduce(
+      (acc, encoding) => {
+        const variant = encodingToVariantMap[encoding.rid] ?? 0 /* VARIANT_UNSPECIFIED */;
+        acc[variant] = encoding.maxBitrate || defaultSimulcastBitrates[variant];
+        return acc;
+      },
+      {}
+    );
+  };
+  createTrackVariantBitratesEvent = () => {
+  };
+};
+
+// src/tracks/Local.ts
+var Local = class {
+  localTracks = {};
+  localEndpoint = {
+    id: "",
+    type: "webrtc",
+    metadata: void 0,
+    tracks: /* @__PURE__ */ new Map()
+  };
+  emit;
+  sendMediaEvent;
+  connection = null;
+  constructor(emit, sendMediaEvent) {
+    this.emit = emit;
+    this.sendMediaEvent = sendMediaEvent;
+  }
+  updateSenders = () => {
+    Object.values(this.localTracks).forEach((localTrack) => {
+      localTrack.updateSender();
+    });
+  };
+  updateMLineIds = (midToTrackIds) => {
+    Object.entries(midToTrackIds).forEach(([mid, trackId]) => {
+      this.localTracks[trackId]?.setMLineId(mid);
+    });
+  };
+  updateConnection = (connection) => {
+    this.connection = connection;
+    Object.values(this.localTracks).forEach((track) => {
+      track.updateConnection(connection);
+    });
+  };
+  createSdpOfferEvent = (sdpOffer) => {
+    const trackIdToMetadataJson = this.getTrackIdToMetadataJson();
+    const trackIdToBitrates = this.getTrackIdToTrackBitrates();
+    const midToTrackId = this.getMidToTrackId();
+    return MediaEvent_SdpOffer.create({
+      sdp: sdpOffer.sdp,
+      midToTrackId,
+      trackIdToBitrates,
+      trackIdToMetadataJson
+    });
+  };
+  addTrack = (connection, trackId, track, stream, trackMetadata, simulcastConfig, maxBandwidth) => {
+    const trackContext = new TrackContextImpl(this.localEndpoint, trackId, trackMetadata, simulcastConfig);
+    trackContext.track = track;
+    trackContext.stream = stream;
+    trackContext.maxBandwidth = maxBandwidth;
+    if (!isTrackKind(track.kind)) throw new Error("Track has no kind");
+    trackContext.trackKind = track.kind;
+    this.localEndpoint.tracks.set(trackId, trackContext);
+    const trackManager = new LocalTrack(connection, trackId, trackContext);
+    this.localTracks[trackId] = trackManager;
+    return trackManager;
+  };
+  getTrackByMidOrNull = (mid) => {
+    return Object.values(this.localTracks).find((track) => track.mLineId === mid) ?? null;
+  };
+  removeTrack = (trackId) => {
+    const trackManager = this.localTracks[trackId];
+    if (!trackManager) throw new Error(`Cannot find ${trackId}`);
+    trackManager.removeFromConnection();
+    const renegotiateTracks = MediaEvent_RenegotiateTracks.create({});
+    this.sendMediaEvent({ renegotiateTracks });
+    this.localEndpoint.tracks.delete(trackId);
+    delete this.localTracks[trackId];
+  };
+  replaceTrack = async (webrtc, trackId, newTrack) => {
+    const trackManager = this.localTracks[trackId];
+    if (!trackManager) throw new Error(`Cannot find ${trackId}`);
+    await trackManager.replaceTrack(newTrack, webrtc);
+  };
+  setEndpointMetadata = (metadata) => {
+    this.localEndpoint.metadata = metadata;
+  };
+  getEndpoint = () => {
+    return this.localEndpoint;
+  };
+  setTrackBandwidth = async (trackId, bandwidth) => {
+    const trackManager = this.localTracks[trackId];
+    if (!trackManager) throw new Error(`Cannot find ${trackId}`);
+    await trackManager.setTrackBandwidth(bandwidth);
+    const trackBitrates = MediaEvent_TrackBitrates.create({
+      trackId,
+      variantBitrates: [{ variant: 0 /* VARIANT_UNSPECIFIED */, bitrate: bandwidth }]
+    });
+    this.sendMediaEvent(MediaEvent.create({ trackBitrates }));
+    this.emit("localTrackBandwidthSet", {
+      trackId,
+      bandwidth
+    });
+  };
+  getTrackIdToTrack = () => {
+    const entries = Object.values(this.localTracks).map(
+      (track) => [track.id, track.trackContext]
+    );
+    return new Map(entries);
+  };
+  setLocalEndpointId = (endpointId) => {
+    this.localEndpoint.id = endpointId;
+  };
+  setEncodingBandwidth = async (trackId, rid, bandwidth) => {
+    const trackManager = this.localTracks[trackId];
+    if (!trackManager) throw new Error(`Cannot find ${trackId}`);
+    await trackManager.setEncodingBandwidth(rid, bandwidth);
+    const bitrates = trackManager.getTrackBitrates();
+    let variantBitrates = [];
+    if (typeof bitrates === "number") {
+      variantBitrates = [{ variant: 0 /* VARIANT_UNSPECIFIED */, bitrate: bitrates }];
+    } else if (bitrates) {
+      variantBitrates = Object.entries(bitrates).map(([variant, bitrate]) => ({
+        variant: Number(variant),
+        bitrate
+      }));
+    }
+    const trackBitrates = MediaEvent_TrackBitrates.create({
+      trackId,
+      variantBitrates
+    });
+    this.sendMediaEvent(MediaEvent.create({ trackBitrates }));
+    this.emit("localTrackEncodingBandwidthSet", {
+      trackId,
+      rid,
+      bandwidth
+    });
+  };
+  updateEndpointMetadata = (metadata) => {
+    this.localEndpoint.metadata = metadata;
+    const updateEndpointMetadata = MediaEvent_UpdateEndpointMetadata.create({
+      metadataJson: JSON.stringify(this.localEndpoint.metadata)
+    });
+    this.sendMediaEvent({ updateEndpointMetadata });
+    this.emit("localEndpointMetadataChanged", {
+      metadata: this.localEndpoint.metadata
+    });
+  };
+  updateLocalTrackMetadata = (trackId, metadata) => {
+    const trackManager = this.localTracks[trackId];
+    if (!trackManager) throw new Error(`Cannot find ${trackId}`);
+    trackManager.updateTrackMetadata(metadata);
+    const trackContext = trackManager.trackContext;
+    const updateTrackMetadata = MediaEvent_UpdateTrackMetadata.create({
+      trackId,
+      metadataJson: metadata ? JSON.stringify(metadata) : void 0
+    });
+    switch (trackContext.negotiationStatus) {
+      case "done":
+        this.sendMediaEvent({ updateTrackMetadata });
+        this.emit("localTrackMetadataChanged", {
+          trackId,
+          metadata: trackContext.metadata
+        });
+        break;
+      case "offered":
+        trackContext.pendingMetadataUpdate = true;
+        break;
+      case "awaiting":
+        break;
+    }
+  };
+  disableLocalTrackEncoding = async (trackId, encoding) => {
+    const localTrack = this.localTracks[trackId];
+    if (!localTrack) throw new Error(`Track ${trackId} not found`);
+    await localTrack.disableTrackEncoding(encoding);
+    const disableTrackVariant = MediaEvent_DisableTrackVariant.create({ trackId, variant: encoding });
+    this.sendMediaEvent(MediaEvent.create({ disableTrackVariant }));
+    this.emit("localTrackEncodingEnabled", {
+      trackId,
+      encoding
+    });
+  };
+  enableLocalTrackEncoding = async (trackId, variant) => {
+    const trackManager = this.localTracks[trackId];
+    if (!trackManager) throw new Error(`Cannot find ${trackId}`);
+    await trackManager.enableTrackEncoding(variant);
+    const enableTrackVariant = MediaEvent_EnableTrackVariant.create({ trackId, variant });
+    this.sendMediaEvent(MediaEvent.create({ enableTrackVariant }));
+    this.emit("localTrackEncodingEnabled", {
+      trackId,
+      encoding: variant
+    });
+  };
+  getTrackIdToMetadataJson = () => Object.values(this.localTracks).reduce(
+    (acc, { id, trackContext }) => ({ ...acc, [id]: JSON.stringify(trackContext.metadata) }),
+    {}
+  );
+  // TODO add bitrates
+  getTrackIdToTrackBitrates = () => Object.values(this.localTracks).reduce((acc, { id }) => ({ ...acc, [id]: { bitrate: 15e5 } }), {});
+  getMidToTrackId = () => {
+    if (!this.connection) return {};
+    const mappingFromTransceivers = this.getTransceiverMapping();
+    const mappingFromLocalNegotiatedTracks = Object.values(this.localTracks).filter((track) => !!track.mLineId).reduce((acc, { id, mLineId }) => ({ ...acc, [mLineId]: id }), {});
+    return { ...mappingFromTransceivers, ...mappingFromLocalNegotiatedTracks };
+  };
+  getTransceiverMapping = () => {
+    if (!this.connection) return {};
+    return this.connection.getConnection().getTransceivers().filter((transceiver) => Boolean(transceiver.sender.track?.id && transceiver.mid)).reduce((acc, { sender, mid }) => {
+      const localTrack = Object.values(this.localTracks).find(
+        (track) => track.mediaStreamTrackId === sender.track.id
+      );
+      if (!localTrack) throw new Error("Local track not found");
+      return { ...acc, [mid]: localTrack.id };
+    }, {});
+  };
+  setLocalTrackStatusToOffered = () => {
+    Object.values(this.localTracks).forEach((localTrack) => {
+      localTrack.trackContext.negotiationStatus = "offered";
+    });
+  };
+  addAllTracksToConnection = () => {
+    Object.values(this.localTracks).forEach((localTrack) => {
+      localTrack.addTrackToConnection();
+    });
+  };
+};
+
+// src/tracks/LocalTrackManager.ts
+var LocalTrackManager = class {
+  connection;
+  local;
+  ongoingTrackReplacement = false;
+  /**
+   * Indicates if an ongoing renegotiation is active.
+   * During renegotiation, both parties are expected to actively exchange events: renegotiateTracks, offerData, sdpOffer, sdpAnswer.
+   */
+  ongoingRenegotiation = false;
+  sendMediaEvent;
+  constructor(local, sendMediaEvent) {
+    this.local = local;
+    this.sendMediaEvent = sendMediaEvent;
+  }
+  isNegotiationInProgress = () => {
+    return this.ongoingRenegotiation || this.ongoingTrackReplacement;
+  };
+  cleanUp = () => {
+    this.ongoingTrackReplacement = false;
+    this.ongoingRenegotiation = false;
+  };
+  parseAddTrack = (track, simulcastConfig, maxBandwidth) => {
+    if (this.getEndpointId() === "") {
+      throw new Error("Cannot add tracks before being accepted by the server");
+    }
+    if (!simulcastConfig.enabled && !(typeof maxBandwidth === "number")) {
+      throw new Error("Invalid type of `maxBandwidth` argument for a non-simulcast track, expected: number");
+    }
+    if (this.connection?.isTrackInUse(track)) {
+      throw new Error("This track was already added to peerConnection, it can't be added again!");
+    }
+  };
+  addTrackHandler = (trackId, track, stream, trackMetadata, simulcastConfig, maxBandwidth) => {
+    this.ongoingRenegotiation = true;
+    const trackManager = this.local.addTrack(
+      this.connection,
+      trackId,
+      track,
+      stream,
+      trackMetadata,
+      simulcastConfig,
+      maxBandwidth
+    );
+    if (this.connection) {
+      trackManager.addTrackToConnection();
+    }
+    this.sendMediaEvent({ renegotiateTracks: MediaEvent_RenegotiateTracks.create() });
+  };
+  removeTrackHandler = (trackId) => {
+    if (!this.connection) throw new Error(`There is no active RTCPeerConnection`);
+    this.ongoingRenegotiation = true;
+    this.local.removeTrack(trackId);
+  };
+  replaceTrackHandler = async (webrtc, trackId, newTrack) => {
+    this.ongoingTrackReplacement = true;
+    try {
+      await this.local.replaceTrack(webrtc, trackId, newTrack);
+    } finally {
+      this.ongoingTrackReplacement = false;
+    }
+  };
+  getEndpointId = () => this.local.getEndpoint().id;
+  updateConnection = (connection) => {
+    this.connection = connection;
+  };
+  updateSenders = () => {
+    this.local.updateSenders();
+  };
+};
+
+// src/tracks/RemoteTrack.ts
+var RemoteTrack = class {
+  id;
+  mLineId = null;
+  trackContext;
+  encodings = {
+    [-1 /* UNRECOGNIZED */]: false,
+    [0 /* VARIANT_UNSPECIFIED */]: false,
+    [1 /* VARIANT_LOW */]: false,
+    [2 /* VARIANT_MEDIUM */]: false,
+    [3 /* VARIANT_HIGH */]: false
+  };
+  // todo this field is not exposed
+  targetEncoding = null;
+  constructor(id, trackContext) {
+    this.id = id;
+    this.trackContext = trackContext;
+  }
+  setMLineId = (mLineId) => {
+    this.mLineId = mLineId;
+  };
+  setReady = (stream, track) => {
+    if (!isTrackKind(track.kind)) throw new Error("Track has no kind");
+    this.trackContext.stream = stream;
+    this.trackContext.track = track;
+    this.trackContext.trackKind = track.kind;
+  };
+  disableTrackEncoding = (encoding) => {
+    this.encodings[encoding] = false;
+  };
+  enableTrackEncoding = (encoding) => {
+    this.encodings[encoding] = true;
+  };
+  setTargetTrackEncoding = (variant) => {
+    this.targetEncoding = variant;
+    const trackContext = this.trackContext;
+    if (!trackContext.simulcastConfig?.enabled) {
+      throw new Error("The track does not support changing its target variant");
+    }
+    const isValidTargetEncoding = !trackContext.simulcastConfig.enabledVariants.includes(variant);
+    if (isValidTargetEncoding) {
+      throw new Error(`The track does not support variant ${variant}`);
+    }
+  };
+};
+
+// src/tracks/Remote.ts
+var Remote = class {
+  remoteTracks = {};
+  remoteEndpoints = {};
+  emit;
+  sendMediaEvent;
+  constructor(emit, sendMediaEvent) {
+    this.emit = emit;
+    this.sendMediaEvent = sendMediaEvent;
+  }
+  getTrackByMid = (mid) => {
+    const remoteTrack = Object.values(this.remoteTracks).find((remote) => remote.mLineId === mid);
+    if (!remoteTrack) throw new Error(`Remote track with ${mid} not found`);
+    return remoteTrack;
+  };
+  addTracks = (endpointId, tracks) => {
+    const endpoint = this.remoteEndpoints[endpointId];
+    if (!endpoint) throw new Error(`Endpoint ${endpointId} not found`);
+    Object.entries(tracks).map(([trackId, { metadataJson, simulcastConfig }]) => {
+      const parsedMetadata = metadataJson ? JSON.parse(metadataJson) : void 0;
+      const trackContext = new TrackContextImpl(endpoint, trackId, parsedMetadata, simulcastConfig);
+      return new RemoteTrack(trackId, trackContext);
+    }).forEach((remoteTrack) => {
+      this.remoteTracks[remoteTrack.id] = remoteTrack;
+      endpoint.tracks.set(remoteTrack.id, remoteTrack.trackContext);
+      this.emit("trackAdded", remoteTrack.trackContext);
+    });
+  };
+  removeTracks = (trackIds) => {
+    trackIds.forEach((trackId) => {
+      this.removeRemoteTrack(trackId);
+    });
+  };
+  removeRemoteTrack = (trackId) => {
+    const remoteTrack = this.remoteTracks[trackId];
+    if (!remoteTrack) throw new Error(`Track ${trackId} not found`);
+    const remoteEndpoint = this.remoteEndpoints[remoteTrack.trackContext.endpoint.id];
+    if (!remoteEndpoint) throw new Error(`Endpoint ${remoteTrack.trackContext.endpoint.id} not found`);
+    remoteEndpoint.tracks.delete(trackId);
+    delete this.remoteTracks[trackId];
+    this.emit("trackRemoved", remoteTrack.trackContext);
+  };
+  addRemoteEndpoint = (endpointId, metadataJson, tracks, sendNotification = true) => {
+    const endpoint = {
+      id: endpointId,
+      type: "exwebrtc",
+      metadata: metadataJson ? JSON.parse(metadataJson) : void 0,
+      tracks: /* @__PURE__ */ new Map()
+    };
+    this.addEndpoint(endpoint);
+    this.addTracks(endpoint.id, tracks ?? {});
+    if (sendNotification) {
+      this.emit("endpointAdded", endpoint);
+    }
+  };
+  addEndpoint = (endpoint) => {
+    this.remoteEndpoints[endpoint.id] = endpoint;
+  };
+  updateRemoteEndpoint = (endpointId, metadataJson) => {
+    const endpoint = this.remoteEndpoints[endpointId];
+    if (!endpoint) throw new Error(`Endpoint ${endpointId} not found`);
+    endpoint.metadata = metadataJson ? JSON.parse(metadataJson) : void 0;
+    this.emit("endpointUpdated", endpoint);
+  };
+  removeRemoteEndpoint = (endpointId) => {
+    const endpoint = this.remoteEndpoints[endpointId];
+    if (!endpoint) throw new Error(`Endpoint ${endpointId} not found`);
+    const trackIds = [...endpoint.tracks.values()].map(({ trackId }) => trackId);
+    this.removeTracks(trackIds);
+    delete this.remoteEndpoints[endpointId];
+    this.emit("endpointRemoved", endpoint);
+  };
+  updateRemoteTrack = (endpointId, trackId, metadataJson) => {
+    if (!this.remoteEndpoints[endpointId]) throw new Error(`Endpoint ${endpointId} not found`);
+    const remoteTrack = this.remoteTracks[trackId];
+    if (!remoteTrack) throw new Error(`Track ${trackId} not found`);
+    remoteTrack.trackContext.metadata = metadataJson ? JSON.parse(metadataJson) : void 0;
+    this.emit("trackUpdated", remoteTrack.trackContext);
+  };
+  disableRemoteTrackEncoding = (trackId, encoding) => {
+    const remoteTrack = this.remoteTracks[trackId];
+    if (!remoteTrack) throw new Error(`Track ${trackId} not found`);
+    remoteTrack.disableTrackEncoding(encoding);
+    this.emit("trackEncodingDisabled", remoteTrack.trackContext, encoding);
+  };
+  enableRemoteTrackEncoding = (trackId, encoding) => {
+    const remoteTrack = this.remoteTracks[trackId];
+    if (!remoteTrack) throw new Error(`Track ${trackId} not found`);
+    remoteTrack.enableTrackEncoding(encoding);
+    this.emit("trackEncodingEnabled", remoteTrack.trackContext, encoding);
+  };
+  setRemoteTrackEncoding = (trackId, encoding, reason) => {
+    const remoteTrack = this.remoteTracks[trackId];
+    if (!remoteTrack) throw new Error(`Track ${trackId} not found`);
+    remoteTrack.trackContext.encoding = encoding;
+    remoteTrack.trackContext.encodingReason = reason;
+    remoteTrack.trackContext.emit("encodingChanged", remoteTrack.trackContext);
+  };
+  setRemoteTrackVadStatus = (trackId, vadStatus) => {
+    const remoteTrack = this.remoteTracks[trackId];
+    if (!remoteTrack) throw new Error(`Track ${trackId} not found`);
+    let nextStatus = null;
+    if (vadStatus === 1 /* STATUS_SILENCE */) {
+      nextStatus = "silence";
+    } else if (vadStatus === 2 /* STATUS_SPEECH */) {
+      nextStatus = "speech";
+    }
+    if (nextStatus) {
+      remoteTrack.trackContext.vadStatus = nextStatus;
+      remoteTrack.trackContext.emit("voiceActivityChanged", remoteTrack.trackContext);
+    } else {
+      console.warn("Received unknown vad status: ", vadStatus);
+    }
+  };
+  getRemoteTrackContexts = () => {
+    return Object.values(this.remoteTracks).reduce(
+      (acc, current) => ({
+        ...acc,
+        [current.trackContext.trackId]: current.trackContext
+      }),
+      {}
+    );
+  };
+  getRemoteEndpoints = () => {
+    return Object.values(this.remoteEndpoints).reduce(
+      (acc, current) => ({ ...acc, [current.id]: current }),
+      {}
+    );
+  };
+  setTargetRemoteTrackEncoding = (trackId, variant) => {
+    const remoteTrack = this.remoteTracks[trackId];
+    if (!remoteTrack) throw new Error(`Track ${trackId} not found`);
+    try {
+      remoteTrack.setTargetTrackEncoding(variant);
+      const setTargetTrackVariant = MediaEvent_SetTargetTrackVariant.create({ variant, trackId });
+      this.sendMediaEvent({ setTargetTrackVariant });
+      this.emit("targetTrackEncodingRequested", {
+        trackId,
+        variant
+      });
+    } catch (e) {
+      console.warn(e);
+    }
+  };
+  updateMLineIds = (midToTrackIds) => {
+    Object.entries(midToTrackIds).forEach(([mid, trackId]) => {
+      this.remoteTracks[trackId]?.setMLineId(mid);
+    });
+  };
+};
+
+// src/webRTCEndpoint.ts
+var WebRTCEndpoint = class extends EventEmitter2 {
+  localTrackManager;
+  remote;
+  local;
+  commandsQueue;
+  proposedIceServers = [];
+  bandwidthEstimation = BigInt(0);
+  connectionManager;
+  clearConnectionCallbacks = null;
+  constructor() {
+    super();
+    const sendEvent = (mediaEvent) => this.sendMediaEvent(mediaEvent);
+    const emit = (events, ...args) => {
+      this.emit(events, ...args);
+    };
+    this.remote = new Remote(emit, sendEvent);
+    this.local = new Local(emit, sendEvent);
+    this.localTrackManager = new LocalTrackManager(this.local, sendEvent);
+    this.commandsQueue = new CommandsQueue(this.localTrackManager);
+  }
+  /**
+   * Tries to connect to the RTC Engine. If user is successfully connected then {@link WebRTCEndpointEvents.connected}
+   * will be emitted.
+   *
+   * @param metadata - Any information that other endpoints will receive in {@link WebRTCEndpointEvents.endpointAdded}
+   * after accepting this endpoint
+   *
+   * @example
+   * ```ts
+   * let webrtc = new WebRTCEndpoint();
+   * webrtc.connect({displayName: "Bob"});
+   * ```
+   */
+  connect = (metadata) => {
+    this.local.setEndpointMetadata(metadata);
+    const connect = MediaEvent_Connect.create({ metadataJson: JSON.stringify(metadata) });
+    this.sendMediaEvent({ connect });
+  };
+  /**
+   * Feeds media event received from RTC Engine to {@link WebRTCEndpoint}.
+   * This function should be called whenever some media event from RTC Engine
+   * was received and can result in {@link WebRTCEndpoint} generating some other
+   * media events.
+   *
+   * @param mediaEvent - String data received over custom signalling layer.
+   *
+   * @example
+   * This example assumes phoenix channels as signalling layer.
+   * As phoenix channels require objects, RTC Engine encapsulates binary data into
+   * map with one field that is converted to object with one field on the TS side.
+   * ```ts
+   * webrtcChannel.on("mediaEvent", (event) => webrtc.receiveMediaEvent(event.data));
+   * ```
+   */
+  receiveMediaEvent = async (mediaEvent) => {
+    const deserializedMediaEvent = deserializeServerMediaEvent(mediaEvent);
+    if (deserializedMediaEvent.connected) {
+      const connectedEvent = deserializedMediaEvent.connected;
+      this.proposedIceServers = connectedEvent.iceServers;
+      this.local.setLocalEndpointId(connectedEvent.endpointId);
+      const localEndpointMetadataJson = connectedEvent.endpointIdToEndpoint[connectedEvent.endpointId]?.metadataJson;
+      if (localEndpointMetadataJson) {
+        this.local.setEndpointMetadata(JSON.parse(localEndpointMetadataJson));
+      }
+      const connectedEndpoint = connectedEvent.endpointIdToEndpoint[connectedEvent.endpointId];
+      if (connectedEndpoint?.metadataJson) {
+        const parsedMetadata = JSON.parse(connectedEndpoint?.metadataJson);
+        this.local.setEndpointMetadata(parsedMetadata);
+      }
+      Object.entries(connectedEvent.endpointIdToEndpoint).filter(([endpointId]) => endpointId !== this.local.getEndpoint().id).forEach(([endpointId, endpoint]) => {
+        this.remote.addRemoteEndpoint(endpointId, endpoint.metadataJson, endpoint.trackIdToTrack);
+      });
+      const remoteEndpoints = Object.values(this.remote.getRemoteEndpoints());
+      this.emit("connected", this.local.getEndpoint().id, remoteEndpoints);
+      return;
+    }
+    if (this.getEndpointId()) await this.handleMediaEvent(deserializedMediaEvent);
+  };
+  getEndpointId = () => this.local.getEndpoint().id;
+  onTrackReady = (event) => {
+    const stream = event.streams[0];
+    if (!stream) throw new Error("Cannot find media stream");
+    const mid = event.transceiver.mid;
+    const remoteTrack = this.remote.getTrackByMid(mid);
+    remoteTrack.setReady(stream, event.track);
+    this.emit("trackReady", remoteTrack.trackContext);
+  };
+  /**
+   * Retrieves statistics related to the RTCPeerConnection.
+   * These statistics provide insights into the performance and status of the connection.
+   *
+   * @return {Promise<RTCStatsReport>}
+   *
+   * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/RTCPeerConnection/getStats | MDN Web Docs: RTCPeerConnection.getStats()}
+   */
+  async getStatistics(selector) {
+    return await this.connectionManager?.getConnection().getStats(selector) ?? /* @__PURE__ */ new Map();
+  }
+  /**
+   * Returns a snapshot of currently received remote tracks.
+   *
+   * @example
+   * if (webRTCEndpoint.getRemoteTracks()[trackId]?.simulcastConfig?.enabled) {
+   *   webRTCEndpoint.setTargetTrackEncoding(trackId, encoding);
+   * }
+   */
+  getRemoteTracks() {
+    return this.remote.getRemoteTrackContexts();
+  }
+  /**
+   * Returns a snapshot of currently received remote endpoints.
+   */
+  getRemoteEndpoints() {
+    return this.remote.getRemoteEndpoints();
+  }
+  getLocalEndpoint() {
+    return this.local.getEndpoint();
+  }
+  getBandwidthEstimation() {
+    return this.bandwidthEstimation;
+  }
+  handleMediaEvent = async (event) => {
+    if (event.offerData) {
+      await this.onOfferData(event.offerData);
+    } else if (event.tracksAdded) {
+      this.localTrackManager.ongoingRenegotiation = true;
+      const { trackIdToTrack, endpointId } = event.tracksAdded;
+      if (this.getEndpointId() === endpointId) return;
+      this.remote.addTracks(endpointId, trackIdToTrack);
+    } else if (event.tracksRemoved) {
+      this.localTrackManager.ongoingRenegotiation = true;
+      const { endpointId, trackIds } = event.tracksRemoved;
+      if (this.getEndpointId() === endpointId) return;
+      this.remote.removeTracks(trackIds);
+    } else if (event.sdpAnswer) {
+      this.localTrackManager.ongoingRenegotiation = false;
+      await this.onSdpAnswer(event.sdpAnswer);
+      this.commandsQueue.processNextCommand();
+    } else if (event.candidate) {
+      await this.onRemoteCandidate(event.candidate);
+    } else if (event.endpointAdded) {
+      const { endpointId, metadataJson } = event.endpointAdded;
+      if (endpointId === this.getEndpointId()) return;
+      this.remote.addRemoteEndpoint(endpointId, metadataJson);
+    } else if (event.endpointRemoved) {
+      const { endpointId } = event.endpointRemoved;
+      if (endpointId === this.local.getEndpoint().id) {
+        this.cleanUp();
+        this.emit("disconnected");
+        return;
+      }
+      if (this.getEndpointId() === endpointId) return;
+      this.remote.removeRemoteEndpoint(endpointId);
+    } else if (event.endpointUpdated) {
+      const { endpointId, metadataJson } = event.endpointUpdated;
+      if (this.getEndpointId() === endpointId) return;
+      this.remote.updateRemoteEndpoint(endpointId, metadataJson);
+    } else if (event.trackUpdated) {
+      const { endpointId, trackId, metadataJson } = event.trackUpdated;
+      if (this.getEndpointId() === endpointId) return;
+      this.remote.updateRemoteTrack(endpointId, trackId, metadataJson);
+    } else if (event.vadNotification) {
+      const { trackId, status } = event.vadNotification;
+      this.remote.setRemoteTrackVadStatus(trackId, status);
+    } else if (event.error) {
+      console.warn("signaling error", {
+        message: event.error.message
+      });
+      this.emit("signalingError", {
+        message: event.error.message
+      });
+      this.disconnect();
+    } else if (event.trackVariantSwitched) {
+      const { trackId, variant } = event.trackVariantSwitched;
+      this.remote.setRemoteTrackEncoding(trackId, variant);
+    } else if (event.trackVariantEnabled) {
+      const { trackId, variant } = event.trackVariantEnabled;
+      this.remote.enableRemoteTrackEncoding(trackId, variant);
+    } else if (event.trackVariantDisabled) {
+      const { trackId, variant } = event.trackVariantDisabled;
+      this.remote.disableRemoteTrackEncoding(trackId, variant);
+    }
+  };
+  onSdpAnswer = async (data) => {
+    this.remote.updateMLineIds(data.midToTrackId);
+    this.local.updateMLineIds(data.midToTrackId);
+    Object.keys(data.midToTrackId).map((mid) => {
+      if (!mid) throw new Error("TrackId is not defined");
+      return mid;
+    }).map((mid) => this.local.getTrackByMidOrNull(mid)).filter((localTrack) => localTrack !== null).forEach((localTrack) => {
+      const trackContext = localTrack.trackContext;
+      trackContext.negotiationStatus = "done";
+      if (trackContext.pendingMetadataUpdate) {
+        const updateTrackMetadata = MediaEvent_UpdateTrackMetadata.create({
+          trackId: localTrack.id,
+          metadataJson: JSON.stringify(trackContext.metadata)
+        });
+        this.sendMediaEvent({ updateTrackMetadata });
+      }
+      trackContext.pendingMetadataUpdate = false;
+    });
+    if (!this.connectionManager) throw new Error(`There is no active RTCPeerConnection`);
+    this.connectionManager.setOnTrackReady((event) => {
+      this.onTrackReady(event);
+    });
+    try {
+      await this.connectionManager.setRemoteDescription({ sdp: data.sdp, type: "answer" });
+    } catch (err) {
+      console.error(err);
+    }
+  };
+  /**
+   * Adds track that will be sent to the RTC Engine.
+   * @param track - Audio or video track e.g. from your microphone or camera.
+   * @param trackMetadata - Any information about this track that other endpoints will
+   * receive in {@link WebRTCEndpointEvents.endpointAdded}. E.g. this can source of the track - whether it's
+   * screensharing, webcam or some other media device.
+   * @param simulcastConfig - Simulcast configuration. By default simulcast is disabled.
+   * For more information refer to {@link SimulcastConfig}.
+   * @param maxBandwidth - maximal bandwidth this track can use.
+   * Defaults to 0 which is unlimited.
+   * This option has no effect for simulcast and audio tracks.
+   * For simulcast tracks use `{@link WebRTCEndpoint.setTrackBandwidth}.
+   * @returns {string} Returns id of added track
+   * @example
+   * ```ts
+   * let localStream: MediaStream = new MediaStream();
+   * try {
+   *   localAudioStream = await navigator.mediaDevices.getUserMedia(
+   *     AUDIO_CONSTRAINTS
+   *   );
+   *   localAudioStream
+   *     .getTracks()
+   *     .forEach((track) => localStream.addTrack(track));
+   * } catch (error) {
+   *   console.error("Couldn't get microphone permission:", error);
+   * }
+   *
+   * try {
+   *   localVideoStream = await navigator.mediaDevices.getUserMedia(
+   *     VIDEO_CONSTRAINTS
+   *   );
+   *   localVideoStream
+   *     .getTracks()
+   *     .forEach((track) => localStream.addTrack(track));
+   * } catch (error) {
+   *  console.error("Couldn't get camera permission:", error);
+   * }
+   *
+   * localStream
+   *  .getTracks()
+   *  .forEach((track) => webrtc.addTrack(track, localStream));
+   * ```
+   */
+  async addTrack(track, trackMetadata, simulcastConfig = {
+    enabled: false,
+    enabledVariants: [],
+    disabledVariants: []
+  }, maxBandwidth = 0) {
+    const resolutionNotifier = new Deferred();
+    const trackId = this.getTrackId(uuidv4());
+    const stream = new MediaStream();
+    try {
+      stream.addTrack(track);
+      this.commandsQueue.pushCommand({
+        handler: async () => this.localTrackManager.addTrackHandler(trackId, track, stream, trackMetadata, simulcastConfig, maxBandwidth),
+        parse: () => this.localTrackManager.parseAddTrack(track, simulcastConfig, maxBandwidth),
+        resolve: "after-renegotiation",
+        resolutionNotifier
+      });
+    } catch (error) {
+      resolutionNotifier.reject(error);
+    }
+    await resolutionNotifier.promise;
+    this.emit("localTrackAdded", {
+      trackId,
+      track,
+      stream,
+      trackMetadata,
+      simulcastConfig,
+      maxBandwidth
+    });
+    return trackId;
+  }
+  /**
+   * Replaces a track that is being sent to the RTC Engine.
+   * @param trackId - Audio or video track.
+   * @param {string} trackId - Id of audio or video track to replace.
+   * @param {MediaStreamTrack} newTrack
+   * @returns {Promise<boolean>} success
+   * @example
+   * ```ts
+   * // setup camera
+   * let localStream: MediaStream = new MediaStream();
+   * try {
+   *   localVideoStream = await navigator.mediaDevices.getUserMedia(
+   *     VIDEO_CONSTRAINTS
+   *   );
+   *   localVideoStream
+   *     .getTracks()
+   *     .forEach((track) => localStream.addTrack(track));
+   * } catch (error) {
+   *   console.error("Couldn't get camera permission:", error);
+   * }
+   * let oldTrackId;
+   * localStream
+   *  .getTracks()
+   *  .forEach((track) => trackId = webrtc.addTrack(track, localStream));
+   *
+   * // change camera
+   * const oldTrack = localStream.getVideoTracks()[0];
+   * let videoDeviceId = "abcd-1234";
+   * navigator.mediaDevices.getUserMedia({
+   *      video: {
+   *        ...(VIDEO_CONSTRAINTS as {}),
+   *        deviceId: {
+   *          exact: videoDeviceId,
+   *        },
+   *      }
+   *   })
+   *   .then((stream) => {
+   *     let videoTrack = stream.getVideoTracks()[0];
+   *     webrtc.replaceTrack(oldTrackId, videoTrack);
+   *   })
+   *   .catch((error) => {
+   *     console.error('Error switching camera', error);
+   *   })
+   * ```
+   */
+  async replaceTrack(trackId, newTrack) {
+    const resolutionNotifier = new Deferred();
+    this.commandsQueue.pushCommand({
+      handler: () => this.localTrackManager.replaceTrackHandler(this, trackId, newTrack),
+      resolutionNotifier,
+      resolve: "on-handler-resolve"
+    });
+    return resolutionNotifier.promise.then(() => {
+      this.emit("localTrackReplaced", { trackId, track: newTrack });
+    });
+  }
+  /**
+   * Updates maximum bandwidth for the track identified by trackId.
+   * This value directly translates to quality of the stream and, in case of video, to the amount of RTP packets being sent.
+   * In case trackId points at the simulcast track bandwidth is split between all of the variant streams proportionally to their resolution.
+   *
+   * @param {string} trackId
+   * @param {BandwidthLimit} bandwidth in kbps
+   * @returns {Promise<boolean>} success
+   */
+  setTrackBandwidth(trackId, bandwidth) {
+    if (!this.connectionManager) throw new Error(`There is no active RTCPeerConnection`);
+    return this.local.setTrackBandwidth(trackId, bandwidth);
+  }
+  /**
+   * Updates maximum bandwidth for the given simulcast encoding of the given track.
+   *
+   * @param {string} trackId - id of the track
+   * @param {string} rid - rid of the encoding
+   * @param {BandwidthLimit} bandwidth - desired max bandwidth used by the encoding (in kbps)
+   * @returns
+   */
+  async setEncodingBandwidth(trackId, rid, bandwidth) {
+    if (!this.connectionManager) throw new Error(`There is no active RTCPeerConnection`);
+    return await this.local.setEncodingBandwidth(trackId, rid, bandwidth);
+  }
+  /**
+   * Removes a track from connection that was sent to the RTC Engine.
+   * @param {string} trackId - Id of audio or video track to remove.
+   * @example
+   * ```ts
+   * // setup camera
+   * let localStream: MediaStream = new MediaStream();
+   * try {
+   *   localVideoStream = await navigator.mediaDevices.getUserMedia(
+   *     VIDEO_CONSTRAINTS
+   *   );
+   *   localVideoStream
+   *     .getTracks()
+   *     .forEach((track) => localStream.addTrack(track));
+   * } catch (error) {
+   *   console.error("Couldn't get camera permission:", error);
+   * }
+   *
+   * let trackId
+   * localStream
+   *  .getTracks()
+   *  .forEach((track) => trackId = webrtc.addTrack(track, localStream));
+   *
+   * // remove track
+   * webrtc.removeTrack(trackId)
+   * ```
+   */
+  async removeTrack(trackId) {
+    const resolutionNotifier = new Deferred();
+    this.commandsQueue.pushCommand({
+      handler: async () => this.localTrackManager.removeTrackHandler(trackId),
+      resolutionNotifier,
+      resolve: "after-renegotiation"
+    });
+    await resolutionNotifier.promise;
+    this.emit("localTrackRemoved", {
+      trackId
+    });
+  }
+  /**
+   * Sets track variant that server should send to the client library.
+   *
+   * The variant will be sent whenever it is available.
+   * If chosen variant is temporarily unavailable, some other variant
+   * will be sent until the chosen variant becomes active again.
+   *
+   * @param {string} trackId - id of track
+   * @param {Encoding} variant - variant to receive
+   * @example
+   * ```ts
+   * webrtc.setTargetTrackEncoding(incomingTrackCtx.trackId, "l")
+   * ```
+   */
+  setTargetTrackEncoding(trackId, variant) {
+    this.remote.setTargetRemoteTrackEncoding(trackId, variant);
+  }
+  /**
+   * Enables track encoding so that it will be sent to the server.
+   * @param {string} trackId - id of track
+   * @param {Encoding} encoding - encoding that will be enabled
+   * @example
+   * ```ts
+   * const trackId = webrtc.addTrack(track, stream, {}, {enabled: true, activeEncodings: ["l", "m", "h"]});
+   * webrtc.disableTrackEncoding(trackId, "l");
+   * // wait some time
+   * webrtc.enableTrackEncoding(trackId, "l");
+   * ```
+   */
+  enableTrackEncoding = async (trackId, encoding) => {
+    await this.local.enableLocalTrackEncoding(trackId, encoding);
+  };
+  /**
+   * Disables track encoding so that it will be no longer sent to the server.
+   * @param {string} trackId - id of track
+   * @param {Encoding} encoding - encoding that will be disabled
+   * @example
+   * ```ts
+   * const trackId = webrtc.addTrack(track, stream, {}, {enabled: true, activeEncodings: ["l", "m", "h"]});
+   * webrtc.disableTrackEncoding(trackId, "l");
+   * ```
+   */
+  disableTrackEncoding = async (trackId, encoding) => {
+    await this.local.disableLocalTrackEncoding(trackId, encoding);
+  };
+  /**
+   * Updates the metadata for the current endpoint.
+   * @param metadata - Data about this endpoint that other endpoints will receive upon being added.
+   *
+   * If the metadata is different from what is already tracked in the room, the optional
+   * event `endpointUpdated` will be emitted for other endpoint in the room.
+   */
+  updateEndpointMetadata = (metadata) => {
+    this.local.updateEndpointMetadata(metadata);
+  };
+  /**
+   * Updates the metadata for a specific track.
+   * @param trackId - trackId (generated in addTrack) of audio or video track.
+   * @param trackMetadata - Data about this track that other endpoint will receive upon being added.
+   *
+   * If the metadata is different from what is already tracked in the room, the optional
+   * event `trackUpdated` will be emitted for other endpoints in the room.
+   */
+  updateTrackMetadata = (trackId, trackMetadata) => {
+    this.local.updateLocalTrackMetadata(trackId, trackMetadata);
+  };
+  /**
+   * Disconnects from the room. This function should be called when user disconnects from the room
+   * in a clean way e.g. by clicking a dedicated, custom button `disconnect`.
+   * As a result there will be generated one more media event that should be
+   * sent to the RTC Engine. Thanks to it each other endpoint will be notified
+   * that endpoint was removed in {@link WebRTCEndpointEvents.endpointRemoved},
+   */
+  disconnect = () => {
+    const disconnect = MediaEvent_Disconnect.create();
+    this.sendMediaEvent({ disconnect });
+    this.emit("disconnectRequested", {});
+    this.cleanUp();
+  };
+  /**
+   * Cleans up {@link WebRTCEndpoint} instance.
+   */
+  cleanUp = () => {
+    if (this.connectionManager) {
+      this.clearConnectionCallbacks?.();
+      this.connectionManager?.getConnection().close();
+      this.commandsQueue.cleanUp();
+      this.localTrackManager.cleanUp();
+    }
+    this.connectionManager = void 0;
+  };
+  getTrackId(uuid) {
+    return `${this.getEndpointId()}:${uuid}`;
+  }
+  sendMediaEvent = (mediaEvent) => {
+    this.emit("sendMediaEvent", serializePeerMediaEvent(mediaEvent));
+  };
+  async createAndSendOffer() {
+    const connection = this.connectionManager;
+    if (!connection) return;
+    try {
+      this.localTrackManager.updateSenders();
+      const offer = await connection.getConnection().createOffer();
+      if (!this.connectionManager) {
+        console.warn("RTCPeerConnection stopped or restarted");
+        return;
+      }
+      await connection.getConnection().setLocalDescription(offer);
+      if (!this.connectionManager) {
+        console.warn("RTCPeerConnection stopped or restarted");
+        return;
+      }
+      const sdpOffer = this.local.createSdpOfferEvent(offer);
+      this.sendMediaEvent({ sdpOffer });
+      this.local.setLocalTrackStatusToOffered();
+    } catch (error) {
+      console.error(error);
+    }
+  }
+  onOfferData = async (offerData) => {
+    const connectionManager = this.connectionManager ?? this.createNewConnection();
+    if (offerData.tracksTypes) {
+      connectionManager.addTransceiversIfNeeded(offerData.tracksTypes);
+    }
+    await this.createAndSendOffer();
+  };
+  setupConnectionListeners = (connection) => {
+    const onIceCandidate = (event) => this.onLocalCandidate(event);
+    const onIceCandidateError = (event) => this.onIceCandidateError(event);
+    const onConnectionStateChange = (event) => this.onConnectionStateChange(event);
+    const onIceConnectionStateChange = (event) => this.onIceConnectionStateChange(event);
+    this.clearConnectionCallbacks = () => {
+      connection.removeEventListener("icecandidate", onIceCandidate);
+      connection.removeEventListener("icecandidateerror", onIceCandidateError);
+      connection.removeEventListener("connectionstatechange", onConnectionStateChange);
+      connection.removeEventListener("iceconnectionstatechange", onIceConnectionStateChange);
+    };
+    connection.addEventListener("icecandidate", onIceCandidate);
+    connection.addEventListener("icecandidateerror", onIceCandidateError);
+    connection.addEventListener("connectionstatechange", onConnectionStateChange);
+    connection.addEventListener("iceconnectionstatechange", onIceConnectionStateChange);
+  };
+  createNewConnection = () => {
+    const connectionManager = new ConnectionManager(this.proposedIceServers);
+    this.localTrackManager.updateConnection(connectionManager);
+    this.local.updateConnection(connectionManager);
+    this.setupConnectionListeners(connectionManager.getConnection());
+    this.commandsQueue.initConnection(connectionManager);
+    this.local.addAllTracksToConnection();
+    this.connectionManager = connectionManager;
+    return connectionManager;
+  };
+  onRemoteCandidate = async (candidate) => {
+    try {
+      const iceCandidate = new RTCIceCandidate(candidate);
+      if (!this.connectionManager) {
+        throw new Error("Received new remote candidate but RTCConnection is undefined");
+      }
+      await this.connectionManager.addIceCandidate(iceCandidate);
+    } catch (error) {
+      console.error(error);
+    }
+  };
+  onLocalCandidate = (event) => {
+    if (!event.candidate) return;
+    const candidate = Candidate.create({
+      candidate: event.candidate.candidate,
+      sdpMLineIndex: event.candidate.sdpMLineIndex ?? void 0,
+      sdpMid: event.candidate.sdpMid ?? void 0,
+      usernameFragment: event.candidate.usernameFragment ?? void 0
+    });
+    this.sendMediaEvent({ candidate });
+  };
+  onIceCandidateError = (event) => {
+    console.warn(event);
+  };
+  onConnectionStateChange = (event) => {
+    switch (this.localTrackManager.connection?.getConnection().connectionState) {
+      case "failed":
+        this.emit("connectionError", {
+          message: "RTCPeerConnection failed",
+          event
+        });
+        break;
+    }
+  };
+  onIceConnectionStateChange = (event) => {
+    switch (this.localTrackManager.connection?.getConnection().iceConnectionState) {
+      case "disconnected":
+        console.warn("ICE connection: disconnected");
+        this.sendMediaEvent({ renegotiateTracks: MediaEvent_RenegotiateTracks.create() });
+        break;
+      case "failed":
+        this.emit("connectionError", {
+          message: "ICE connection failed",
+          event
+        });
+        break;
+    }
+  };
+};
+export {
+  MediaEvent_Track_SimulcastConfig as SimulcastConfig,
+  Variant,
+  WebRTCEndpoint
+};