@observertc/observer-js 1.0.0-b276103.0 → 1.0.0-beta.10

package/dist/index.mjs

@@ -0,0 +1,3970 @@
+// src/common/logger.ts
+var mainLogger = new class {
+  trace = () => void 0;
+  // trace(module: string, ...args: any[]) {
+  // 	// eslint-disable-next-line no-console
+  // 	console.log(`[TRACE] ${module}`, ...args);
+  // }
+  debug(module, ...args) {
+    console.log(`[DEBUG] ${module}`, ...args);
+  }
+  info(module, ...args) {
+    console.info(`[INFO] ${module}`, ...args);
+  }
+  warn(module, ...args) {
+    console.warn(`[WARN] ${module}`, ...args);
+  }
+  error(module, ...args) {
+    console.error(`[ERROR] ${module}`, ...args);
+  }
+}();
+function createLogger(moduleName) {
+  return new class {
+    trace(...args) {
+      mainLogger.trace(moduleName, ...args);
+    }
+    debug(...args) {
+      mainLogger.debug(moduleName, ...args);
+    }
+    info(...args) {
+      mainLogger.info(moduleName, ...args);
+    }
+    warn(...args) {
+      mainLogger.warn(moduleName, ...args);
+    }
+    error(...args) {
+      mainLogger.error(moduleName, ...args);
+    }
+  }();
+}
+function setObserverLogger(logger8) {
+  mainLogger = logger8;
+}
+
+// src/ObservedCall.ts
+import { EventEmitter as EventEmitter3 } from "events";
+
+// src/ObservedClient.ts
+import { EventEmitter as EventEmitter2 } from "events";
+
+// src/ObservedPeerConnection.ts
+import { EventEmitter } from "events";
+
+// src/ObservedInboundRtp.ts
+var ObservedInboundRtp = class {
+  constructor(timestamp, id, ssrc, kind, trackIdentifier, _peerConnection) {
+    this.timestamp = timestamp;
+    this.id = id;
+    this.ssrc = ssrc;
+    this.kind = kind;
+    this.trackIdentifier = trackIdentifier;
+    this._peerConnection = _peerConnection;
+  }
+  timestamp;
+  id;
+  ssrc;
+  kind;
+  trackIdentifier;
+  _peerConnection;
+  appData;
+  _visited = false;
+  transportId;
+  codecId;
+  packetsReceived;
+  packetsLost;
+  mid;
+  remoteId;
+  framesDecoded;
+  keyFramesDecoded;
+  framesRendered;
+  framesDropped;
+  frameWidth;
+  frameHeight;
+  framesPerSecond;
+  qpSum;
+  totalDecodeTime;
+  totalInterFrameDelay;
+  totalSquaredInterFrameDelay;
+  pauseCount;
+  totalPausesDuration;
+  freezeCount;
+  totalFreezesDuration;
+  lastPacketReceivedTimestamp;
+  headerBytesReceived;
+  packetsDiscarded;
+  fecBytesReceived;
+  fecPacketsReceived;
+  fecPacketsDiscarded;
+  bytesReceived;
+  nackCount;
+  firCount;
+  pliCount;
+  totalProcessingDelay;
+  estimatedPlayoutTimestamp;
+  jitterBufferDelay;
+  jitterBufferTargetDelay;
+  jitterBufferEmittedCount;
+  jitterBufferMinimumDelay;
+  totalSamplesReceived;
+  concealedSamples;
+  silentConcealedSamples;
+  concealmentEvents;
+  insertedSamplesForDeceleration;
+  removedSamplesForAcceleration;
+  audioLevel;
+  totalAudioEnergy;
+  totalSamplesDuration;
+  framesReceived;
+  decoderImplementation;
+  playoutId;
+  powerEfficientDecoder;
+  framesAssembledFromMultiplePackets;
+  totalAssemblyTime;
+  retransmittedPacketsReceived;
+  retransmittedBytesReceived;
+  rtxSsrc;
+  fecSsrc;
+  totalCorruptionProbability;
+  totalSquaredCorruptionProbability;
+  corruptionMeasurements;
+  attachments;
+  jitter;
+  bitrate = 0;
+  fractionLost;
+  bitPerPixel = 0;
+  deltaLostPackets = 0;
+  deltaReceivedPackets = 0;
+  deltaBytesReceived = 0;
+  deltaReceivedSamples = 0;
+  deltaSilentConcealedSamples = 0;
+  // Derived from the corresponding remote-outbound-rtp (sender report), when present.
+  remoteRttInMs;
+  remoteBytesSent;
+  remotePacketsSent;
+  remoteTimestamp;
+  get visited() {
+    const visited = this._visited;
+    this._visited = false;
+    return visited;
+  }
+  getPeerConnection() {
+    return this._peerConnection;
+  }
+  getRemoteOutboundRtp() {
+    return this._peerConnection.observedRemoteOutboundRtps.get(this.ssrc);
+  }
+  getIceTransport() {
+    return this._peerConnection.observedIceTransports.get(this.transportId ?? "");
+  }
+  getCodec() {
+    return this._peerConnection.observedCodecs.get(this.codecId ?? "");
+  }
+  getMediaPlayout() {
+    return this._peerConnection.observedMediaPlayouts.get(this.playoutId ?? "");
+  }
+  getTrack() {
+    return this._peerConnection.observedInboundTracks.get(this.trackIdentifier);
+  }
+  update(stats) {
+    this._visited = true;
+    this.deltaBytesReceived = 0;
+    this.deltaLostPackets = 0;
+    this.deltaReceivedPackets = 0;
+    this.deltaReceivedSamples = 0;
+    this.deltaSilentConcealedSamples = 0;
+    this.remoteRttInMs = void 0;
+    this.remoteBytesSent = void 0;
+    this.remotePacketsSent = void 0;
+    this.remoteTimestamp = void 0;
+    this.bitrate = 0;
+    this.jitter = void 0;
+    this.fractionLost = void 0;
+    this.bitPerPixel = 0;
+    const elapsedTimeInMs = stats.timestamp - this.timestamp;
+    if (elapsedTimeInMs) {
+      if (this.bytesReceived && stats.bytesReceived && this.bytesReceived < stats.bytesReceived) {
+        this.bitrate = (stats.bytesReceived - (this.bytesReceived ?? 0)) * 8 / elapsedTimeInMs;
+      }
+      if (this.packetsLost && stats.packetsLost && this.packetsLost < stats.packetsLost) {
+        this.deltaLostPackets = stats.packetsLost - this.packetsLost;
+      }
+      if (this.packetsReceived && stats.packetsReceived && this.packetsReceived < stats.packetsReceived) {
+        this.deltaReceivedPackets = stats.packetsReceived - this.packetsReceived;
+      }
+      if (this.totalSamplesReceived && stats.totalSamplesReceived && this.totalSamplesReceived < stats.totalSamplesReceived) {
+        this.deltaReceivedSamples = stats.totalSamplesReceived - this.totalSamplesReceived;
+      }
+      if (this.silentConcealedSamples && stats.silentConcealedSamples && this.silentConcealedSamples < stats.silentConcealedSamples) {
+        this.deltaSilentConcealedSamples = stats.silentConcealedSamples - this.silentConcealedSamples;
+      }
+      if (stats.bytesReceived && this.framesReceived && stats.framesReceived && this.framesReceived < stats.framesReceived) {
+        this.bitPerPixel = (stats.bytesReceived - (this.bytesReceived ?? 0)) / (stats.framesReceived - this.framesReceived);
+      }
+      if (this.deltaLostPackets && this.deltaReceivedPackets) {
+        this.fractionLost = this.deltaLostPackets / (this.deltaLostPackets + this.deltaReceivedPackets);
+      }
+    }
+    this.timestamp = stats.timestamp;
+    this.transportId = stats.transportId;
+    this.codecId = stats.codecId;
+    this.packetsReceived = stats.packetsReceived;
+    this.packetsLost = stats.packetsLost;
+    this.mid = stats.mid;
+    this.remoteId = stats.remoteId;
+    this.framesDecoded = stats.framesDecoded;
+    this.keyFramesDecoded = stats.keyFramesDecoded;
+    this.framesRendered = stats.framesRendered;
+    this.framesDropped = stats.framesDropped;
+    this.frameWidth = stats.frameWidth;
+    this.frameHeight = stats.frameHeight;
+    this.framesPerSecond = stats.framesPerSecond;
+    this.qpSum = stats.qpSum;
+    this.totalDecodeTime = stats.totalDecodeTime;
+    this.totalInterFrameDelay = stats.totalInterFrameDelay;
+    this.totalSquaredInterFrameDelay = stats.totalSquaredInterFrameDelay;
+    this.pauseCount = stats.pauseCount;
+    this.totalPausesDuration = stats.totalPausesDuration;
+    this.freezeCount = stats.freezeCount;
+    this.totalFreezesDuration = stats.totalFreezesDuration;
+    this.lastPacketReceivedTimestamp = stats.lastPacketReceivedTimestamp;
+    this.headerBytesReceived = stats.headerBytesReceived;
+    this.packetsDiscarded = stats.packetsDiscarded;
+    this.fecBytesReceived = stats.fecBytesReceived;
+    this.fecPacketsReceived = stats.fecPacketsReceived;
+    this.fecPacketsDiscarded = stats.fecPacketsDiscarded;
+    this.bytesReceived = stats.bytesReceived;
+    this.nackCount = stats.nackCount;
+    this.firCount = stats.firCount;
+    this.pliCount = stats.pliCount;
+    this.totalProcessingDelay = stats.totalProcessingDelay;
+    this.estimatedPlayoutTimestamp = stats.estimatedPlayoutTimestamp;
+    this.jitterBufferDelay = stats.jitterBufferDelay;
+    this.jitterBufferTargetDelay = stats.jitterBufferTargetDelay;
+    this.jitterBufferEmittedCount = stats.jitterBufferEmittedCount;
+    this.jitterBufferMinimumDelay = stats.jitterBufferMinimumDelay;
+    this.totalSamplesReceived = stats.totalSamplesReceived;
+    this.concealedSamples = stats.concealedSamples;
+    this.silentConcealedSamples = stats.silentConcealedSamples;
+    this.concealmentEvents = stats.concealmentEvents;
+  }
+};
+
+// src/ObservedOutboundRtp.ts
+var ObservedOutboundRtp = class {
+  constructor(timestamp, id, ssrc, kind, _peerConnection) {
+    this.timestamp = timestamp;
+    this.id = id;
+    this.ssrc = ssrc;
+    this.kind = kind;
+    this._peerConnection = _peerConnection;
+  }
+  timestamp;
+  id;
+  ssrc;
+  kind;
+  _peerConnection;
+  _visited = false;
+  appData;
+  transportId;
+  codecId;
+  packetsSent;
+  bytesSent;
+  mid;
+  mediaSourceId;
+  remoteId;
+  rid;
+  headerBytesSent;
+  retransmittedPacketsSent;
+  retransmittedBytesSent;
+  rtxSsrc;
+  targetBitrate;
+  totalEncodedBytesTarget;
+  frameWidth;
+  frameHeight;
+  framesPerSecond;
+  framesSent;
+  hugeFramesSent;
+  framesEncoded;
+  keyFramesEncoded;
+  qpSum;
+  totalEncodeTime;
+  totalPacketSendDelay;
+  qualityLimitationReason;
+  qualityLimitationResolutionChanges;
+  nackCount;
+  firCount;
+  pliCount;
+  encoderImplementation;
+  powerEfficientEncoder;
+  active;
+  scalabilityMode;
+  qualityLimitationDurations;
+  attachments;
+  // derived fields
+  bitrate = 0;
+  payloadBitrate = 0;
+  packetRate = 0;
+  bitPerPixel = 0;
+  deltaPacketsSent = 0;
+  deltaBytesSent = 0;
+  // Derived from the corresponding remote-inbound-rtp (receiver report), when present.
+  remoteRttInMs;
+  remoteFractionLost;
+  remoteJitter;
+  remotePacketsLost;
+  get visited() {
+    const visited = this._visited;
+    this._visited = false;
+    return visited;
+  }
+  getPeerConnection() {
+    return this._peerConnection;
+  }
+  getRemoteInboundRtp() {
+    return this._peerConnection.observedRemoteInboundRtps.get(this.ssrc);
+  }
+  getCodec() {
+    return this._peerConnection.observedCodecs.get(this.codecId ?? "");
+  }
+  getMediaSource() {
+    return this._peerConnection.observedMediaSources.get(this.mediaSourceId ?? "");
+  }
+  getTrack() {
+    return this.getMediaSource()?.getTrack();
+  }
+  update(stats) {
+    this._visited = true;
+    this.bitPerPixel = 0;
+    this.bitrate = 0;
+    this.payloadBitrate = 0;
+    this.packetRate = 0;
+    this.deltaPacketsSent = 0;
+    this.deltaBytesSent = 0;
+    this.remoteRttInMs = void 0;
+    this.remoteFractionLost = void 0;
+    this.remoteJitter = void 0;
+    this.remotePacketsLost = void 0;
+    const elapsedTimeInMs = stats.timestamp - this.timestamp;
+    if (elapsedTimeInMs) {
+      if (stats.packetsSent !== void 0 && this.packetsSent !== void 0 && stats.packetsSent >= this.packetsSent) {
+        this.deltaPacketsSent = stats.packetsSent - this.packetsSent;
+        this.packetRate = this.deltaPacketsSent / (elapsedTimeInMs / 1e3);
+      }
+      if (stats.bytesSent !== void 0 && this.bytesSent !== void 0 && stats.bytesSent >= this.bytesSent) {
+        this.deltaBytesSent = stats.bytesSent - this.bytesSent;
+        this.bitrate = this.deltaBytesSent * 8 / (elapsedTimeInMs / 1e3);
+      }
+      if (stats.headerBytesSent !== void 0 && this.headerBytesSent !== void 0) {
+        this.payloadBitrate = (this.deltaBytesSent ?? 0 - (stats.headerBytesSent - this.headerBytesSent)) * 8 / (elapsedTimeInMs / 1e3);
+      }
+      if (this.framesSent !== void 0 && stats.framesSent !== void 0) {
+        this.bitPerPixel = this.deltaBytesSent ? this.deltaBytesSent * 8 / (this.framesSent - stats.framesSent) : 0;
+      }
+    }
+    this.timestamp = stats.timestamp;
+    this.transportId = stats.transportId;
+    this.codecId = stats.codecId;
+    this.packetsSent = stats.packetsSent;
+    this.bytesSent = stats.bytesSent;
+    this.mid = stats.mid;
+    this.mediaSourceId = stats.mediaSourceId;
+    this.remoteId = stats.remoteId;
+    this.rid = stats.rid;
+    this.headerBytesSent = stats.headerBytesSent;
+    this.retransmittedPacketsSent = stats.retransmittedPacketsSent;
+    this.retransmittedBytesSent = stats.retransmittedBytesSent;
+    this.rtxSsrc = stats.rtxSsrc;
+    this.targetBitrate = stats.targetBitrate;
+    this.totalEncodedBytesTarget = stats.totalEncodedBytesTarget;
+    this.frameWidth = stats.frameWidth;
+    this.frameHeight = stats.frameHeight;
+    this.framesPerSecond = stats.framesPerSecond;
+    this.framesSent = stats.framesSent;
+    this.hugeFramesSent = stats.hugeFramesSent;
+    this.framesEncoded = stats.framesEncoded;
+    this.keyFramesEncoded = stats.keyFramesEncoded;
+    this.qpSum = stats.qpSum;
+    this.totalEncodeTime = stats.totalEncodeTime;
+    this.totalPacketSendDelay = stats.totalPacketSendDelay;
+    this.qualityLimitationReason = stats.qualityLimitationReason;
+    this.qualityLimitationResolutionChanges = stats.qualityLimitationResolutionChanges;
+    this.nackCount = stats.nackCount;
+    this.firCount = stats.firCount;
+    this.pliCount = stats.pliCount;
+    this.encoderImplementation = stats.encoderImplementation;
+    this.powerEfficientEncoder = stats.powerEfficientEncoder;
+    this.active = stats.active;
+    this.scalabilityMode = stats.scalabilityMode;
+    this.qualityLimitationDurations = stats.qualityLimitationDurations;
+    this.attachments = stats.attachments;
+  }
+};
+
+// src/ObservedCertificate.ts
+var ObservedCertificate = class {
+  constructor(timestamp, id, _peerConnection) {
+    this.timestamp = timestamp;
+    this.id = id;
+    this._peerConnection = _peerConnection;
+  }
+  timestamp;
+  id;
+  _peerConnection;
+  appData;
+  _visited = false;
+  fingerprint;
+  fingerprintAlgorithm;
+  base64Certificate;
+  issuerCertificateId;
+  attachments;
+  get visited() {
+    const visited = this._visited;
+    this._visited = false;
+    return visited;
+  }
+  getPeerConnection() {
+    return this._peerConnection;
+  }
+  update(stats) {
+    this._visited = true;
+    this.timestamp = stats.timestamp;
+    this.fingerprint = stats.fingerprint;
+    this.fingerprintAlgorithm = stats.fingerprintAlgorithm;
+    this.base64Certificate = stats.base64Certificate;
+    this.issuerCertificateId = stats.issuerCertificateId;
+    this.attachments = stats.attachments;
+  }
+};
+
+// src/ObservedCodec.ts
+var ObservedCodec = class {
+  constructor(timestamp, id, mimeType, _peerConnection) {
+    this.timestamp = timestamp;
+    this.id = id;
+    this.mimeType = mimeType;
+    this._peerConnection = _peerConnection;
+  }
+  timestamp;
+  id;
+  mimeType;
+  _peerConnection;
+  _visited = false;
+  appData;
+  payloadType;
+  transportId;
+  clockRate;
+  channels;
+  sdpFmtpLine;
+  attachments;
+  get visited() {
+    const visited = this._visited;
+    this._visited = false;
+    return visited;
+  }
+  getPeerConnection() {
+    return this._peerConnection;
+  }
+  getIceTransport() {
+    return this._peerConnection.observedIceTransports.get(this.transportId ?? "");
+  }
+  update(stats) {
+    this._visited = true;
+    this.timestamp = stats.timestamp;
+    this.payloadType = stats.payloadType;
+    this.transportId = stats.transportId;
+    this.clockRate = stats.clockRate;
+    this.channels = stats.channels;
+    this.sdpFmtpLine = stats.sdpFmtpLine;
+    this.attachments = stats.attachments;
+  }
+};
+
+// src/ObservedDataChannel.ts
+var ObservedDataChannel = class {
+  constructor(timestamp, id, _peerConnection) {
+    this.timestamp = timestamp;
+    this.id = id;
+    this._peerConnection = _peerConnection;
+  }
+  timestamp;
+  id;
+  _peerConnection;
+  _visited = false;
+  label;
+  protocol;
+  dataChannelIdentifier;
+  state;
+  messagesSent;
+  bytesSent;
+  messagesReceived;
+  bytesReceived;
+  attachments;
+  addedAt;
+  removedAt;
+  deltaBytesSent = 0;
+  deltaBytesReceived = 0;
+  deltaMessagesSent = 0;
+  deltaMessagesReceived = 0;
+  appData;
+  get visited() {
+    const visited = this._visited;
+    this._visited = false;
+    return visited;
+  }
+  getPeerConnection() {
+    return this._peerConnection;
+  }
+  update(stats) {
+    this._visited = true;
+    if (this.messagesSent && stats.messagesSent && stats.messagesSent >= this.messagesSent) {
+      this.deltaMessagesSent = stats.messagesSent - this.messagesSent;
+    } else {
+      this.deltaMessagesSent = 0;
+    }
+    if (this.messagesReceived && stats.messagesReceived && stats.messagesReceived >= this.messagesReceived) {
+      this.deltaMessagesReceived = stats.messagesReceived - this.messagesReceived;
+    } else {
+      this.deltaMessagesReceived = 0;
+    }
+    if (this.bytesSent && stats.bytesSent && stats.bytesSent >= this.bytesSent) {
+      this.deltaBytesSent = stats.bytesSent - this.bytesSent;
+    } else {
+      this.deltaBytesSent = 0;
+    }
+    if (this.bytesReceived && stats.bytesReceived && stats.bytesReceived >= this.bytesReceived) {
+      this.deltaBytesReceived = stats.bytesReceived - this.bytesReceived;
+    } else {
+      this.deltaBytesReceived = 0;
+    }
+    this.label = stats.label;
+    this.protocol = stats.protocol;
+    this.dataChannelIdentifier = stats.dataChannelIdentifier;
+    this.state = stats.state;
+    this.messagesSent = stats.messagesSent;
+    this.bytesSent = stats.bytesSent;
+    this.messagesReceived = stats.messagesReceived;
+    this.bytesReceived = stats.bytesReceived;
+    this.attachments = stats.attachments;
+  }
+};
+
+// src/ObservedIceCandidate.ts
+var ObservedIceCandidate = class {
+  constructor(timestamp, id, _peerConnection) {
+    this.timestamp = timestamp;
+    this.id = id;
+    this._peerConnection = _peerConnection;
+  }
+  timestamp;
+  id;
+  _peerConnection;
+  _visited = false;
+  appData;
+  transportId;
+  address;
+  port;
+  protocol;
+  candidateType;
+  priority;
+  url;
+  relayProtocol;
+  foundation;
+  relatedAddress;
+  relatedPort;
+  usernameFragment;
+  tcpType;
+  attachments;
+  get visited() {
+    const visited = this._visited;
+    this._visited = false;
+    return visited;
+  }
+  getPeerConnection() {
+    return this._peerConnection;
+  }
+  getIceTransport() {
+    return this._peerConnection.observedIceTransports.get(this.transportId ?? "");
+  }
+  update(stats) {
+    this._visited = true;
+    this.timestamp = stats.timestamp;
+    this.transportId = stats.transportId;
+    this.address = stats.address;
+    this.port = stats.port;
+    this.protocol = stats.protocol;
+    this.candidateType = stats.candidateType;
+    this.priority = stats.priority;
+    this.url = stats.url;
+    this.relayProtocol = stats.relayProtocol;
+    this.foundation = stats.foundation;
+    this.relatedAddress = stats.relatedAddress;
+    this.relatedPort = stats.relatedPort;
+    this.usernameFragment = stats.usernameFragment;
+    this.tcpType = stats.tcpType;
+    this.attachments = stats.attachments;
+  }
+};
+
+// src/ObservedIceCandidatePair.ts
+var ObservedIceCandidatePair = class {
+  constructor(timestamp, id, _peerConnection) {
+    this.timestamp = timestamp;
+    this.id = id;
+    this._peerConnection = _peerConnection;
+  }
+  timestamp;
+  id;
+  _peerConnection;
+  _visited = false;
+  appData;
+  transportId;
+  localCandidateId;
+  remoteCandidateId;
+  state;
+  nominated;
+  packetsSent;
+  packetsReceived;
+  bytesSent;
+  bytesReceived;
+  lastPacketSentTimestamp;
+  lastPacketReceivedTimestamp;
+  totalRoundTripTime;
+  currentRoundTripTime;
+  availableOutgoingBitrate;
+  availableIncomingBitrate;
+  requestsReceived;
+  requestsSent;
+  responsesReceived;
+  responsesSent;
+  consentRequestsSent;
+  packetsDiscardedOnSend;
+  bytesDiscardedOnSend;
+  attachments;
+  deltaBytesSent = 0;
+  deltaBytesReceived = 0;
+  deltaPacketsSent = 0;
+  deltaPacketsReceived = 0;
+  get visited() {
+    const visited = this._visited;
+    this._visited = false;
+    return visited;
+  }
+  getPeerConnection() {
+    return this._peerConnection;
+  }
+  getIceTransport() {
+    return this._peerConnection.observedIceTransports.get(this.transportId ?? "");
+  }
+  getLocalCandidate() {
+    return this._peerConnection.observedIceCandidates.get(this.localCandidateId ?? "");
+  }
+  getRemoteCandidate() {
+    return this._peerConnection.observedIceCandidates.get(this.remoteCandidateId ?? "");
+  }
+  update(stats) {
+    this._visited = true;
+    if (this.packetsSent && stats.packetsSent && stats.packetsSent >= this.packetsSent) {
+      this.deltaPacketsSent = stats.packetsSent - this.packetsSent;
+    } else {
+      this.deltaPacketsSent = 0;
+    }
+    if (this.packetsReceived && stats.packetsReceived && stats.packetsReceived >= this.packetsReceived) {
+      this.deltaPacketsReceived = stats.packetsReceived - this.packetsReceived;
+    } else {
+      this.deltaPacketsReceived = 0;
+    }
+    if (this.bytesSent && stats.bytesSent && stats.bytesSent >= this.bytesSent) {
+      this.deltaBytesSent = stats.bytesSent - this.bytesSent;
+    } else {
+      this.deltaBytesSent = 0;
+    }
+    if (this.bytesReceived && stats.bytesReceived && stats.bytesReceived >= this.bytesReceived) {
+      this.deltaBytesReceived = stats.bytesReceived - this.bytesReceived;
+    } else {
+      this.deltaBytesReceived = 0;
+    }
+    this.timestamp = stats.timestamp;
+    this.transportId = stats.transportId;
+    this.localCandidateId = stats.localCandidateId;
+    this.remoteCandidateId = stats.remoteCandidateId;
+    this.state = this._convertState(stats.state);
+    this.nominated = stats.nominated;
+    this.packetsSent = stats.packetsSent;
+    this.packetsReceived = stats.packetsReceived;
+    this.bytesSent = stats.bytesSent;
+    this.bytesReceived = stats.bytesReceived;
+    this.lastPacketSentTimestamp = stats.lastPacketSentTimestamp;
+    this.lastPacketReceivedTimestamp = stats.lastPacketReceivedTimestamp;
+    this.totalRoundTripTime = stats.totalRoundTripTime;
+    this.currentRoundTripTime = stats.currentRoundTripTime;
+    this.availableOutgoingBitrate = stats.availableOutgoingBitrate;
+    this.availableIncomingBitrate = stats.availableIncomingBitrate;
+    this.requestsReceived = stats.requestsReceived;
+    this.requestsSent = stats.requestsSent;
+    this.responsesReceived = stats.responsesReceived;
+    this.responsesSent = stats.responsesSent;
+    this.consentRequestsSent = stats.consentRequestsSent;
+    this.packetsDiscardedOnSend = stats.packetsDiscardedOnSend;
+    this.bytesDiscardedOnSend = stats.bytesDiscardedOnSend;
+    this.attachments = stats.attachments;
+  }
+  _convertState(state) {
+    switch (state) {
+      case "new":
+      case "in-progress":
+      case "waiting":
+      case "failed":
+      case "succeeded":
+        return state;
+      case "cancelled":
+        return "failed";
+      case "inprogress":
+        return "in-progress";
+      default:
+        return void 0;
+    }
+  }
+};
+
+// src/ObservedIceTransport.ts
+var ObservedIceTransport = class {
+  constructor(timestamp, id, _peerConnection) {
+    this.timestamp = timestamp;
+    this.id = id;
+    this._peerConnection = _peerConnection;
+  }
+  timestamp;
+  id;
+  _peerConnection;
+  _visited = false;
+  appData;
+  packetsSent;
+  packetsReceived;
+  bytesSent;
+  bytesReceived;
+  iceRole;
+  iceLocalUsernameFragment;
+  dtlsState;
+  iceState;
+  selectedCandidatePairId;
+  localCertificateId;
+  remoteCertificateId;
+  tlsVersion;
+  dtlsCipher;
+  dtlsRole;
+  srtpCipher;
+  selectedCandidatePairChanges;
+  attachments;
+  deltaPacketsReceived = 0;
+  deltaPacketsSent = 0;
+  deltaBytesReceived = 0;
+  deltaBytesSent = 0;
+  get visited() {
+    const visited = this._visited;
+    this._visited = false;
+    return visited;
+  }
+  getPeerConnection() {
+    return this._peerConnection;
+  }
+  getSelectedCandidatePair() {
+    return this._peerConnection.observedIceCandidatesPair.get(this.selectedCandidatePairId ?? "");
+  }
+  update(stats) {
+    this._visited = true;
+    if (this.bytesReceived !== void 0 && stats.bytesReceived !== void 0 && this.bytesReceived <= stats.bytesReceived) {
+      this.deltaBytesReceived = stats.bytesReceived - this.bytesReceived;
+    } else {
+      this.deltaBytesReceived = 0;
+    }
+    if (this.bytesSent !== void 0 && stats.bytesSent !== void 0 && this.bytesSent <= stats.bytesSent) {
+      this.deltaBytesSent = stats.bytesSent - this.bytesSent;
+    } else {
+      this.deltaBytesSent = 0;
+    }
+    if (this.packetsReceived !== void 0 && stats.packetsReceived !== void 0 && this.packetsReceived <= stats.packetsReceived) {
+      this.deltaPacketsReceived = stats.packetsReceived - this.packetsReceived;
+    } else {
+      this.deltaPacketsReceived = 0;
+    }
+    if (this.packetsSent !== void 0 && stats.packetsSent !== void 0 && this.packetsSent <= stats.packetsSent) {
+      this.deltaPacketsSent = stats.packetsSent - this.packetsSent;
+    } else {
+      this.deltaPacketsSent = 0;
+    }
+    this.timestamp = stats.timestamp;
+    this.packetsSent = stats.packetsSent;
+    this.packetsReceived = stats.packetsReceived;
+    this.bytesSent = stats.bytesSent;
+    this.bytesReceived = stats.bytesReceived;
+    this.iceRole = stats.iceRole;
+    this.iceLocalUsernameFragment = stats.iceLocalUsernameFragment;
+    this.dtlsState = stats.dtlsState;
+    this.iceState = stats.iceState;
+    this.selectedCandidatePairId = stats.selectedCandidatePairId;
+    this.localCertificateId = stats.localCertificateId;
+    this.remoteCertificateId = stats.remoteCertificateId;
+    this.tlsVersion = stats.tlsVersion;
+    this.dtlsCipher = stats.dtlsCipher;
+    this.dtlsRole = stats.dtlsRole;
+    this.srtpCipher = stats.srtpCipher;
+    this.selectedCandidatePairChanges = stats.selectedCandidatePairChanges;
+    this.attachments = stats.attachments;
+  }
+};
+
+// src/ObservedMediaSource.ts
+var ObservedMediaSource = class {
+  constructor(timestamp, id, kind, _peerConnection) {
+    this.timestamp = timestamp;
+    this.id = id;
+    this.kind = kind;
+    this._peerConnection = _peerConnection;
+  }
+  timestamp;
+  id;
+  kind;
+  _peerConnection;
+  _visited = false;
+  appData;
+  trackIdentifier;
+  audioLevel;
+  totalAudioEnergy;
+  totalSamplesDuration;
+  echoReturnLoss;
+  echoReturnLossEnhancement;
+  width;
+  height;
+  frames;
+  framesPerSecond;
+  attachments;
+  get visited() {
+    const visited = this._visited;
+    this._visited = false;
+    return visited;
+  }
+  getPeerConnection() {
+    return this._peerConnection;
+  }
+  getTrack() {
+    return this._peerConnection.observedOutboundTracks.get(this.trackIdentifier ?? "");
+  }
+  update(stats) {
+    this._visited = true;
+    this.timestamp = stats.timestamp;
+    this.trackIdentifier = stats.trackIdentifier;
+    this.audioLevel = stats.audioLevel;
+    this.totalAudioEnergy = stats.totalAudioEnergy;
+    this.totalSamplesDuration = stats.totalSamplesDuration;
+    this.echoReturnLoss = stats.echoReturnLoss;
+    this.echoReturnLossEnhancement = stats.echoReturnLossEnhancement;
+    this.width = stats.width;
+    this.height = stats.height;
+    this.frames = stats.frames;
+    this.framesPerSecond = stats.framesPerSecond;
+    this.attachments = stats.attachments;
+  }
+};
+
+// src/ObservedPeerConnectionTransport.ts
+var ObservedPeerConnectionTransport = class {
+  constructor(timestamp, id, _peerConnection) {
+    this.timestamp = timestamp;
+    this.id = id;
+    this._peerConnection = _peerConnection;
+  }
+  timestamp;
+  id;
+  _peerConnection;
+  _visited = false;
+  appData;
+  dataChannelsOpened;
+  dataChannelsClosed;
+  attachments;
+  get visited() {
+    const visited = this._visited;
+    this._visited = false;
+    return visited;
+  }
+  getPeerConnection() {
+    return this._peerConnection;
+  }
+  update(stats) {
+    this._visited = true;
+    this.timestamp = stats.timestamp;
+    this.dataChannelsOpened = stats.dataChannelsOpened;
+    this.dataChannelsClosed = stats.dataChannelsClosed;
+    this.attachments = stats.attachments;
+  }
+};
+
+// src/ObservedMediaPlayout.ts
+var ObservedMediaPlayout = class {
+  constructor(timestamp, id, kind, _peerConnection) {
+    this.timestamp = timestamp;
+    this.id = id;
+    this.kind = kind;
+    this._peerConnection = _peerConnection;
+  }
+  timestamp;
+  id;
+  kind;
+  _peerConnection;
+  _visited = false;
+  appData;
+  synthesizedSamplesDuration;
+  synthesizedSamplesEvents;
+  totalSamplesDuration;
+  totalPlayoutDelay;
+  totalSamplesCount;
+  attachments;
+  get visited() {
+    const visited = this._visited;
+    this._visited = false;
+    return visited;
+  }
+  getPeerConnection() {
+    return this._peerConnection;
+  }
+  update(stats) {
+    this._visited = true;
+    this.timestamp = stats.timestamp;
+    this.synthesizedSamplesDuration = stats.synthesizedSamplesDuration;
+    this.synthesizedSamplesEvents = stats.synthesizedSamplesEvents;
+    this.totalSamplesDuration = stats.totalSamplesDuration;
+    this.totalPlayoutDelay = stats.totalPlayoutDelay;
+    this.totalSamplesCount = stats.totalSamplesCount;
+    this.attachments = stats.attachments;
+  }
+};
+
+// src/ObservedRemoteInboundRtp.ts
+var ObservedRemoteInboundRtp = class {
+  constructor(timestamp, id, ssrc, kind, _peerConnection) {
+    this.timestamp = timestamp;
+    this.id = id;
+    this.ssrc = ssrc;
+    this.kind = kind;
+    this._peerConnection = _peerConnection;
+  }
+  timestamp;
+  id;
+  ssrc;
+  kind;
+  _peerConnection;
+  _visited = false;
+  appData;
+  transportId;
+  codecId;
+  packetsReceived;
+  packetsLost;
+  jitter;
+  localId;
+  roundTripTime;
+  totalRoundTripTime;
+  fractionLost;
+  roundTripTimeMeasurements;
+  attachments;
+  get visited() {
+    const visited = this._visited;
+    this._visited = false;
+    return visited;
+  }
+  getPeerConnection() {
+    return this._peerConnection;
+  }
+  getOutboundRtp() {
+    return this._peerConnection.observedOutboundRtps.get(this.ssrc);
+  }
+  getCodec() {
+    return this._peerConnection.observedCodecs.get(this.codecId ?? "");
+  }
+  update(stats) {
+    this._visited = true;
+    this.timestamp = stats.timestamp;
+    this.transportId = stats.transportId;
+    this.codecId = stats.codecId;
+    this.packetsReceived = stats.packetsReceived;
+    this.packetsLost = stats.packetsLost;
+    this.jitter = stats.jitter;
+    this.localId = stats.localId;
+    this.roundTripTime = stats.roundTripTime;
+    this.totalRoundTripTime = stats.totalRoundTripTime;
+    this.fractionLost = stats.fractionLost;
+    this.roundTripTimeMeasurements = stats.roundTripTimeMeasurements;
+    this.attachments = stats.attachments;
+  }
+};
+
+// src/ObservedRemoteOutboundRtp.ts
+var ObservedRemoteOutboundRtp = class {
+  constructor(timestamp, id, ssrc, kind, _peerConnection) {
+    this.timestamp = timestamp;
+    this.id = id;
+    this.ssrc = ssrc;
+    this.kind = kind;
+    this._peerConnection = _peerConnection;
+  }
+  timestamp;
+  id;
+  ssrc;
+  kind;
+  _peerConnection;
+  _visited = false;
+  appData;
+  transportId;
+  codecId;
+  packetsSent;
+  bytesSent;
+  localId;
+  remoteTimestamp;
+  reportsSent;
+  roundTripTime;
+  totalRoundTripTime;
+  roundTripTimeMeasurements;
+  attachments;
+  get visited() {
+    const visited = this._visited;
+    this._visited = false;
+    return visited;
+  }
+  getPeerConnection() {
+    return this._peerConnection;
+  }
+  getInboundRtp() {
+    return this._peerConnection.observedInboundRtps.get(this.ssrc);
+  }
+  getCodec() {
+    return this._peerConnection.observedCodecs.get(this.codecId ?? "");
+  }
+  update(stats) {
+    this._visited = true;
+    this.timestamp = stats.timestamp;
+    this.transportId = stats.transportId;
+    this.codecId = stats.codecId;
+    this.packetsSent = stats.packetsSent;
+    this.bytesSent = stats.bytesSent;
+    this.localId = stats.localId;
+    this.remoteTimestamp = stats.remoteTimestamp;
+    this.reportsSent = stats.reportsSent;
+    this.roundTripTime = stats.roundTripTime;
+    this.totalRoundTripTime = stats.totalRoundTripTime;
+    this.roundTripTimeMeasurements = stats.roundTripTimeMeasurements;
+    this.attachments = stats.attachments;
+  }
+};
+
+// src/ObservedInboundTrack.ts
+var ObservedInboundTrack = class {
+  constructor(timestamp, id, kind, _peerConnection, _inboundRtp, _mediaPlayout) {
+    this.timestamp = timestamp;
+    this.id = id;
+    this.kind = kind;
+    this._peerConnection = _peerConnection;
+    this._inboundRtp = _inboundRtp;
+    this._mediaPlayout = _mediaPlayout;
+  }
+  timestamp;
+  id;
+  kind;
+  _peerConnection;
+  _inboundRtp;
+  _mediaPlayout;
+  calculatedScore = {
+    weight: 1,
+    value: void 0
+  };
+  appData;
+  remoteOutboundTrack;
+  _visited = false;
+  addedAt;
+  removedAt;
+  muted;
+  attachments;
+  get score() {
+    return this.calculatedScore.value;
+  }
+  get visited() {
+    const visited = this._visited;
+    this._visited = false;
+    return visited;
+  }
+  getPeerConnection() {
+    return this._peerConnection;
+  }
+  getInboundRtp() {
+    return this._inboundRtp;
+  }
+  getMediaPlayout() {
+    return this._mediaPlayout;
+  }
+  update(stats) {
+    this._visited = true;
+    this.timestamp = stats.timestamp;
+    this.calculatedScore.value = stats.score;
+    this.attachments = stats.attachments;
+  }
+};
+
+// src/ObservedOutboundTrack.ts
+var ObservedOutboundTrack = class {
+  constructor(timestamp, id, kind, _peerConnection, _outboundRtps, _mediaSource) {
+    this.timestamp = timestamp;
+    this.id = id;
+    this.kind = kind;
+    this._peerConnection = _peerConnection;
+    this._outboundRtps = _outboundRtps;
+    this._mediaSource = _mediaSource;
+  }
+  timestamp;
+  id;
+  kind;
+  _peerConnection;
+  _outboundRtps;
+  _mediaSource;
+  _visited = false;
+  appData;
+  remoteInboundTracks = /* @__PURE__ */ new Set();
+  calculatedScore = {
+    weight: 1,
+    value: void 0
+  };
+  addedAt;
+  removedAt;
+  muted;
+  attachments;
+  get score() {
+    return this.calculatedScore.value;
+  }
+  get visited() {
+    const visited = this._visited;
+    this._visited = false;
+    return visited;
+  }
+  getPeerConnection() {
+    return this._peerConnection;
+  }
+  getOutboundRtps() {
+    return this._outboundRtps;
+  }
+  getMediaSource() {
+    return this._mediaSource;
+  }
+  update(stats) {
+    this._visited = true;
+    this.timestamp = stats.timestamp;
+    this.calculatedScore.value = stats.score;
+    this.attachments = stats.attachments;
+  }
+};
+
+// src/common/utils.ts
+function getMedian(arr, copyArrayForSorting = true) {
+  const sortedArr = copyArrayForSorting ? arr.slice().sort((a, b) => a - b) : arr.sort((a, b) => a - b);
+  const mid = Math.floor(sortedArr.length / 2);
+  if (sortedArr.length % 2 !== 0) {
+    return sortedArr[mid];
+  }
+  return (sortedArr[mid - 1] + sortedArr[mid]) / 2;
+}
+function parseJsonAs(json) {
+  if (!json) {
+    return void 0;
+  }
+  try {
+    return JSON.parse(json);
+  } catch (error) {
+    return void 0;
+  }
+}
+
+// src/ObservedPeerConnection.ts
+var logger = createLogger("ObservedPeerConnection");
+var ObservedPeerConnection = class extends EventEmitter {
+  constructor(peerConnectionId, client) {
+    super();
+    this.peerConnectionId = peerConnectionId;
+    this.client = client;
+    this.setMaxListeners(Infinity);
+    this.eventScope = {
+      observer: client.call.observer,
+      observedCall: client.call,
+      observedClient: client,
+      observedPeerConnection: this
+    };
+  }
+  peerConnectionId;
+  client;
+  _visited = true;
+  appData;
+  calculatedScore = {
+    weight: 1,
+    value: void 0
+  };
+  closed = false;
+  // timestamp of the PEER_CONNECTION_OPENED event
+  openedAt;
+  // timestamp of the PEER_CONNECTION_CLOSED event
+  closedAt;
+  updated = Date.now();
+  connectionState;
+  iceConnectionState;
+  iceGatheringState;
+  availableIncomingBitrate = 0;
+  availableOutgoingBitrate = 0;
+  totalInboundPacketsLost = 0;
+  totalInboundPacketsReceived = 0;
+  totalOutboundPacketsSent = 0;
+  totalDataChannelBytesSent = 0;
+  totalDataChannelBytesReceived = 0;
+  totalDataChannelMessagesSent = 0;
+  totalDataChannelMessagesReceived = 0;
+  totalSentAudioBytes = 0;
+  totalSentVideoBytes = 0;
+  totalSentAudioPackets = 0;
+  totalSentVideoPackets = 0;
+  totalReceivedAudioPacktes = 0;
+  totalReceivedVideoPackets = 0;
+  totalReceivedAudioBytes = 0;
+  totalReceivedVideoBytes = 0;
+  deltaInboundPacketsLost = 0;
+  deltaInboundPacketsReceived = 0;
+  deltaOutboundPacketsSent = 0;
+  deltaDataChannelBytesSent = 0;
+  deltaDataChannelBytesReceived = 0;
+  deltaDataChannelMessagesSent = 0;
+  deltaDataChannelMessagesReceived = 0;
+  deltaInboundReceivedBytes = 0;
+  deltaOutboundSentBytes = 0;
+  deltaReceivedAudioBytes = 0;
+  deltaReceivedVideoBytes = 0;
+  deltaReceivedAudioPackets = 0;
+  deltaReceivedVideoPackets = 0;
+  deltaSentAudioBytes = 0;
+  deltaSentVideoBytes = 0;
+  deltaSentAudioPackets = 0;
+  deltaSentVideoPackets = 0;
+  deltaTransportSentBytes = 0;
+  deltaTransportReceivedBytes = 0;
+  receivingPacketsPerSecond = 0;
+  sendingPacketsPerSecond = 0;
+  sendingAudioBitrate = 0;
+  sendingVideoBitrate = 0;
+  receivingAudioBitrate = 0;
+  receivingVideoBitrate = 0;
+  currentRttInMs;
+  currentJitter;
+  usingTCP = false;
+  usingTURN = false;
+  observedTurnServer;
+  observedCertificates = /* @__PURE__ */ new Map();
+  observedCodecs = /* @__PURE__ */ new Map();
+  observedDataChannels = /* @__PURE__ */ new Map();
+  observedIceCandidates = /* @__PURE__ */ new Map();
+  observedIceCandidatesPair = /* @__PURE__ */ new Map();
+  observedIceTransports = /* @__PURE__ */ new Map();
+  observedInboundRtps = /* @__PURE__ */ new Map();
+  observedInboundTracks = /* @__PURE__ */ new Map();
+  observedMediaPlayouts = /* @__PURE__ */ new Map();
+  observedMediaSources = /* @__PURE__ */ new Map();
+  observedOutboundRtps = /* @__PURE__ */ new Map();
+  observedOutboundTracks = /* @__PURE__ */ new Map();
+  observedPeerConnectionTransports = /* @__PURE__ */ new Map();
+  observedRemoteInboundRtps = /* @__PURE__ */ new Map();
+  observedRemoteOutboundRtps = /* @__PURE__ */ new Map();
+  eventScope;
+  get score() {
+    return this.calculatedScore.value;
+  }
+  get visited() {
+    const visited = this._visited;
+    this._visited = false;
+    return visited;
+  }
+  get codecs() {
+    return [...this.observedCodecs.values()];
+  }
+  get inboundRtps() {
+    return [...this.observedInboundRtps.values()];
+  }
+  get remoteOutboundRtps() {
+    return [...this.observedRemoteOutboundRtps.values()];
+  }
+  get outboundRtps() {
+    return [...this.observedOutboundRtps.values()];
+  }
+  get remoteInboundRtps() {
+    return [...this.observedRemoteInboundRtps.values()];
+  }
+  get mediaSources() {
+    return [...this.observedMediaSources.values()];
+  }
+  get mediaPlayouts() {
+    return [...this.observedMediaPlayouts.values()];
+  }
+  get dataChannels() {
+    return [...this.observedDataChannels.values()];
+  }
+  get peerConnectionTransports() {
+    return [...this.observedPeerConnectionTransports.values()];
+  }
+  get iceTransports() {
+    return [...this.observedIceTransports.values()];
+  }
+  get iceCandidates() {
+    return [...this.observedIceCandidates.values()];
+  }
+  get iceCandidatePairs() {
+    return [...this.observedIceCandidatesPair.values()];
+  }
+  get certificates() {
+    return [...this.observedCertificates.values()];
+  }
+  get selectedIceCandidatePairs() {
+    return this.iceTransports.map((iceTransport) => iceTransport.getSelectedCandidatePair()).filter((pair) => pair !== void 0);
+  }
+  get selectedIceCandiadtePairForTurn() {
+    return this.selectedIceCandidatePairs.filter(
+      (pair) => pair.getLocalCandidate()?.candidateType === "relay" && pair.getRemoteCandidate()?.url?.startsWith("turn:")
+    );
+  }
+  close() {
+    if (this.closed) return;
+    this.closed = true;
+    this.observedCertificates.forEach((observedCertificate) => this._notify("certificate-removed", { ...this.eventScope, observedCertificate }));
+    this.observedCodecs.forEach((observedCodec) => this._notify("codec-removed", { ...this.eventScope, observedCodec }));
+    this.observedDataChannels.forEach((observedDataChannel) => this._notify("data-channel-removed", { ...this.eventScope, observedDataChannel }));
+    this.observedIceCandidates.forEach((observedIceCandidate) => this._notify("ice-candidate-removed", { ...this.eventScope, observedIceCandidate }));
+    this.observedIceCandidatesPair.forEach((pair) => this._notify("ice-candidate-pair-removed", { ...this.eventScope, observedIceCandidatePair: pair }));
+    this.observedIceTransports.forEach((transport) => this._notify("ice-transport-removed", { ...this.eventScope, observedIceTransport: transport }));
+    this.observedInboundRtps.forEach((rtp) => this._notify("inbound-rtp-removed", { ...this.eventScope, observedInboundRtp: rtp }));
+    this.observedInboundTracks.forEach((track) => {
+      this.emit("removed-inbound-track", track);
+      this._notify("inbound-track-removed", { ...this.eventScope, observedInboundTrack: track });
+    });
+    this.observedMediaPlayouts.forEach((playout) => this._notify("media-playout-removed", { ...this.eventScope, observedMediaPlayout: playout }));
+    this.observedMediaSources.forEach((source) => this._notify("media-source-removed", { ...this.eventScope, observedMediaSource: source }));
+    this.observedOutboundRtps.forEach((rtp) => this._notify("outbound-rtp-removed", { ...this.eventScope, observedOutboundRtp: rtp }));
+    this.observedOutboundTracks.forEach((track) => {
+      this.emit("removed-outbound-track", track);
+      this._notify("outbound-track-removed", { ...this.eventScope, observedOutboundTrack: track });
+    });
+    this.observedPeerConnectionTransports.forEach((transport) => this._notify("peer-connection-transport-removed", { ...this.eventScope, observedPeerConnectionTransport: transport }));
+    this.observedRemoteInboundRtps.forEach((rtp) => this._notify("remote-inbound-rtp-removed", { ...this.eventScope, observedRemoteInboundRtp: rtp }));
+    this.observedRemoteOutboundRtps.forEach((rtp) => this._notify("remote-outbound-rtp-removed", { ...this.eventScope, observedRemoteOutboundRtp: rtp }));
+    this.observedCertificates.clear();
+    this.observedCodecs.clear();
+    this.observedDataChannels.clear();
+    this.observedIceCandidates.clear();
+    this.observedIceCandidatesPair.clear();
+    this.observedIceTransports.clear();
+    this.observedInboundRtps.clear();
+    this.observedInboundTracks.clear();
+    this.observedMediaPlayouts.clear();
+    this.observedMediaSources.clear();
+    this.observedOutboundRtps.clear();
+    this.observedOutboundTracks.clear();
+    this.observedPeerConnectionTransports.clear();
+    this.observedRemoteInboundRtps.clear();
+    this.observedRemoteOutboundRtps.clear();
+    this.client.call.observer.observedTURN.removePeerConnection(this);
+    if (!this.closedAt) this.closedAt = Date.now();
+    this.emit("close");
+    this._notify("peer-connection-closed", { ...this.eventScope });
+  }
+  accept(sample, context) {
+    if (this.closed) return;
+    this._visited = true;
+    if (context) this.appData = { ...this.appData, ...context };
+    this.availableIncomingBitrate = 0;
+    this.availableOutgoingBitrate = 0;
+    this.deltaInboundPacketsLost = 0;
+    this.deltaInboundPacketsReceived = 0;
+    this.deltaOutboundPacketsSent = 0;
+    this.deltaDataChannelBytesSent = 0;
+    this.deltaDataChannelBytesReceived = 0;
+    this.deltaInboundReceivedBytes = 0;
+    this.deltaOutboundSentBytes = 0;
+    this.deltaReceivedAudioBytes = 0;
+    this.deltaReceivedVideoBytes = 0;
+    this.deltaReceivedAudioPackets = 0;
+    this.deltaReceivedVideoPackets = 0;
+    this.deltaSentAudioBytes = 0;
+    this.deltaSentVideoBytes = 0;
+    this.deltaSentAudioPackets = 0;
+    this.deltaSentVideoPackets = 0;
+    this.deltaTransportReceivedBytes = 0;
+    this.deltaTransportSentBytes = 0;
+    this.sendingAudioBitrate = 0;
+    this.sendingVideoBitrate = 0;
+    this.receivingAudioBitrate = 0;
+    this.receivingVideoBitrate = 0;
+    const now = Date.now();
+    const elapsedTimeInMs = now - this.updated;
+    const elapsedTimeInSec = elapsedTimeInMs / 1e3;
+    const rttMeasurementsInSec = [];
+    const jitterMeasurements = [];
+    if (sample.certificates) {
+      for (const certificate of sample.certificates) {
+        this._updateCertificateStats(certificate);
+      }
+    }
+    if (sample.codecs) {
+      for (const codec of sample.codecs) {
+        this._updateCodecStats(codec);
+      }
+    }
+    if (sample.dataChannels) {
+      for (const dataChannel of sample.dataChannels) {
+        const observedDataChannel = this._updateDataChannelStats(dataChannel);
+        if (!observedDataChannel) continue;
+        this.deltaDataChannelBytesSent += observedDataChannel.deltaBytesSent;
+        this.deltaDataChannelBytesReceived += observedDataChannel.deltaBytesReceived;
+        this.deltaDataChannelMessagesSent += observedDataChannel.deltaMessagesSent;
+        this.deltaDataChannelMessagesReceived += observedDataChannel.deltaMessagesReceived;
+      }
+    }
+    if (sample.iceCandidates) {
+      for (const iceCandidate of sample.iceCandidates) {
+        this._updateIceCandidateStats(iceCandidate);
+      }
+    }
+    if (sample.iceCandidatePairs) {
+      for (const iceCandidatePair of sample.iceCandidatePairs) {
+        const observedCandidatePair = this._updateIceCandidatePairStats(iceCandidatePair);
+        if (!observedCandidatePair) continue;
+        if (observedCandidatePair.currentRoundTripTime) {
+          rttMeasurementsInSec.push(observedCandidatePair.currentRoundTripTime);
+        }
+        if (observedCandidatePair.availableIncomingBitrate) {
+          this.availableIncomingBitrate += observedCandidatePair.availableIncomingBitrate;
+        }
+        if (observedCandidatePair.availableOutgoingBitrate) {
+          this.availableOutgoingBitrate += observedCandidatePair.availableOutgoingBitrate;
+        }
+      }
+    }
+    if (sample.iceTransports) {
+      for (const iceTransport of sample.iceTransports) {
+        const observedIceTransport = this._updateIceTransportStats(iceTransport);
+        if (!observedIceTransport) continue;
+      }
+    }
+    if (sample.inboundRtps) {
+      for (const inboundRtp of sample.inboundRtps) {
+        const observedInboundRtp = this._updateInboundRtpStats(inboundRtp);
+        if (!observedInboundRtp) continue;
+        this.deltaInboundPacketsLost += observedInboundRtp.deltaLostPackets;
+        this.deltaInboundPacketsReceived += observedInboundRtp.deltaReceivedPackets;
+        this.deltaInboundReceivedBytes += observedInboundRtp.deltaBytesReceived;
+        switch (inboundRtp.kind) {
+          case "audio":
+            this.deltaReceivedAudioBytes += observedInboundRtp.deltaBytesReceived;
+            this.deltaReceivedAudioPackets += observedInboundRtp.deltaReceivedPackets;
+            break;
+          case "video":
+            this.deltaReceivedVideoBytes += observedInboundRtp.deltaBytesReceived;
+            this.deltaReceivedVideoPackets += observedInboundRtp.deltaReceivedPackets;
+            break;
+        }
+        if (observedInboundRtp.jitter) {
+          jitterMeasurements.push(observedInboundRtp.jitter);
+        }
+      }
+    }
+    if (sample.mediaPlayouts) {
+      for (const mediaPlayout of sample.mediaPlayouts) {
+        this._updateMediaPlayoutStats(mediaPlayout);
+      }
+    }
+    if (sample.mediaSources) {
+      for (const mediaSource of sample.mediaSources) {
+        this._updateMediaSourceStats(mediaSource);
+      }
+    }
+    if (sample.outboundRtps) {
+      for (const outboundRtp of sample.outboundRtps) {
+        const observedOutboundRtp = this._updateOutboundRtpStats(outboundRtp);
+        if (!observedOutboundRtp) continue;
+        this.deltaOutboundPacketsSent += observedOutboundRtp.deltaPacketsSent ?? 0;
+        this.deltaOutboundSentBytes += observedOutboundRtp.deltaBytesSent ?? 0;
+        switch (outboundRtp.kind) {
+          case "audio":
+            this.deltaSentAudioBytes += observedOutboundRtp.deltaBytesSent;
+            this.deltaSentAudioPackets += observedOutboundRtp.deltaPacketsSent;
+            break;
+          case "video":
+            this.deltaSentVideoBytes += observedOutboundRtp.deltaBytesSent;
+            this.deltaSentVideoPackets += observedOutboundRtp.deltaPacketsSent;
+            break;
+        }
+      }
+    }
+    if (sample.peerConnectionTransports) {
+      for (const peerConnectionTransport of sample.peerConnectionTransports) {
+        const observedTransport = this._updatePeerConnectionTransportStats(peerConnectionTransport);
+        if (!observedTransport) continue;
+      }
+    }
+    if (sample.remoteInboundRtps) {
+      for (const remoteInboundRtp of sample.remoteInboundRtps) {
+        const observedRemoteInboundRtp = this._updateRemoteInboundRtpStats(remoteInboundRtp);
+        if (!observedRemoteInboundRtp) continue;
+        if (observedRemoteInboundRtp.roundTripTime) {
+          rttMeasurementsInSec.push(observedRemoteInboundRtp.roundTripTime);
+        }
+        const observedOutboundRtp = observedRemoteInboundRtp.getOutboundRtp();
+        if (observedOutboundRtp) {
+          if (observedRemoteInboundRtp.roundTripTime !== void 0) {
+            observedOutboundRtp.remoteRttInMs = observedRemoteInboundRtp.roundTripTime * 1e3;
+          }
+          if (observedRemoteInboundRtp.fractionLost !== void 0) {
+            observedOutboundRtp.remoteFractionLost = observedRemoteInboundRtp.fractionLost;
+          }
+          if (observedRemoteInboundRtp.jitter !== void 0) {
+            observedOutboundRtp.remoteJitter = observedRemoteInboundRtp.jitter;
+          }
+          if (observedRemoteInboundRtp.packetsLost !== void 0) {
+            observedOutboundRtp.remotePacketsLost = observedRemoteInboundRtp.packetsLost;
+          }
+        }
+      }
+    }
+    if (sample.remoteOutboundRtps) {
+      for (const remoteOutboundRtp of sample.remoteOutboundRtps) {
+        const observedRemoteOutboundRtp = this._updateRemoteOutboundRtpStats(remoteOutboundRtp);
+        if (!observedRemoteOutboundRtp) continue;
+        const observedInboundRtp = observedRemoteOutboundRtp.getInboundRtp();
+        if (observedInboundRtp) {
+          if (observedRemoteOutboundRtp.roundTripTime !== void 0) {
+            observedInboundRtp.remoteRttInMs = observedRemoteOutboundRtp.roundTripTime * 1e3;
+          }
+          if (observedRemoteOutboundRtp.bytesSent !== void 0) {
+            observedInboundRtp.remoteBytesSent = observedRemoteOutboundRtp.bytesSent;
+          }
+          if (observedRemoteOutboundRtp.packetsSent !== void 0) {
+            observedInboundRtp.remotePacketsSent = observedRemoteOutboundRtp.packetsSent;
+          }
+          if (observedRemoteOutboundRtp.remoteTimestamp !== void 0) {
+            observedInboundRtp.remoteTimestamp = observedRemoteOutboundRtp.remoteTimestamp;
+          }
+        }
+      }
+    }
+    if (sample.inboundTracks) {
+      for (const inboundTrack of sample.inboundTracks) {
+        this._updateInboundTrackSample(inboundTrack);
+      }
+    }
+    if (sample.outboundTracks) {
+      for (const outboundTrack of sample.outboundTracks) {
+        this._updateOutboundTrackSample(outboundTrack);
+      }
+    }
+    this.totalInboundPacketsLost += this.deltaInboundPacketsLost;
+    this.totalInboundPacketsReceived += this.deltaInboundPacketsReceived;
+    this.totalOutboundPacketsSent += this.deltaOutboundPacketsSent;
+    this.totalDataChannelBytesSent += this.deltaDataChannelBytesSent;
+    this.totalDataChannelBytesReceived += this.deltaDataChannelBytesReceived;
+    this.totalDataChannelMessagesSent += this.deltaDataChannelMessagesSent;
+    this.totalDataChannelMessagesReceived += this.deltaDataChannelMessagesReceived;
+    this.totalReceivedAudioBytes += this.deltaReceivedAudioBytes;
+    this.totalReceivedVideoBytes += this.deltaReceivedVideoBytes;
+    this.totalSentAudioBytes += this.deltaSentAudioBytes;
+    this.totalSentVideoBytes += this.deltaSentVideoBytes;
+    this.totalReceivedAudioPacktes += this.deltaReceivedAudioPackets;
+    this.totalReceivedVideoPackets += this.deltaReceivedVideoPackets;
+    this.totalSentAudioPackets += this.deltaSentAudioPackets;
+    this.totalSentVideoPackets += this.deltaSentVideoPackets;
+    this.receivingPacketsPerSecond = this.deltaInboundPacketsReceived / elapsedTimeInSec;
+    this.sendingPacketsPerSecond = this.deltaOutboundPacketsSent / elapsedTimeInSec;
+    this.sendingAudioBitrate = this.deltaSentAudioBytes * 8 / elapsedTimeInSec;
+    this.sendingVideoBitrate = this.deltaSentVideoBytes * 8 / elapsedTimeInSec;
+    this.receivingAudioBitrate = this.deltaReceivedAudioBytes * 8 / elapsedTimeInSec;
+    this.receivingVideoBitrate = this.deltaReceivedVideoBytes * 8 / elapsedTimeInSec;
+    if (rttMeasurementsInSec.length > 0) {
+      this.currentRttInMs = getMedian(rttMeasurementsInSec, false) * 1e3;
+    } else {
+      this.currentRttInMs = void 0;
+    }
+    if (jitterMeasurements.length > 0) {
+      this.currentJitter = getMedian(jitterMeasurements, false);
+    } else {
+      this.currentJitter = void 0;
+    }
+    const wasUsingTURN = this.usingTURN;
+    const selectedIceCandidatePairs = this.selectedIceCandidatePairs;
+    const selectedCandidatePairForTurn = [];
+    this.usingTCP = false;
+    this.usingTURN = false;
+    for (const selectedCandidatePair of selectedIceCandidatePairs) {
+      if (selectedCandidatePair.getLocalCandidate()?.protocol === "tcp") {
+        this.usingTCP = true;
+      }
+      if (selectedCandidatePair.getLocalCandidate()?.candidateType === "relay" && selectedCandidatePair.getRemoteCandidate()?.url?.startsWith("turn:")) {
+        selectedCandidatePairForTurn.push(selectedCandidatePair);
+        this.usingTURN = true;
+      }
+      this.deltaTransportReceivedBytes += selectedCandidatePair.deltaBytesReceived;
+      this.deltaTransportSentBytes += selectedCandidatePair.deltaBytesSent;
+    }
+    if (this.usingTURN) {
+      if (!this.observedTurnServer) {
+        this.observedTurnServer = this.client.call.observer.observedTURN.addPeerConnection(this);
+      }
+      this.observedTurnServer?.updateTurnUsage(...selectedCandidatePairForTurn);
+    } else if (wasUsingTURN) {
+      if (!this.usingTURN) {
+        this.client.call.observer.observedTURN.removePeerConnection(this);
+      }
+    }
+    this.calculatedScore.value = sample.score;
+    this.updated = now;
+    this._checkVisited();
+    this._notify("peer-connection-updated", { ...this.eventScope, context });
+  }
+  _checkVisited() {
+    for (const certificate of [...this.observedCertificates.values()]) {
+      if (certificate.visited) continue;
+      this.observedCertificates.delete(certificate.id);
+    }
+    for (const observedCodec of [...this.observedCodecs.values()]) {
+      if (observedCodec.visited) continue;
+      this.observedCodecs.delete(observedCodec.id);
+      this._notify("codec-removed", { ...this.eventScope, observedCodec });
+    }
+    for (const observedDataChannel of [...this.observedDataChannels.values()]) {
+      if (observedDataChannel.visited) continue;
+      this.observedDataChannels.delete(observedDataChannel.id);
+      this._notify("data-channel-removed", { ...this.eventScope, observedDataChannel });
+    }
+    for (const observedIceCandidate of [...this.observedIceCandidates.values()]) {
+      if (observedIceCandidate.visited) continue;
+      this.observedIceCandidates.delete(observedIceCandidate.id);
+      this._notify("ice-candidate-removed", { ...this.eventScope, observedIceCandidate });
+    }
+    for (const observedIceCandidatePair of [...this.observedIceCandidatesPair.values()]) {
+      if (observedIceCandidatePair.visited) continue;
+      this.observedIceCandidatesPair.delete(observedIceCandidatePair.id);
+      this._notify("ice-candidate-pair-removed", { ...this.eventScope, observedIceCandidatePair });
+    }
+    for (const observedIceTransport of [...this.observedIceTransports.values()]) {
+      if (observedIceTransport.visited) continue;
+      this.observedIceTransports.delete(observedIceTransport.id);
+      this._notify("ice-transport-removed", { ...this.eventScope, observedIceTransport });
+    }
+    for (const observedInboundRtp of [...this.observedInboundRtps.values()]) {
+      if (observedInboundRtp.visited) continue;
+      this.observedInboundRtps.delete(observedInboundRtp.ssrc);
+      this._notify("inbound-rtp-removed", { ...this.eventScope, observedInboundRtp });
+    }
+    for (const observedInboundTrack of [...this.observedInboundTracks.values()]) {
+      if (observedInboundTrack.visited) continue;
+      this.observedInboundTracks.delete(observedInboundTrack.id);
+      this.emit("removed-inbound-track", observedInboundTrack);
+      this._notify("inbound-track-removed", { ...this.eventScope, observedInboundTrack });
+    }
+    for (const observedMediaPlayout of [...this.observedMediaPlayouts.values()]) {
+      if (observedMediaPlayout.visited) continue;
+      this.observedMediaPlayouts.delete(observedMediaPlayout.id);
+      this._notify("media-playout-removed", { ...this.eventScope, observedMediaPlayout });
+    }
+    for (const observedMediaSource of [...this.observedMediaSources.values()]) {
+      if (observedMediaSource.visited) continue;
+      this.observedMediaSources.delete(observedMediaSource.id);
+      this._notify("media-source-removed", { ...this.eventScope, observedMediaSource });
+    }
+    for (const observedOutboundRtp of [...this.observedOutboundRtps.values()]) {
+      if (observedOutboundRtp.visited) continue;
+      this.observedOutboundRtps.delete(observedOutboundRtp.ssrc);
+      this._notify("outbound-rtp-removed", { ...this.eventScope, observedOutboundRtp });
+    }
+    for (const observedOutboundTrack of [...this.observedOutboundTracks.values()]) {
+      if (observedOutboundTrack.visited) continue;
+      this.observedOutboundTracks.delete(observedOutboundTrack.id);
+      this.emit("removed-outbound-track", observedOutboundTrack);
+      this._notify("outbound-track-removed", { ...this.eventScope, observedOutboundTrack });
+    }
+    for (const observedPeerConnectionTransport of [...this.observedPeerConnectionTransports.values()]) {
+      if (observedPeerConnectionTransport.visited) continue;
+      this.observedPeerConnectionTransports.delete(observedPeerConnectionTransport.id);
+      this._notify("peer-connection-transport-removed", { ...this.eventScope, observedPeerConnectionTransport });
+    }
+    for (const observedRemoteInboundRtp of [...this.observedRemoteInboundRtps.values()]) {
+      if (observedRemoteInboundRtp.visited) continue;
+      this.observedRemoteInboundRtps.delete(observedRemoteInboundRtp.ssrc);
+      this._notify("remote-inbound-rtp-removed", { ...this.eventScope, observedRemoteInboundRtp });
+    }
+    for (const observedRemoteOutboundRtp of [...this.observedRemoteOutboundRtps.values()]) {
+      if (observedRemoteOutboundRtp.visited) continue;
+      this.observedRemoteOutboundRtps.delete(observedRemoteOutboundRtp.ssrc);
+      this._notify("remote-outbound-rtp-removed", { ...this.eventScope, observedRemoteOutboundRtp });
+    }
+  }
+  _updateCertificateStats(stats) {
+    let observedCertificate = this.observedCertificates.get(stats.id);
+    if (!observedCertificate) {
+      if (!stats.timestamp || !stats.id || !stats.fingerprint) {
+        return logger.warn(
+          `ObservedPeerConnection received an invalid CertificateStats (missing timestamp OR id OR fingerprint field). PeerConnectionId: ${this.peerConnectionId} ClientId: ${this.client.clientId}, CallId: ${this.client.call.callId}`,
+          stats
+        );
+      }
+      observedCertificate = new ObservedCertificate(stats.timestamp, stats.id, this);
+      observedCertificate.update(stats);
+      this.observedCertificates.set(stats.id, observedCertificate);
+      this._notify("certificate-added", { ...this.eventScope, observedCertificate });
+    } else {
+      observedCertificate.update(stats);
+      this._notify("certificate-updated", { ...this.eventScope, observedCertificate });
+    }
+    return observedCertificate;
+  }
+  _updateCodecStats(stats) {
+    let observedCodec = this.observedCodecs.get(stats.id);
+    if (!observedCodec) {
+      if (!stats.timestamp || !stats.id || !stats.mimeType) {
+        return logger.warn(
+          `ObservedPeerConnection received an invalid CodecStats (missing timestamp OR id OR mimeType field). PeerConnectionId: ${this.peerConnectionId} ClientId: ${this.client.clientId}, CallId: ${this.client.call.callId}`,
+          stats
+        );
+      }
+      observedCodec = new ObservedCodec(stats.timestamp, stats.id, stats.mimeType, this);
+      observedCodec.update(stats);
+      this.observedCodecs.set(stats.id, observedCodec);
+      this._notify("codec-added", { ...this.eventScope, observedCodec });
+    } else {
+      observedCodec.update(stats);
+    }
+    this._notify("codec-updated", { ...this.eventScope, observedCodec });
+    return observedCodec;
+  }
+  _updateDataChannelStats(stats) {
+    let observedDataChannel = this.observedDataChannels.get(stats.id);
+    if (!observedDataChannel) {
+      if (!stats.timestamp || !stats.id) {
+        return logger.warn(
+          `ObservedPeerConnection received an invalid DataChannelStats (missing timestamp OR id field). PeerConnectionId: ${this.peerConnectionId} ClientId: ${this.client.clientId}, CallId: ${this.client.call.callId}`,
+          stats
+        );
+      }
+      observedDataChannel = new ObservedDataChannel(stats.timestamp, stats.id, this);
+      observedDataChannel.update(stats);
+      this.observedDataChannels.set(stats.id, observedDataChannel);
+      this._notify("data-channel-added", { ...this.eventScope, observedDataChannel });
+    } else {
+      observedDataChannel.update(stats);
+    }
+    this._notify("data-channel-updated", { ...this.eventScope, observedDataChannel });
+    return observedDataChannel;
+  }
+  _updateIceCandidateStats(stats) {
+    let observedIceCandidate = this.observedIceCandidates.get(stats.id);
+    if (!observedIceCandidate) {
+      if (!stats.timestamp || !stats.id) {
+        return logger.warn(
+          `ObservedPeerConnection received an invalid IceCandidateStats (missing timestamp OR id field). PeerConnectionId: ${this.peerConnectionId} ClientId: ${this.client.clientId}, CallId: ${this.client.call.callId}`,
+          stats
+        );
+      }
+      observedIceCandidate = new ObservedIceCandidate(stats.timestamp, stats.id, this);
+      observedIceCandidate.update(stats);
+      this.observedIceCandidates.set(stats.id, observedIceCandidate);
+      this._notify("ice-candidate-added", { ...this.eventScope, observedIceCandidate });
+    } else {
+      observedIceCandidate.update(stats);
+    }
+    this._notify("ice-candidate-updated", { ...this.eventScope, observedIceCandidate });
+    return observedIceCandidate;
+  }
+  _updateIceCandidatePairStats(stats) {
+    let observedIceCandidatePair = this.observedIceCandidatesPair.get(stats.id);
+    if (!observedIceCandidatePair) {
+      if (!stats.timestamp || !stats.id) {
+        return logger.warn(
+          `ObservedPeerConnection received an invalid IceCandidateStats (missing timestamp OR id field). PeerConnectionId: ${this.peerConnectionId} ClientId: ${this.client.clientId}, CallId: ${this.client.call.callId}`,
+          stats
+        );
+      }
+      observedIceCandidatePair = new ObservedIceCandidatePair(stats.timestamp, stats.id, this);
+      observedIceCandidatePair.update(stats);
+      this.observedIceCandidatesPair.set(stats.id, observedIceCandidatePair);
+      this._notify("ice-candidate-pair-added", { ...this.eventScope, observedIceCandidatePair });
+    } else {
+      observedIceCandidatePair.update(stats);
+    }
+    this._notify("ice-candidate-pair-updated", { ...this.eventScope, observedIceCandidatePair });
+    return observedIceCandidatePair;
+  }
+  _updateIceTransportStats(stats) {
+    let observedIceTransport = this.observedIceTransports.get(stats.id);
+    if (!observedIceTransport) {
+      if (!stats.timestamp || !stats.id) {
+        return logger.warn(
+          `ObservedPeerConnection received an invalid IceCandidateStats (missing timestamp OR id field). PeerConnectionId: ${this.peerConnectionId} ClientId: ${this.client.clientId}, CallId: ${this.client.call.callId}`,
+          stats
+        );
+      }
+      observedIceTransport = new ObservedIceTransport(stats.timestamp, stats.id, this);
+      observedIceTransport.update(stats);
+      this.observedIceTransports.set(stats.id, observedIceTransport);
+      this._notify("ice-transport-added", { ...this.eventScope, observedIceTransport });
+    } else {
+      observedIceTransport.update(stats);
+    }
+    this._notify("ice-transport-updated", { ...this.eventScope, observedIceTransport });
+    return observedIceTransport;
+  }
+  _updateInboundRtpStats(stats) {
+    let observedInboundRtp = this.observedInboundRtps.get(stats.ssrc);
+    if (!observedInboundRtp) {
+      if (!stats.timestamp || !stats.id || !stats.ssrc || !stats.kind || !stats.trackIdentifier) {
+        return logger.warn(
+          `ObservedPeerConnection received an invalid InboundRtpStats (missing timestamp OR id OR ssrc OR kind OR trackIdentifier field). PeerConnectionId: ${this.peerConnectionId} ClientId: ${this.client.clientId}, CallId: ${this.client.call.callId}`,
+          stats
+        );
+      }
+      observedInboundRtp = new ObservedInboundRtp(
+        stats.timestamp,
+        stats.id,
+        stats.ssrc,
+        stats.kind,
+        stats.trackIdentifier,
+        this
+      );
+      observedInboundRtp.update(stats);
+      this.observedInboundRtps.set(stats.ssrc, observedInboundRtp);
+      this._notify("inbound-rtp-added", { ...this.eventScope, observedInboundRtp });
+    } else {
+      observedInboundRtp.update(stats);
+    }
+    this._notify("inbound-rtp-updated", { ...this.eventScope, observedInboundRtp });
+    return observedInboundRtp;
+  }
+  _updateInboundTrackSample(stats) {
+    let observedInboundTrack = this.observedInboundTracks.get(stats.id);
+    if (!observedInboundTrack) {
+      if (!stats.timestamp || !stats.id || !stats.kind) {
+        return logger.warn(
+          `ObservedPeerConnection received an invalid InboundTrackSample (missing timestamp OR id OR kind field). PeerConnectionId: ${this.peerConnectionId} ClientId: ${this.client.clientId}, CallId: ${this.client.call.callId}`,
+          stats
+        );
+      }
+      const inboundRtp = [...this.observedInboundRtps.values()].find((inbRtp) => inbRtp.trackIdentifier === stats.id);
+      const mediaPlayout = inboundRtp ? [...this.observedMediaPlayouts.values()].find((mp) => mp.id === inboundRtp.playoutId) : void 0;
+      observedInboundTrack = new ObservedInboundTrack(
+        stats.timestamp,
+        stats.id,
+        stats.kind,
+        this,
+        inboundRtp,
+        mediaPlayout
+      );
+      observedInboundTrack.update(stats);
+      this.observedInboundTracks.set(stats.id, observedInboundTrack);
+      this._notify("inbound-track-added", { ...this.eventScope, observedInboundTrack });
+    } else {
+      observedInboundTrack.update(stats);
+    }
+    this._notify("inbound-track-updated", { ...this.eventScope, observedInboundTrack });
+    return observedInboundTrack;
+  }
+  _updateMediaPlayoutStats(stats) {
+    let observedMediaPlayout = this.observedMediaPlayouts.get(stats.id);
+    if (!observedMediaPlayout) {
+      if (!stats.timestamp || !stats.id || !stats.kind) {
+        return logger.warn(
+          `ObservedPeerConnection received an invalid InboundRtpStats (missing timestamp OR id OR kind OR trackIdentifier field). PeerConnectionId: ${this.peerConnectionId} ClientId: ${this.client.clientId}, CallId: ${this.client.call.callId}`,
+          stats
+        );
+      }
+      observedMediaPlayout = new ObservedMediaPlayout(
+        stats.timestamp,
+        stats.id,
+        stats.kind,
+        this
+      );
+      observedMediaPlayout.update(stats);
+      this.observedMediaPlayouts.set(stats.id, observedMediaPlayout);
+      this._notify("media-playout-added", { ...this.eventScope, observedMediaPlayout });
+    } else {
+      observedMediaPlayout.update(stats);
+    }
+    this._notify("media-playout-updated", { ...this.eventScope, observedMediaPlayout });
+    return observedMediaPlayout;
+  }
+  _updateMediaSourceStats(stats) {
+    let observedMediaSource = this.observedMediaSources.get(stats.id);
+    if (!observedMediaSource) {
+      if (!stats.timestamp || !stats.id || !stats.kind) {
+        return logger.warn(
+          `ObservedPeerConnection received an invalid InboundRtpStats (missing timestamp OR id OR kind field). PeerConnectionId: ${this.peerConnectionId} ClientId: ${this.client.clientId}, CallId: ${this.client.call.callId}`,
+          stats
+        );
+      }
+      observedMediaSource = new ObservedMediaSource(
+        stats.timestamp,
+        stats.id,
+        stats.kind,
+        this
+      );
+      observedMediaSource.update(stats);
+      this.observedMediaSources.set(stats.id, observedMediaSource);
+      this._notify("media-source-added", { ...this.eventScope, observedMediaSource });
+    } else {
+      observedMediaSource.update(stats);
+    }
+    this._notify("media-source-updated", { ...this.eventScope, observedMediaSource });
+    return observedMediaSource;
+  }
+  _updateOutboundRtpStats(stats) {
+    let observedOutboundRtp = this.observedOutboundRtps.get(stats.ssrc);
+    if (!observedOutboundRtp) {
+      if (!stats.timestamp || !stats.id || !stats.ssrc || !stats.kind) {
+        return logger.warn(
+          `ObservedPeerConnection received an invalid OutboundRtpStats (missing timestamp OR id OR ssrc OR kind field). PeerConnectionId: ${this.peerConnectionId} ClientId: ${this.client.clientId}, CallId: ${this.client.call.callId}`,
+          stats
+        );
+      }
+      observedOutboundRtp = new ObservedOutboundRtp(
+        stats.timestamp,
+        stats.id,
+        stats.ssrc,
+        stats.kind,
+        this
+      );
+      observedOutboundRtp.update(stats);
+      this.observedOutboundRtps.set(stats.ssrc, observedOutboundRtp);
+      this._notify("outbound-rtp-added", { ...this.eventScope, observedOutboundRtp });
+    } else {
+      observedOutboundRtp.update(stats);
+    }
+    this._notify("outbound-rtp-updated", { ...this.eventScope, observedOutboundRtp });
+    return observedOutboundRtp;
+  }
+  _updateOutboundTrackSample(stats) {
+    let observedOutboundTrack = this.observedOutboundTracks.get(stats.id);
+    if (!observedOutboundTrack) {
+      if (!stats.timestamp || !stats.id || !stats.kind) {
+        return logger.warn(
+          `ObservedPeerConnection received an invalid OutboundTrackSample (missing timestamp OR id OR kind field). PeerConnectionId: ${this.peerConnectionId} ClientId: ${this.client.clientId}, CallId: ${this.client.call.callId}`,
+          stats
+        );
+      }
+      const observedMediaSource = [...this.observedMediaSources.values()].find((mediaSource) => mediaSource.trackIdentifier === stats.id);
+      const outboundRtps = observedMediaSource ? [...this.observedOutboundRtps.values()].filter((outboundRtp) => outboundRtp.mediaSourceId === observedMediaSource?.id) : void 0;
+      observedOutboundTrack = new ObservedOutboundTrack(
+        stats.timestamp,
+        stats.id,
+        stats.kind,
+        this,
+        outboundRtps,
+        observedMediaSource
+      );
+      observedOutboundTrack.update(stats);
+      this.observedOutboundTracks.set(stats.id, observedOutboundTrack);
+      this._notify("outbound-track-added", { ...this.eventScope, observedOutboundTrack });
+    } else {
+      observedOutboundTrack.update(stats);
+    }
+    this._notify("outbound-track-updated", { ...this.eventScope, observedOutboundTrack });
+    return observedOutboundTrack;
+  }
+  _updatePeerConnectionTransportStats(stats) {
+    let observedPeerConnectionTransport = this.observedPeerConnectionTransports.get(stats.id);
+    if (!observedPeerConnectionTransport) {
+      if (!stats.timestamp || !stats.id) {
+        return logger.warn(
+          `ObservedPeerConnection received an invalid PeerConnectionTransportStats (missing timestamp OR id field). PeerConnectionId: ${this.peerConnectionId} ClientId: ${this.client.clientId}, CallId: ${this.client.call.callId}`,
+          stats
+        );
+      }
+      observedPeerConnectionTransport = new ObservedPeerConnectionTransport(stats.timestamp, stats.id, this);
+      observedPeerConnectionTransport.update(stats);
+      this.observedPeerConnectionTransports.set(stats.id, observedPeerConnectionTransport);
+      this._notify("peer-connection-transport-added", { ...this.eventScope, observedPeerConnectionTransport });
+    } else {
+      observedPeerConnectionTransport.update(stats);
+    }
+    this._notify("peer-connection-transport-updated", { ...this.eventScope, observedPeerConnectionTransport });
+    return observedPeerConnectionTransport;
+  }
+  _updateRemoteInboundRtpStats(stats) {
+    let observedRemoteInboundRtp = this.observedRemoteInboundRtps.get(stats.ssrc);
+    if (!observedRemoteInboundRtp) {
+      if (!stats.timestamp || !stats.id || !stats.ssrc || !stats.kind) {
+        return logger.warn(
+          `ObservedPeerConnection received an invalid RemoteInboundRtpStats (missing timestamp OR id OR ssrc OR kind field). PeerConnectionId: ${this.peerConnectionId} ClientId: ${this.client.clientId}, CallId: ${this.client.call.callId}`,
+          stats
+        );
+      }
+      observedRemoteInboundRtp = new ObservedRemoteInboundRtp(
+        stats.timestamp,
+        stats.id,
+        stats.ssrc,
+        stats.kind,
+        this
+      );
+      observedRemoteInboundRtp.update(stats);
+      this.observedRemoteInboundRtps.set(stats.ssrc, observedRemoteInboundRtp);
+      this._notify("remote-inbound-rtp-added", { ...this.eventScope, observedRemoteInboundRtp });
+    } else {
+      observedRemoteInboundRtp.update(stats);
+    }
+    this._notify("remote-inbound-rtp-updated", { ...this.eventScope, observedRemoteInboundRtp });
+    return observedRemoteInboundRtp;
+  }
+  _updateRemoteOutboundRtpStats(stats) {
+    let observedRemoteOutboundRtp = this.observedRemoteOutboundRtps.get(stats.ssrc);
+    if (!observedRemoteOutboundRtp) {
+      if (!stats.timestamp || !stats.id || !stats.ssrc || !stats.kind) {
+        return logger.warn(
+          `ObservedPeerConnection received an invalid RemoteOutboundRtpStats (missing timestamp OR id OR ssrc OR kind field). PeerConnectionId: ${this.peerConnectionId} ClientId: ${this.client.clientId}, CallId: ${this.client.call.callId}`,
+          stats
+        );
+      }
+      observedRemoteOutboundRtp = new ObservedRemoteOutboundRtp(
+        stats.timestamp,
+        stats.id,
+        stats.ssrc,
+        stats.kind,
+        this
+      );
+      observedRemoteOutboundRtp.update(stats);
+      this.observedRemoteOutboundRtps.set(stats.ssrc, observedRemoteOutboundRtp);
+      this._notify("remote-outbound-rtp-added", { ...this.eventScope, observedRemoteOutboundRtp });
+    } else {
+      observedRemoteOutboundRtp.update(stats);
+    }
+    this._notify("remote-outbound-rtp-updated", { ...this.eventScope, observedRemoteOutboundRtp });
+    return observedRemoteOutboundRtp;
+  }
+  /** Emit an Observer-bus event scoped to this peer connection. */
+  _notify(type, ...args) {
+    this.client.call.observer.emit(type, ...args);
+  }
+};
+
+// src/schema/ClientEventTypes.ts
+var ClientEventTypes = /* @__PURE__ */ ((ClientEventTypes2) => {
+  ClientEventTypes2["CLIENT_JOINED"] = "CLIENT_JOINED";
+  ClientEventTypes2["CLIENT_LEFT"] = "CLIENT_LEFT";
+  ClientEventTypes2["PEER_CONNECTION_OPENED"] = "PEER_CONNECTION_OPENED";
+  ClientEventTypes2["PEER_CONNECTION_CLOSED"] = "PEER_CONNECTION_CLOSED";
+  ClientEventTypes2["MEDIA_TRACK_ADDED"] = "MEDIA_TRACK_ADDED";
+  ClientEventTypes2["MEDIA_TRACK_REMOVED"] = "MEDIA_TRACK_REMOVED";
+  ClientEventTypes2["MEDIA_TRACK_RESUMED"] = "MEDIA_TRACK_RESUMED";
+  ClientEventTypes2["MEDIA_TRACK_MUTED"] = "MEDIA_TRACK_MUTED";
+  ClientEventTypes2["MEDIA_TRACK_UNMUTED"] = "MEDIA_TRACK_UNMUTED";
+  ClientEventTypes2["ICE_GATHERING_STATE_CHANGED"] = "ICE_GATHERING_STATE_CHANGED";
+  ClientEventTypes2["PEER_CONNECTION_STATE_CHANGED"] = "PEER_CONNECTION_STATE_CHANGED";
+  ClientEventTypes2["ICE_CONNECTION_STATE_CHANGED"] = "ICE_CONNECTION_STATE_CHANGED";
+  ClientEventTypes2["DATA_CHANNEL_OPEN"] = "DATA_CHANNEL_OPEN";
+  ClientEventTypes2["DATA_CHANNEL_CLOSED"] = "DATA_CHANNEL_CLOSED";
+  ClientEventTypes2["DATA_CHANNEL_ERROR"] = "DATA_CHANNEL_ERROR";
+  ClientEventTypes2["NEGOTIATION_NEEDED"] = "NEGOTIATION_NEEDED";
+  ClientEventTypes2["SIGNALING_STATE_CHANGE"] = "SIGNALING_STATE_CHANGE";
+  ClientEventTypes2["ICE_CANDIDATE"] = "ICE_CANDIDATE";
+  ClientEventTypes2["ICE_CANDIDATE_ERROR"] = "ICE_CANDIDATE_ERROR";
+  ClientEventTypes2["PRODUCER_ADDED"] = "PRODUCER_ADDED";
+  ClientEventTypes2["PRODUCER_REMOVED"] = "PRODUCER_REMOVED";
+  ClientEventTypes2["PRODUCER_PAUSED"] = "PRODUCER_PAUSED";
+  ClientEventTypes2["PRODUCER_RESUMED"] = "PRODUCER_RESUMED";
+  ClientEventTypes2["CONSUMER_ADDED"] = "CONSUMER_ADDED";
+  ClientEventTypes2["CONSUMER_REMOVED"] = "CONSUMER_REMOVED";
+  ClientEventTypes2["CONSUMER_PAUSED"] = "CONSUMER_PAUSED";
+  ClientEventTypes2["CONSUMER_RESUMED"] = "CONSUMER_RESUMED";
+  ClientEventTypes2["DATA_PRODUCER_CREATED"] = "DATA_PRODUCER_CREATED";
+  ClientEventTypes2["DATA_PRODUCER_CLOSED"] = "DATA_PRODUCER_CLOSED";
+  ClientEventTypes2["DATA_CONSUMER_CREATED"] = "DATA_CONSUMER_CREATED";
+  ClientEventTypes2["DATA_CONSUMER_CLOSED"] = "DATA_CONSUMER_CLOSED";
+  return ClientEventTypes2;
+})(ClientEventTypes || {});
+
+// src/schema/ClientMetaTypes.ts
+var ClientMetaTypes = /* @__PURE__ */ ((ClientMetaTypes2) => {
+  ClientMetaTypes2["MEDIA_CONSTRAINT"] = "MEDIA_CONSTRAINT";
+  ClientMetaTypes2["MEDIA_DEVICE"] = "MEDIA_DEVICE";
+  ClientMetaTypes2["MEDIA_DEVICES_SUPPORTED_CONSTRAINTS"] = "MEDIA_DEVICES_SUPPORTED_CONSTRAINTS";
+  ClientMetaTypes2["USER_MEDIA_ERROR"] = "USER_MEDIA_ERROR";
+  ClientMetaTypes2["LOCAL_SDP"] = "LOCAL_SDP";
+  ClientMetaTypes2["OPERATION_SYSTEM"] = "OPERATION_SYSTEM";
+  ClientMetaTypes2["ENGINE"] = "ENGINE";
+  ClientMetaTypes2["PLATFORM"] = "PLATFORM";
+  ClientMetaTypes2["BROWSER"] = "BROWSER";
+  return ClientMetaTypes2;
+})(ClientMetaTypes || {});
+
+// src/ObservedClient.ts
+var logger2 = createLogger("ObservedClient");
+var ObservedClient = class extends EventEmitter2 {
+  constructor(settings, call) {
+    super();
+    this.call = call;
+    this.setMaxListeners(Infinity);
+    this.eventScope = { observer: call.observer, observedCall: call, observedClient: this };
+    this.sink = call.observer.config.createClientSink?.({ clientId: settings.clientId, observedCall: call });
+    this.clientId = settings.clientId;
+    this.appData = settings.appData ?? {};
+    this.settings = {
+      closeClientIfIdleForMs: settings.closeClientIfIdleForMs
+    };
+    if (this.sink) {
+      const onError = (err) => logger2.warn("ClientSampleSink error for client %s: %o", this.clientId, err);
+      this.sink.once("close", () => this.sink?.off("error", onError));
+      this.sink.on("error", onError);
+    }
+  }
+  call;
+  clientId;
+  observedPeerConnections = /* @__PURE__ */ new Map();
+  /** Per-client sink (from `ObserverConfig.createClientSink`), if any. */
+  sink;
+  /** Ancestry base shared by all Observer-bus events originating at this client. */
+  eventScope;
+  calculatedScore = {
+    weight: 1,
+    value: void 0
+  };
+  settings;
+  appData;
+  attachments;
+  updated = Date.now();
+  acceptedSamples = 0;
+  closed = false;
+  joinedAt;
+  leftAt;
+  closedAt;
+  lastSampleTimestamp;
+  // the timestamp of the CLIENT_JOINED event
+  operationSystem;
+  engine;
+  platform;
+  browser;
+  mediaConstraints = [];
+  usingTURN = false;
+  usingTCP = false;
+  availableOutgoingBitrate = 0;
+  availableIncomingBitrate = 0;
+  deltaReceivedAudioBytes = 0;
+  deltaReceivedVideoBytes = 0;
+  deltaSentAudioBytes = 0;
+  deltaSentVideoBytes = 0;
+  deltaDataChannelBytesSent = 0;
+  deltaDataChannelBytesReceived = 0;
+  deltaDataChannelMessagesSent = 0;
+  deltaDataChannelMessagesReceived = 0;
+  deltaInboundPacketsLost = 0;
+  deltaInboundPacketsReceived = 0;
+  deltaOutboundPacketsSent = 0;
+  deltaTransportSentBytes = 0;
+  deltaTransportReceivedBytes = 0;
+  deltaRttLt50Measurements = 0;
+  deltaRttLt150Measurements = 0;
+  deltaRttLt300Measurements = 0;
+  deltaRttGtOrEq300Measurements = 0;
+  currentMaxRttInMs;
+  currentMinRttInMs;
+  currentAvgRttInMs;
+  sendingAudioBitrate = 0;
+  sendingVideoBitrate = 0;
+  receivingAudioBitrate = 0;
+  receivingVideoBitrate = 0;
+  numberOfInboundRtpStreams = 0;
+  numberOfInbundTracks = 0;
+  numberOfOutboundRtpStreams = 0;
+  numberOfOutboundTracks = 0;
+  numberOfDataChannels = 0;
+  deltaNumberOfIssues = 0;
+  totalScoreSum = 0;
+  numberOfScoreMeasurements = 0;
+  // public totalNumberOfIssues = 0;
+  mediaDevices = [];
+  issues = [];
+  _injections = {};
+  closeTimer;
+  get numberOfPeerConnections() {
+    return this.observedPeerConnections.size;
+  }
+  get score() {
+    return this.calculatedScore.value;
+  }
+  close() {
+    if (this.closed) return;
+    this.closed = true;
+    this._injections.clientEvents?.forEach((clientEvent) => this._processClientEvent(clientEvent));
+    this._injections.clientIssues?.forEach((clientIssue) => this.addIssue(clientIssue));
+    this._injections.extensionStats?.forEach((extensionStat) => this.addExtensionStats(extensionStat));
+    this._injections.clientMetaItems?.forEach((clientMetaItem) => this.addMetadata(clientMetaItem));
+    Array.from(this.observedPeerConnections.values()).forEach((peerConnection) => peerConnection.close());
+    if (!this.leftAt) {
+      this.leftAt = this.lastSampleTimestamp;
+      if (this.leftAt) {
+        this.emit("left");
+        this._notify("client-left", { ...this.eventScope });
+      }
+    }
+    this.closedAt = Date.now();
+    this.emit("close");
+    this._notify("client-closed", { ...this.eventScope });
+    try {
+      this.sink?.end();
+    } catch (err) {
+      logger2.warn("ClientSampleSink.end failed for client %s: %o", this.clientId, err);
+    }
+  }
+  accept(sample, context) {
+    if (this.closed) {
+      logger2.warn("Attempted to accept a sample on a closed client %s", this.clientId);
+      return;
+    }
+    this.sink?.write(sample);
+    if (this.closeTimer) {
+      clearTimeout(this.closeTimer);
+      this.closeTimer = void 0;
+    }
+    const now = Date.now();
+    const elapsedInMs = now - this.updated;
+    const elapsedInSeconds = elapsedInMs / 1e3;
+    let sumOfRtts = 0;
+    let numberOfRttMeasurements = 0;
+    ++this.acceptedSamples;
+    this.availableIncomingBitrate = 0;
+    this.availableOutgoingBitrate = 0;
+    this.deltaDataChannelBytesReceived = 0;
+    this.deltaDataChannelBytesSent = 0;
+    this.deltaDataChannelMessagesReceived = 0;
+    this.deltaDataChannelMessagesSent = 0;
+    this.deltaInboundPacketsLost = 0;
+    this.deltaInboundPacketsReceived = 0;
+    this.deltaOutboundPacketsSent = 0;
+    this.deltaReceivedAudioBytes = 0;
+    this.deltaReceivedVideoBytes = 0;
+    this.deltaSentAudioBytes = 0;
+    this.deltaSentVideoBytes = 0;
+    this.deltaTransportReceivedBytes = 0;
+    this.deltaTransportSentBytes = 0;
+    this.deltaRttLt50Measurements = 0;
+    this.deltaRttLt150Measurements = 0;
+    this.deltaRttLt300Measurements = 0;
+    this.deltaRttGtOrEq300Measurements = 0;
+    this.deltaNumberOfIssues = 0;
+    this.numberOfDataChannels = 0;
+    this.numberOfInboundRtpStreams = 0;
+    this.numberOfInbundTracks = 0;
+    this.numberOfOutboundRtpStreams = 0;
+    this.numberOfOutboundTracks = 0;
+    this.usingTURN = false;
+    this.usingTCP = false;
+    this.currentMinRttInMs = void 0;
+    this.currentMaxRttInMs = void 0;
+    this._mergeInjections(sample);
+    const clientEventsPostBuffer = [];
+    for (const clientEvent of sample.clientEvents ?? []) {
+      this._processClientEvent(clientEvent, clientEventsPostBuffer);
+    }
+    for (const metaData of sample.clientMetaItems ?? []) {
+      this.addMetadata(metaData);
+    }
+    for (const issue of sample.clientIssues ?? []) {
+      this.addIssue(issue);
+      ++this.deltaNumberOfIssues;
+    }
+    for (const extensionStat of sample.extensionStats ?? []) {
+      this.addExtensionStats(extensionStat);
+    }
+    for (const pcSample of sample.peerConnections ?? []) {
+      const observedPeerConnection = this._updatePeerConnection(pcSample, context);
+      if (!observedPeerConnection) continue;
+      this.deltaDataChannelBytesReceived += observedPeerConnection.deltaDataChannelBytesReceived;
+      this.deltaDataChannelBytesSent += observedPeerConnection.deltaDataChannelBytesSent;
+      this.deltaDataChannelMessagesReceived += observedPeerConnection.deltaDataChannelMessagesReceived;
+      this.deltaDataChannelMessagesSent += observedPeerConnection.deltaDataChannelMessagesSent;
+      this.deltaInboundPacketsLost += observedPeerConnection.deltaInboundPacketsLost;
+      this.deltaInboundPacketsReceived += observedPeerConnection.deltaInboundPacketsReceived;
+      this.deltaOutboundPacketsSent += observedPeerConnection.deltaOutboundPacketsSent;
+      this.deltaReceivedAudioBytes += observedPeerConnection.deltaReceivedAudioBytes;
+      this.deltaReceivedVideoBytes += observedPeerConnection.deltaReceivedVideoBytes;
+      this.deltaSentAudioBytes += observedPeerConnection.deltaSentAudioBytes;
+      this.deltaSentVideoBytes += observedPeerConnection.deltaSentVideoBytes;
+      this.deltaTransportReceivedBytes += observedPeerConnection.deltaTransportReceivedBytes;
+      this.deltaTransportSentBytes += observedPeerConnection.deltaTransportSentBytes;
+      this.availableIncomingBitrate += observedPeerConnection.availableIncomingBitrate;
+      this.availableOutgoingBitrate += observedPeerConnection.availableOutgoingBitrate;
+      this.numberOfDataChannels += observedPeerConnection.observedDataChannels.size;
+      this.numberOfInbundTracks += observedPeerConnection.observedInboundTracks.size;
+      this.numberOfOutboundRtpStreams += observedPeerConnection.observedOutboundRtps.size;
+      this.numberOfOutboundTracks += observedPeerConnection.observedOutboundTracks.size;
+      this.numberOfInboundRtpStreams += observedPeerConnection.observedInboundRtps.size;
+      if (observedPeerConnection.usingTURN) {
+        this.usingTURN = true;
+      }
+      if (observedPeerConnection.usingTCP) {
+        this.usingTCP = true;
+      }
+      if (observedPeerConnection.currentRttInMs) {
+        if (this.currentMinRttInMs === void 0 || observedPeerConnection.currentRttInMs < this.currentMinRttInMs) {
+          this.currentMinRttInMs = observedPeerConnection.currentRttInMs;
+        }
+        if (this.currentMaxRttInMs === void 0 || observedPeerConnection.currentRttInMs > this.currentMaxRttInMs) {
+          this.currentMaxRttInMs = observedPeerConnection.currentRttInMs;
+        }
+        if (observedPeerConnection.currentRttInMs < 50) {
+          this.deltaRttLt50Measurements += 1;
+        } else if (observedPeerConnection.currentRttInMs < 150) {
+          this.deltaRttLt150Measurements += 1;
+        } else if (observedPeerConnection.currentRttInMs < 300) {
+          this.deltaRttLt300Measurements += 1;
+        } else if (300 <= observedPeerConnection.currentRttInMs) {
+          this.deltaRttGtOrEq300Measurements += 1;
+        }
+        sumOfRtts += observedPeerConnection.currentRttInMs;
+        ++numberOfRttMeasurements;
+      }
+    }
+    for (const clientEvent of clientEventsPostBuffer) {
+      this._processClientEvent(clientEvent);
+    }
+    this.attachments = sample.attachments;
+    this.receivingAudioBitrate = this.deltaReceivedAudioBytes * 8 / elapsedInSeconds;
+    this.receivingVideoBitrate = this.deltaReceivedVideoBytes * 8 / elapsedInSeconds;
+    this.sendingAudioBitrate = this.deltaSentAudioBytes * 8 / elapsedInSeconds;
+    this.sendingVideoBitrate = this.deltaSentVideoBytes * 8 / elapsedInSeconds;
+    this.currentAvgRttInMs = 0 < numberOfRttMeasurements ? sumOfRtts / numberOfRttMeasurements : void 0;
+    this.calculatedScore.value = sample.score;
+    this.lastSampleTimestamp = sample.timestamp;
+    const elapsedTimeInMs = now - this.updated;
+    this.emit("update", sample, elapsedTimeInMs, context);
+    this._notify("client-updated", { ...this.eventScope, sample, elapsedTimeInMs, context });
+    this.updated = now;
+    if (this.calculatedScore.value) {
+      this.totalScoreSum += this.calculatedScore.value;
+      ++this.numberOfScoreMeasurements;
+    }
+    if (this.settings.closeClientIfIdleForMs !== void 0) {
+      this.closeTimer = setTimeout(() => {
+        this.close();
+      }, this.settings.closeClientIfIdleForMs);
+    }
+  }
+  injectMetaData(metaData) {
+    if (this.closed) return;
+    if (!this._injections.clientMetaItems) this._injections.clientMetaItems = [];
+    this._injections.clientMetaItems.push(metaData);
+  }
+  injectEvent(event) {
+    if (this.closed) return;
+    if (!this._injections.clientEvents) this._injections.clientEvents = [];
+    this._injections.clientEvents.push(event);
+  }
+  injectIssue(issue) {
+    if (this.closed) return;
+    if (!this._injections.clientIssues) this._injections.clientIssues = [];
+    this._injections.clientIssues.push(issue);
+  }
+  injectExtensionStat(stat) {
+    if (this.closed) return;
+    if (!this._injections.extensionStats) this._injections.extensionStats = [];
+    this._injections.extensionStats.push(stat);
+  }
+  injectAttachment(key, value) {
+    if (this.closed) return;
+    if (!this._injections.attachments) this._injections.attachments = {};
+    this._injections.attachments[key] = value;
+  }
+  addMetadata(metadata) {
+    if (this.closed) return;
+    switch (metadata.type) {
+      case "BROWSER" /* BROWSER */: {
+        this.browser = parseJsonAs(metadata.payload);
+        break;
+      }
+      case "ENGINE" /* ENGINE */: {
+        this.engine = parseJsonAs(metadata.payload);
+        break;
+      }
+      case "PLATFORM" /* PLATFORM */: {
+        this.platform = parseJsonAs(metadata.payload);
+        break;
+      }
+      case "OPERATION_SYSTEM" /* OPERATION_SYSTEM */: {
+        this.operationSystem = parseJsonAs(metadata.payload);
+        break;
+      }
+    }
+    this._notify("client-metadata", { ...this.eventScope, metaData: metadata });
+  }
+  addIssue(issue) {
+    if (this.closed) return;
+    this._notify("client-issue", { ...this.eventScope, issue });
+  }
+  addExtensionStats(stats) {
+    this._notify("client-extension-stats", { ...this.eventScope, extensionStats: stats });
+  }
+  _processClientEvent(event, postBuffer) {
+    switch (event.type) {
+      case "CLIENT_JOINED" /* CLIENT_JOINED */: {
+        if (event.timestamp) {
+          if (!this.joinedAt) {
+            this.joinedAt = event.timestamp;
+            this.emit("joined");
+            this._notify("client-joined", { ...this.eventScope });
+          } else if (this.joinedAt < event.timestamp) {
+            this._notify("client-rejoined", { ...this.eventScope, timestamp: event.timestamp });
+          } else {
+            this.joinedAt = event.timestamp;
+            logger2.warn(`Client ${this.clientId} joinedAt timestamp was updated to ${event.timestamp}. the joined event will not be emitted.`);
+          }
+        }
+        logger2.debug("Client %s joined at %o", this.clientId, event);
+        break;
+      }
+      case "CLIENT_LEFT" /* CLIENT_LEFT */: {
+        if (event.timestamp) {
+          if (!this.leftAt) {
+            this.leftAt = event.timestamp;
+            this.emit("left");
+            this._notify("client-left", { ...this.eventScope });
+          } else {
+            logger2.warn(`Client ${this.clientId} leftAt timestamp was already set`);
+          }
+        }
+        logger2.debug("Client %s left at %o", this.clientId, event);
+        break;
+      }
+      case "PEER_CONNECTION_OPENED" /* PEER_CONNECTION_OPENED */: {
+        const payload = parseJsonAs(event.payload);
+        if (payload?.peerConnectionId && typeof payload.peerConnectionId === "string") {
+          const observedPeerConnection = this.observedPeerConnections.get(payload.peerConnectionId);
+          if (observedPeerConnection) {
+            observedPeerConnection.openedAt = event.timestamp;
+          } else if (postBuffer) {
+            postBuffer.push(event);
+          } else {
+            logger2.warn("Received PEER_CONNECTION_OPENED event without a corresponding observedPeerConnection: %o", event);
+          }
+        }
+        break;
+      }
+      case "PEER_CONNECTION_CLOSED" /* PEER_CONNECTION_CLOSED */: {
+        const payload = parseJsonAs(event.payload);
+        if (payload?.peerConnectionId && typeof payload.peerConnectionId === "string") {
+          const observedPeerConnection = this.observedPeerConnections.get(payload.peerConnectionId);
+          if (observedPeerConnection) {
+            observedPeerConnection.closedAt = event.timestamp;
+          } else if (postBuffer) {
+            postBuffer.push(event);
+          } else {
+            logger2.warn("Received PEER_CONNECTION_CLOSED event without a corresponding observedPeerConnection: %o", event);
+          }
+        }
+        break;
+      }
+      case "MEDIA_TRACK_ADDED" /* MEDIA_TRACK_ADDED */: {
+        const payload = parseJsonAs(event.payload);
+        if (payload?.peerConnectionId && typeof payload.peerConnectionId === "string" && payload?.trackId && typeof payload.trackId === "string") {
+          const observedPeerConnection = this.observedPeerConnections.get(payload.peerConnectionId);
+          const observedTrack = observedPeerConnection?.observedInboundTracks.get(payload.trackId) ?? observedPeerConnection?.observedOutboundTracks.get(payload.trackId);
+          if (observedTrack) {
+            observedTrack.addedAt = event.timestamp;
+          } else if (postBuffer) {
+            postBuffer.push(event);
+          } else {
+            logger2.warn("Received MEDIA_TRACK_ADDED event without a corresponding observedPeerConnection or observedTrack: %o", event);
+          }
+        }
+        break;
+      }
+      case "MEDIA_TRACK_REMOVED" /* MEDIA_TRACK_REMOVED */: {
+        const payload = parseJsonAs(event.payload);
+        if (payload?.peerConnectionId && typeof payload.peerConnectionId === "string" && payload?.trackId && typeof payload.trackId === "string") {
+          const observedPeerConnection = this.observedPeerConnections.get(payload.peerConnectionId);
+          const observedTrack = observedPeerConnection?.observedInboundTracks.get(payload.trackId) ?? observedPeerConnection?.observedOutboundTracks.get(payload.trackId);
+          if (observedTrack) {
+            observedTrack.removedAt = event.timestamp;
+          } else if (postBuffer) {
+            postBuffer.push(event);
+          } else {
+            logger2.warn("Received MEDIA_TRACK_REMOVED event without a corresponding observedPeerConnection or observedTrack: %o", event);
+          }
+        }
+        break;
+      }
+      case "DATA_CHANNEL_OPEN" /* DATA_CHANNEL_OPEN */: {
+        const payload = parseJsonAs(event.payload);
+        if (payload?.peerConnectionId && typeof payload.peerConnectionId === "string" && payload?.dataChannelId && typeof payload.dataChannelId === "string") {
+          const observedPeerConnection = this.observedPeerConnections.get(payload.peerConnectionId);
+          const observedDataChannel = observedPeerConnection?.observedDataChannels.get(payload.dataChannelId);
+          if (observedDataChannel) {
+            observedDataChannel.addedAt = event.timestamp;
+          } else if (postBuffer) {
+            postBuffer.push(event);
+          } else {
+            logger2.warn("Received DATA_CHANNEL_OPENED event without a corresponding observedPeerConnection or observedDataChannel: %o", event);
+          }
+        }
+        break;
+      }
+      case "DATA_CHANNEL_CLOSED" /* DATA_CHANNEL_CLOSED */: {
+        const payload = parseJsonAs(event.payload);
+        if (payload?.peerConnectionId && typeof payload.peerConnectionId === "string" && payload?.dataChannelId && typeof payload.dataChannelId === "string") {
+          const observedPeerConnection = this.observedPeerConnections.get(payload.peerConnectionId);
+          const observedDataChannel = observedPeerConnection?.observedDataChannels.get(payload.dataChannelId);
+          if (observedDataChannel) {
+            observedDataChannel.removedAt = event.timestamp;
+          } else if (postBuffer) {
+            postBuffer.push(event);
+          } else {
+            logger2.warn("Received DATA_CHANNEL_CLOSE event without a corresponding observedPeerConnection or observedDataChannel: %o", event);
+          }
+        }
+        break;
+      }
+      case "MEDIA_TRACK_MUTED" /* MEDIA_TRACK_MUTED */: {
+        const payload = parseJsonAs(event.payload);
+        if (payload?.peerConnectionId && typeof payload.peerConnectionId === "string" && payload?.trackId && typeof payload.trackId === "string") {
+          const observedPeerConnection = this.observedPeerConnections.get(payload.peerConnectionId);
+          const observedInboundTrack = observedPeerConnection?.observedInboundTracks.get(payload.trackId);
+          const observedOutboundTrack = observedPeerConnection?.observedOutboundTracks.get(payload.trackId);
+          if (observedPeerConnection) {
+            if (observedInboundTrack) {
+              observedInboundTrack.muted = true;
+              this._notify("inbound-track-muted", { ...this.eventScope, observedPeerConnection, observedInboundTrack });
+            } else if (observedOutboundTrack) {
+              observedOutboundTrack.muted = true;
+              this._notify("outbound-track-muted", { ...this.eventScope, observedPeerConnection, observedOutboundTrack });
+            }
+          } else if (postBuffer) {
+            postBuffer.push(event);
+          } else {
+            logger2.warn("Received MEDIA_TRACK_MUTED event without a corresponding observedPeerConnection or observedTrack: %o", event);
+          }
+        }
+        break;
+      }
+      case "MEDIA_TRACK_UNMUTED" /* MEDIA_TRACK_UNMUTED */: {
+        const payload = parseJsonAs(event.payload);
+        if (payload?.peerConnectionId && typeof payload.peerConnectionId === "string" && payload?.trackId && typeof payload.trackId === "string") {
+          const observedPeerConnection = this.observedPeerConnections.get(payload.peerConnectionId);
+          const observedInboundTrack = observedPeerConnection?.observedInboundTracks.get(payload.trackId);
+          const observedOutboundTrack = observedPeerConnection?.observedOutboundTracks.get(payload.trackId);
+          if (observedPeerConnection) {
+            if (observedInboundTrack) {
+              observedInboundTrack.muted = false;
+              this._notify("inbound-track-unmuted", { ...this.eventScope, observedPeerConnection, observedInboundTrack });
+            } else if (observedOutboundTrack) {
+              observedOutboundTrack.muted = false;
+              this._notify("outbound-track-unmuted", { ...this.eventScope, observedPeerConnection, observedOutboundTrack });
+            }
+          } else if (postBuffer) {
+            postBuffer.push(event);
+          } else {
+            logger2.warn("Received MEDIA_TRACK_UNMUTED event without a corresponding observedPeerConnection or observedTrack: %o", event);
+          }
+        }
+        break;
+      }
+      case "ICE_CONNECTION_STATE_CHANGED" /* ICE_CONNECTION_STATE_CHANGED */: {
+        const payload = parseJsonAs(event.payload);
+        if (payload?.peerConnectionId && typeof payload.peerConnectionId === "string" && payload?.iceConnectionState && typeof payload.iceConnectionState === "string") {
+          const observedPeerConnection = this.observedPeerConnections.get(payload.peerConnectionId);
+          if (observedPeerConnection) {
+            observedPeerConnection.iceConnectionState = payload.iceConnectionState;
+            this._notify("ice-connection-state-changed", { ...this.eventScope, observedPeerConnection, state: payload.iceConnectionState });
+          } else if (postBuffer) {
+            postBuffer.push(event);
+          } else {
+            logger2.warn("Received ICE_CONNECTION_STATE_CHANGED event without a corresponding observedPeerConnection: %o", event);
+          }
+        }
+        break;
+      }
+      case "ICE_GATHERING_STATE_CHANGED" /* ICE_GATHERING_STATE_CHANGED */: {
+        const payload = parseJsonAs(event.payload);
+        if (payload?.peerConnectionId && typeof payload.peerConnectionId === "string" && payload?.iceGatheringState && typeof payload.iceGatheringState === "string") {
+          const observedPeerConnection = this.observedPeerConnections.get(payload.peerConnectionId);
+          if (observedPeerConnection) {
+            observedPeerConnection.iceGatheringState = payload.iceGatheringState;
+            this._notify("ice-gathering-state-changed", { ...this.eventScope, observedPeerConnection, state: payload.iceGatheringState });
+          } else if (postBuffer) {
+            postBuffer.push(event);
+          } else {
+            logger2.warn("Received ICE_GATHERING_STATE_CHANGED event without a corresponding observedPeerConnection: %o", event);
+          }
+        }
+        break;
+      }
+      case "PEER_CONNECTION_STATE_CHANGED" /* PEER_CONNECTION_STATE_CHANGED */: {
+        const payload = parseJsonAs(event.payload);
+        if (payload?.peerConnectionId && typeof payload.peerConnectionId === "string" && payload?.peerConnectionState && typeof payload.peerConnectionState === "string") {
+          const observedPeerConnection = this.observedPeerConnections.get(payload.peerConnectionId);
+          if (observedPeerConnection) {
+            observedPeerConnection.connectionState = payload.peerConnectionState;
+            this._notify("connection-state-changed", { ...this.eventScope, observedPeerConnection, state: payload.peerConnectionState });
+          } else if (postBuffer) {
+            postBuffer.push(event);
+          } else {
+            logger2.warn("Received PEER_CONNECTION_STATE_CHANGED event without a corresponding observedPeerConnection: %o", event);
+          }
+        }
+        break;
+      }
+    }
+    this._notify("client-event", { ...this.eventScope, event });
+  }
+  _updatePeerConnection(sample, context) {
+    let observedPeerConnection = this.observedPeerConnections.get(sample.peerConnectionId);
+    if (!observedPeerConnection) {
+      if (!sample.peerConnectionId) {
+        return logger2.warn(
+          `ObservedClient received an invalid PeerConnectionSample (missing peerConnectionId field). ClientId: ${this.clientId}, CallId: ${this.call.callId}`,
+          sample
+        ), void 0;
+      }
+      const newObservedPeerConnection = new ObservedPeerConnection(sample.peerConnectionId, this);
+      newObservedPeerConnection.once("close", () => {
+        this.observedPeerConnections.delete(sample.peerConnectionId);
+      });
+      this.observedPeerConnections.set(sample.peerConnectionId, newObservedPeerConnection);
+      this._notify("peer-connection-added", { ...this.eventScope, observedPeerConnection: newObservedPeerConnection });
+      observedPeerConnection = newObservedPeerConnection;
+    }
+    observedPeerConnection.accept(sample, context);
+    return observedPeerConnection;
+  }
+  _mergeInjections(sample) {
+    if (this.closed) return sample;
+    if (this._injections.clientEvents) {
+      if (!sample.clientEvents) sample.clientEvents = [];
+      sample.clientEvents.push(...this._injections.clientEvents);
+      this._injections.clientEvents = void 0;
+    }
+    if (this._injections.clientIssues) {
+      if (!sample.clientIssues) sample.clientIssues = [];
+      sample.clientIssues.push(...this._injections.clientIssues);
+      this._injections.clientIssues = void 0;
+    }
+    if (this._injections.extensionStats) {
+      if (!sample.extensionStats) sample.extensionStats = [];
+      sample.extensionStats.push(...this._injections.extensionStats);
+      this._injections.extensionStats = void 0;
+    }
+    if (this._injections.attachments) {
+      if (!sample.attachments) sample.attachments = {};
+      Object.assign(sample.attachments, this._injections.attachments);
+      this._injections.attachments = void 0;
+    }
+    if (this._injections.clientMetaItems) {
+      if (!sample.clientMetaItems) sample.clientMetaItems = [];
+      sample.clientMetaItems.push(...this._injections.clientMetaItems);
+      this._injections.clientMetaItems = void 0;
+    }
+    return sample;
+  }
+  /** Emit an Observer-bus event scoped to this client (or a peer connection under it). */
+  _notify(type, ...args) {
+    this.call.observer.emit(type, ...args);
+  }
+};
+
+// src/scores/DefaultCallScoreCalculator.ts
+var DefaultCallScoreCalculator = class {
+  constructor(observedCall) {
+    this.observedCall = observedCall;
+  }
+  observedCall;
+  update() {
+    let totalScore = 0;
+    let totalWeight = 0;
+    for (const client of this.observedCall.observedClients.values()) {
+      if (client.score === void 0) continue;
+      totalScore += client.score * client.calculatedScore.weight;
+      totalWeight += client.calculatedScore.weight;
+    }
+    this.observedCall.calculatedScore.value = totalWeight ? totalScore / totalWeight : void 0;
+  }
+};
+
+// src/updaters/OnAllClientCallUpdater.ts
+var OnAllClientCallUpdater = class {
+  constructor(_observedCall) {
+    this._observedCall = _observedCall;
+    this._onNewObservedClient = this._onNewObservedClient.bind(this);
+    this._observedCall.once("close", () => {
+      this._observedCall.off("newclient", this._onNewObservedClient);
+    });
+    this._observedCall.on("newclient", this._onNewObservedClient);
+  }
+  _observedCall;
+  name = "OnAllClientCallUpdater";
+  description = "Call the update() method of the ObservedCall once all client has been updated";
+  _updatedClients = /* @__PURE__ */ new Set();
+  closed = false;
+  close() {
+    if (this.closed) return;
+    this.closed = true;
+    this._updatedClients.clear();
+  }
+  _onNewObservedClient(observedClient) {
+    if (this.closed) return;
+    const onUpdate = (...args) => this._onClientUpdate(observedClient, args[2]);
+    observedClient.once("close", () => {
+      observedClient.off("update", onUpdate);
+      this._updatedClients.delete(observedClient.clientId);
+      this._updateIfEveryClientUpdated();
+    });
+    observedClient.on("update", onUpdate);
+  }
+  _onClientUpdate(observedClient, context) {
+    if (observedClient.closed) return;
+    this._updatedClients.add(observedClient.clientId);
+    this._updateIfEveryClientUpdated(context);
+  }
+  _updateIfEveryClientUpdated(context) {
+    if (this._updatedClients.size < this._observedCall.observedClients.size) {
+      return;
+    } else if (this.closed) {
+      return;
+    }
+    this._updatedClients.clear();
+    this._observedCall.update(context);
+  }
+};
+
+// src/updaters/OnAnyClientCallUpdater.ts
+var OnAnyClientCallUpdater = class {
+  constructor(_observedCall) {
+    this._observedCall = _observedCall;
+    this._onNewObservedClient = this._onNewObservedClient.bind(this);
+    this._observedCall.once("close", () => {
+      this._observedCall.off("newclient", this._onNewObservedClient);
+    });
+    this._observedCall.on("newclient", this._onNewObservedClient);
+  }
+  _observedCall;
+  name = "OnAnyClientCallUpdater";
+  description = "Call the update() method of the ObservedCall when any of the client has been updated";
+  closed = false;
+  close() {
+    if (this.closed) return;
+    this.closed = true;
+  }
+  _onNewObservedClient(observedClient) {
+    if (this.closed) return;
+    const onUpdate = (...args) => {
+      if (this.closed) return;
+      this._observedCall.update(args[2]);
+    };
+    observedClient.once("close", () => {
+      observedClient.off("update", onUpdate);
+    });
+    observedClient.on("update", onUpdate);
+  }
+};
+
+// src/detectors/Detectors.ts
+var logger3 = createLogger("Detectors");
+var Detectors = class {
+  _detectors;
+  constructor(...detectors) {
+    this._detectors = detectors;
+  }
+  get listOfNames() {
+    return this._detectors.map((d) => d.name);
+  }
+  add(detector) {
+    this._detectors.push(detector);
+  }
+  remove(detector) {
+    this._detectors = this._detectors.filter((d) => d !== detector);
+  }
+  update() {
+    for (const detector of this._detectors) {
+      try {
+        detector.update();
+      } catch (err) {
+        logger3.warn(`Error updating detector ${detector?.name}`, err);
+      }
+    }
+  }
+  clear() {
+    this._detectors = [];
+  }
+};
+
+// src/ObservedCall.ts
+var logger4 = createLogger("ObservedCall");
+var ObservedCall = class extends EventEmitter3 {
+  constructor(settings, observer) {
+    super();
+    this.observer = observer;
+    this.setMaxListeners(Infinity);
+    this.eventScope = { observer: this.observer, observedCall: this };
+    this.callId = settings.callId;
+    this.appData = settings.appData ?? {};
+    this.scoreCalculator = new DefaultCallScoreCalculator(this);
+    this.detectors = new Detectors();
+    switch (settings.updatePolicy) {
+      case "update-on-any-client-updated":
+        this.updater = new OnAnyClientCallUpdater(this);
+        break;
+      case "update-when-all-client-updated":
+        this.updater = new OnAllClientCallUpdater(this);
+        break;
+      case "none":
+        break;
+    }
+    this.settings = {
+      closeCallIfEmptyForMs: settings.closeCallIfEmptyForMs
+    };
+  }
+  observer;
+  updater;
+  scoreCalculator;
+  detectors;
+  callId;
+  observedClients = /* @__PURE__ */ new Map();
+  clientsUsedTurn = /* @__PURE__ */ new Set();
+  calculatedScore = {
+    weight: 1,
+    value: void 0
+  };
+  remoteTrackResolver;
+  totalAddedClients = 0;
+  totalRemovedClients = 0;
+  numberOfIssues = 0;
+  numberOfPeerConnections = 0;
+  numberOfInboundRtpStreams = 0;
+  numberOfOutboundRtpStreams = 0;
+  numberOfDataChannels = 0;
+  maxNumberOfClients = 0;
+  deltaNumberOfIssues = 0;
+  // public deltaRttLt50Measurements = 0;
+  // public deltaRttLt150Measurements = 0;
+  // public deltaRttLt300Measurements = 0;
+  // public deltaRttGtOrEq300Measurements = 0;
+  appData;
+  closed = false;
+  startedAt;
+  endedAt;
+  closedAt;
+  settings;
+  /** Ancestry base shared by all Observer-bus events originating at this call. */
+  eventScope;
+  closeTimer;
+  get numberOfClients() {
+    return this.observedClients.size;
+  }
+  get score() {
+    return this.calculatedScore.value;
+  }
+  /** Raise a call-level (server-side) issue; surfaced on the Observer bus as `call-issue`. */
+  addIssue(issue) {
+    if (this.closed) return;
+    this._notify("call-issue", { ...this.eventScope, issue });
+  }
+  close() {
+    if (this.closed) return;
+    this.update();
+    this.closed = true;
+    this.updater?.close();
+    let minSampleTimestamps;
+    let maxSampleTimestamps;
+    for (const client of this.observedClients.values()) {
+      client.close();
+      if (client.joinedAt) minSampleTimestamps = Math.min(minSampleTimestamps ?? client.joinedAt, client.joinedAt);
+      if (client.leftAt) maxSampleTimestamps = Math.max(maxSampleTimestamps ?? client.leftAt, client.leftAt);
+    }
+    if (this.startedAt === void 0) this.startedAt = minSampleTimestamps;
+    if (this.endedAt === void 0) this.endedAt = maxSampleTimestamps;
+    this.closedAt = Date.now();
+    this.emit("close");
+    this._notify("call-closed", { ...this.eventScope });
+  }
+  getObservedClient(clientId) {
+    if (this.closed || !this.observedClients.has(clientId)) return;
+    return this.observedClients.get(clientId);
+  }
+  createObservedClient(settings) {
+    if (this.closed) {
+      logger4.warn("Attempted to create a client (clientId: %s) on a closed call %s", settings.clientId, this.callId);
+      return void 0;
+    }
+    if (this.observedClients.has(settings.clientId)) {
+      logger4.warn("Client with id %s already exists in call %s; returning the existing instance", settings.clientId, this.callId);
+      return this.observedClients.get(settings.clientId);
+    }
+    if (!settings.closeClientIfIdleForMs) {
+      settings.closeClientIfIdleForMs = this.observer.config.closeClientIfIdleForMs;
+    }
+    if (settings.appData === void 0) {
+      settings.appData = this.observer.config.createClientAppData?.({ clientId: settings.clientId, observedCall: this });
+    }
+    const result = new ObservedClient(settings, this);
+    const wasEmpty = this.observedClients.size === 0;
+    const onUpdate = () => this._onClientUpdate(result);
+    const joined = () => this._clientJoined(result);
+    const left = () => this._clientLeft(result);
+    result.once("close", () => {
+      result.off("update", onUpdate);
+      result.off("joined", joined);
+      result.off("left", left);
+      this.observedClients.delete(settings.clientId);
+      if (this.observedClients.size === 0) {
+        this.emit("empty");
+        this._notify("call-empty", { ...this.eventScope });
+        if (this.settings.closeCallIfEmptyForMs) {
+          this.closeTimer = setTimeout(() => {
+            this.close();
+          }, this.settings.closeCallIfEmptyForMs);
+        }
+      }
+      ++this.totalRemovedClients;
+    });
+    result.on("update", onUpdate);
+    result.on("joined", joined);
+    result.on("left", left);
+    ++this.totalAddedClients;
+    this.observedClients.set(settings.clientId, result);
+    this.maxNumberOfClients = Math.max(this.maxNumberOfClients, this.observedClients.size);
+    if (this.closeTimer) {
+      clearTimeout(this.closeTimer);
+      this.closeTimer = void 0;
+    }
+    this.emit("newclient", result);
+    this._notify("client-added", { ...this.eventScope, observedClient: result });
+    if (result.sink) {
+      this._notify("client-sink-created", { ...this.eventScope, observedClient: result, sink: result.sink });
+    }
+    if (wasEmpty) {
+      this.emit("not-empty");
+      this._notify("call-not-empty", { ...this.eventScope });
+    }
+    return result;
+  }
+  getOrCreateObservedClient(settings) {
+    return this.getObservedClient(settings.clientId) ?? this.createObservedClient(settings);
+  }
+  update(context) {
+    if (this.closed) return;
+    this.numberOfInboundRtpStreams = 0;
+    this.numberOfOutboundRtpStreams = 0;
+    this.numberOfPeerConnections = 0;
+    this.numberOfDataChannels = 0;
+    for (const client of this.observedClients.values()) {
+      this.numberOfInboundRtpStreams += client.numberOfInboundRtpStreams;
+      this.numberOfOutboundRtpStreams += client.numberOfOutboundRtpStreams;
+      this.numberOfPeerConnections += client.numberOfPeerConnections;
+      this.numberOfDataChannels += client.numberOfDataChannels;
+    }
+    this.scoreCalculator.update();
+    this.detectors.update();
+    this.emit("update");
+    this._notify("call-updated", { ...this.eventScope, context });
+    this.deltaNumberOfIssues = 0;
+  }
+  _onClientUpdate(client) {
+    this.deltaNumberOfIssues += client.deltaNumberOfIssues;
+    this.numberOfIssues += client.deltaNumberOfIssues;
+    if (client.usingTURN) {
+      this.clientsUsedTurn.add(client.clientId);
+    }
+  }
+  _clientJoined(client) {
+    if (!client.joinedAt) return;
+    this.startedAt = Math.min(this.startedAt ?? client.joinedAt, client.joinedAt);
+  }
+  _clientLeft(client) {
+    if (!client.leftAt) return;
+    this.endedAt = Math.max(this.endedAt ?? client.leftAt, client.leftAt);
+  }
+  /** Emit an Observer-bus event scoped to this call. */
+  _notify(type, ...args) {
+    this.observer.emit(type, ...args);
+  }
+};
+
+// src/Observer.ts
+import { EventEmitter as EventEmitter6 } from "events";
+
+// src/ObservedTURN.ts
+import { EventEmitter as EventEmitter4 } from "events";
+
+// src/ObservedTurnServer.ts
+var ObservedTurnServer = class {
+  constructor(url, observedTURN) {
+    this.url = url;
+    this.observedTURN = observedTURN;
+  }
+  url;
+  observedTURN;
+  totalBytesSent = 0;
+  totalBytesReceived = 0;
+  totalPacketsSent = 0;
+  totalPacketsReceived = 0;
+  packetsSentPerSecond = 0;
+  packetsReceivedPerSecond = 0;
+  outboundBitrate = 0;
+  inboundBitrate = 0;
+  deltaBytesSent = 0;
+  deltaBytesReceived = 0;
+  deltaPacketsSent = 0;
+  deltaPacketsReceived = 0;
+  observedPeerConnections = /* @__PURE__ */ new Map();
+  updated = Date.now();
+  updateTurnUsage(...selectedcandidatepairs) {
+    for (const selectedcandidatepair of selectedcandidatepairs) {
+      this.deltaBytesReceived += selectedcandidatepair.deltaBytesReceived;
+      this.deltaBytesSent += selectedcandidatepair.deltaBytesSent;
+      this.deltaPacketsReceived += selectedcandidatepair.deltaPacketsReceived;
+      this.deltaPacketsSent += selectedcandidatepair.deltaPacketsSent;
+    }
+  }
+  update() {
+    const now = Date.now();
+    const deltaInS = (now - this.updated) / 1e3;
+    this.packetsSentPerSecond = this.deltaPacketsSent / deltaInS;
+    this.packetsReceivedPerSecond = this.deltaPacketsReceived / deltaInS;
+    this.outboundBitrate = this.deltaBytesReceived * 8 / deltaInS;
+    this.inboundBitrate = this.deltaBytesSent * 8 / deltaInS;
+    this.totalBytesSent += this.deltaBytesSent;
+    this.totalBytesReceived += this.deltaBytesReceived;
+    this.totalPacketsSent += this.deltaPacketsSent;
+    this.totalPacketsReceived += this.deltaPacketsReceived;
+    this.observedTURN.totalBytesSent += this.deltaBytesSent;
+    this.observedTURN.totalBytesReceived += this.deltaBytesReceived;
+    this.observedTURN.totalPacketsSent += this.deltaPacketsSent;
+    this.observedTURN.totalPacketsReceived += this.deltaPacketsReceived;
+    this.observedTURN.inboundBitrate += this.inboundBitrate;
+    this.observedTURN.outboundBitrate += this.outboundBitrate;
+    this.observedTURN.packetsReceivedPerSecond += this.packetsReceivedPerSecond;
+    this.observedTURN.packetsSentPerSecond += this.packetsSentPerSecond;
+    this.deltaBytesSent = 0;
+    this.deltaBytesReceived = 0;
+    this.deltaPacketsSent = 0;
+    this.deltaPacketsReceived = 0;
+    this.updated = now;
+  }
+};
+
+// src/ObservedTURN.ts
+var logger5 = createLogger("ObservedTURN");
+var ObservedTURN = class extends EventEmitter4 {
+  totalBytesSent = 0;
+  totalBytesReceived = 0;
+  totalPacketsSent = 0;
+  totalPacketsReceived = 0;
+  packetsSentPerSecond = 0;
+  packetsReceivedPerSecond = 0;
+  outboundBitrate = 0;
+  inboundBitrate = 0;
+  numberOfClients = 0;
+  servers = /* @__PURE__ */ new Map();
+  constructor() {
+    super();
+  }
+  update() {
+    const clientIds = /* @__PURE__ */ new Set();
+    this.packetsReceivedPerSecond = 0;
+    this.packetsSentPerSecond = 0;
+    this.outboundBitrate = 0;
+    this.inboundBitrate = 0;
+    for (const server of this.servers.values()) {
+      server.update();
+      server.observedPeerConnections.forEach((pc) => clientIds.add(pc.client.clientId));
+    }
+    this.numberOfClients = clientIds.size;
+  }
+  addPeerConnection(peerConnection) {
+    const turnPairs = peerConnection.selectedIceCandidatePairs.filter((pair) => pair.getLocalCandidate()?.candidateType === "relay" && pair.getRemoteCandidate()?.url?.startsWith("turn:"));
+    if (turnPairs.length !== 1) {
+      return logger5.warn(`Expected exactly one TURN pair, but found for peerconnection ${peerConnection.peerConnectionId}`, turnPairs.length), void 0;
+    }
+    const candidatePair = turnPairs[0];
+    const rawUrl = candidatePair.getRemoteCandidate()?.url;
+    if (!rawUrl) {
+      return logger5.warn(`No remote candidate URL found for peerconnection ${peerConnection.peerConnectionId}`), void 0;
+    }
+    const turnUrl = new URL(rawUrl);
+    const turnServerUrl = `${turnUrl.protocol}//${turnUrl.hostname}:${turnUrl.port}`;
+    let turnServer = this.servers.get(turnServerUrl);
+    if (!turnServer) {
+      turnServer = new ObservedTurnServer(turnServerUrl, this);
+    }
+    return turnServer;
+  }
+  removePeerConnection(peerConnection) {
+    for (const turnServer of this.servers.values()) {
+      turnServer.observedPeerConnections.delete(peerConnection.peerConnectionId);
+    }
+  }
+};
+
+// src/updaters/OnAllCallObserverUpdater.ts
+var OnAllCallObserverUpdater = class {
+  constructor(observer) {
+    this.observer = observer;
+    this._onNewObservedCall = this._onNewObservedCall.bind(this);
+    this.observer.once("observer-closed", () => {
+      this.observer.off("call-added", this._onNewObservedCall);
+    });
+    this.observer.on("call-added", this._onNewObservedCall);
+  }
+  observer;
+  name = "OnAllCallObserverUpdater";
+  description = "Call Observer's update() method when all of the ObservedCalls are updated";
+  _updatedCalls = /* @__PURE__ */ new Set();
+  closed = false;
+  close() {
+    if (this.closed) return;
+    this.closed = true;
+    this._updatedCalls.clear();
+  }
+  _onNewObservedCall({ observedCall }) {
+    if (this.closed) return;
+    const onUpdate = () => this._onObservedCallUpdated(observedCall);
+    observedCall.once("close", () => {
+      observedCall.off("update", onUpdate);
+      this._updatedCalls.delete(observedCall.callId);
+      this._updateIfEveryCallUpdated();
+    });
+    observedCall.on("update", onUpdate);
+  }
+  _onObservedCallUpdated(observedCall) {
+    if (observedCall.closed) return;
+    this._updatedCalls.add(observedCall.callId);
+    this._updateIfEveryCallUpdated();
+  }
+  _updateIfEveryCallUpdated() {
+    if (this._updatedCalls.size < this.observer.observedCalls.size) return;
+    else if (this.closed) return;
+    this._updatedCalls.clear();
+    this.observer.update();
+  }
+};
+
+// src/updaters/OnAnyCallObserverUpdater.ts
+var OnAnyCallObserverUpdater = class {
+  constructor(observver) {
+    this.observver = observver;
+    this._onNewObservedCall = this._onNewObservedCall.bind(this);
+    this.observver.once("observer-closed", () => {
+      this.observver.off("call-added", this._onNewObservedCall);
+    });
+    this.observver.on("call-added", this._onNewObservedCall);
+  }
+  observver;
+  name = "OnAnyCallObserverUpdater";
+  description = "Call Observer's update() method on any of the ObservedCall is updated";
+  closed = false;
+  close() {
+    if (this.closed) return;
+    this.closed = true;
+  }
+  _onNewObservedCall({ observedCall }) {
+    if (this.closed) return;
+    const onUpdate = () => {
+      if (this.closed) return;
+      this.observver.update();
+    };
+    observedCall.once("close", () => {
+      observedCall.off("update", onUpdate);
+    });
+    observedCall.on("update", onUpdate);
+  }
+};
+
+// src/common/Middleware.ts
+var Executor = class {
+  constructor(stack, finalCallback) {
+    this.stack = stack;
+    this.finalCallback = finalCallback;
+  }
+  stack;
+  finalCallback;
+  done = false;
+  index = 0;
+  prevIndex = -1;
+  // Executes the middleware stack
+  execute(input) {
+    if (this.index <= this.prevIndex) {
+      throw new Error("Middleware must call next() only once!");
+    } else if (this.done) {
+      throw new Error("Middleware stack has already been executed!");
+    }
+    this.prevIndex = this.index;
+    const middleware = this.stack[this.index];
+    this.index++;
+    if (middleware) {
+      return middleware(input, (nextInput) => this.execute(nextInput));
+    }
+    this.done = true;
+    this.finalCallback?.(input);
+  }
+};
+var MiddlewareProcessor = class {
+  stack = [];
+  finalCallback;
+  addMiddleware(...middlewares) {
+    if (middlewares && middlewares.length > 0) {
+      this.stack.push(...middlewares);
+    }
+    return this;
+  }
+  removeMiddleware(...middlewares) {
+    if (middlewares && middlewares.length > 0) {
+      for (const middleware of middlewares) {
+        const index = this.stack.indexOf(middleware);
+        if (index >= 0) {
+          this.stack.splice(index, 1);
+        }
+      }
+    }
+    return this;
+  }
+  process(value) {
+    if (this.stack.length === 0) {
+      return this.finalCallback?.(value);
+    }
+    const executor = new Executor(this.stack, this.finalCallback);
+    executor.execute(value);
+  }
+};
+
+// src/ObservedMediasoupRouter.ts
+import { EventEmitter as EventEmitter5 } from "events";
+var logger6 = createLogger("ObservedMediasoupRouter");
+var ObservedMediasoupRouter = class extends EventEmitter5 {
+  router;
+  sample;
+  appData;
+  webrtcTransportIds = /* @__PURE__ */ new Set();
+  get attachments() {
+    return this.sample.attachments;
+  }
+  closed = false;
+  constructor(settings) {
+    super();
+    this.router = settings.router;
+    this.appData = settings.appData ?? {};
+    this.sample = {
+      routerId: this.router.id,
+      attachments: settings.attachments ?? {},
+      createdAt: Date.now(),
+      producers: [],
+      consumers: [],
+      dataProducers: [],
+      dataConsumers: [],
+      transports: []
+    };
+    this.attachRouterListeners();
+  }
+  get id() {
+    return this.router.id;
+  }
+  addTransport = (transport) => {
+    let transportType = transport.type;
+    if (!transportType) {
+      if (transport.constructor.name === "WebRtcTransport") transportType = "webrtc";
+      else if (transport.constructor.name === "PlainTransport") transportType = "plain";
+      else if (transport.constructor.name === "PipeTransport") transportType = "pipe";
+      else if (transport.constructor.name === "DirectTransport") transportType = "direct";
+    }
+    if (!transportType) return logger6.warn(`Unknown transport type for transport ${transport.id}: ${transport.constructor.name}`);
+    switch (transportType) {
+      case "webrtc":
+        return this.addWebRtcTransport(transport);
+      case "plain":
+        return this.addPlainTransport(transport);
+      case "pipe":
+        return this.addPipeTransport(transport);
+      case "direct":
+        return this.addDirectTransport(transport);
+      default:
+        return logger6.warn(`Unsupported transport type for transport ${transport.id}: ${transportType}`);
+    }
+  };
+  addWebRtcTransport(transport) {
+    const history = [];
+    const transportSample = {
+      id: transport.id,
+      type: "webrtc",
+      createdAt: Date.now(),
+      tuple: transport.iceSelectedTuple,
+      history
+    };
+    this.sample.transports.push(transportSample);
+    const onIceStateChange = (iceState) => {
+      history.push({
+        type: `icestate-changed-to-${iceState}`,
+        timestamp: Date.now()
+      });
+    };
+    const onIceSelectedTupleChange = (tuple) => {
+      transportSample.tuple = tuple;
+      history.push({
+        type: "iceselectedtuple-changed",
+        timestamp: Date.now(),
+        ...tuple
+      });
+    };
+    const onDtlsStateChange = (dtlsState) => {
+      history.push({
+        type: `dtlsstate-changed-to-${dtlsState}`,
+        timestamp: Date.now()
+      });
+      if (dtlsState === "connected" && transportSample.connectedAt === void 0) {
+        transportSample.connectedAt = Date.now();
+      }
+    };
+    const onSctpStateChange = (sctpState) => {
+      history.push({
+        type: `sctpstate-changed-to-${sctpState}`,
+        timestamp: Date.now()
+      });
+    };
+    this._attachTransportObserverListeners(transport, transportSample, () => {
+      transport.observer.off("icestatechange", onIceStateChange);
+      transport.observer.off("iceselectedtuplechange", onIceSelectedTupleChange);
+      transport.observer.off("dtlsstatechange", onDtlsStateChange);
+      transport.observer.off("sctpstatechange", onSctpStateChange);
+      this.webrtcTransportIds.delete(transport.id);
+    });
+    transport.observer.on("icestatechange", onIceStateChange);
+    transport.observer.on("iceselectedtuplechange", onIceSelectedTupleChange);
+    transport.observer.on("dtlsstatechange", onDtlsStateChange);
+    transport.observer.on("sctpstatechange", onSctpStateChange);
+    this.webrtcTransportIds.add(transport.id);
+  }
+  addPlainTransport(transport) {
+    const history = [];
+    const transportSample = {
+      id: transport.id,
+      type: "plain",
+      createdAt: Date.now(),
+      tuple: transport.tuple,
+      rtcpTuple: transport.rtcpTuple,
+      history
+    };
+    this.sample.transports.push(transportSample);
+    const onTuple = (tuple) => {
+      transportSample.tuple = tuple;
+      if (transportSample.connectedAt === void 0) transportSample.connectedAt = Date.now();
+      history.push({ type: "tuple-changed", timestamp: Date.now(), ...tuple });
+    };
+    const onRtcpTuple = (rtcpTuple) => {
+      transportSample.rtcpTuple = rtcpTuple;
+      history.push({ type: "rtcptuple-changed", timestamp: Date.now(), ...rtcpTuple });
+    };
+    const onSctpStateChange = (sctpState) => {
+      if (sctpState === "connected" && transportSample.connectedAt === void 0) {
+        transportSample.connectedAt = Date.now();
+      }
+      history.push({
+        type: `sctpstate-changed-to-${sctpState}`,
+        timestamp: Date.now()
+      });
+    };
+    this._attachTransportObserverListeners(transport, transportSample, () => {
+      transport.observer.off("tuple", onTuple);
+      transport.observer.off("rtcptuple", onRtcpTuple);
+      transport.observer.off("sctpstatechange", onSctpStateChange);
+    });
+    transport.observer.on("tuple", onTuple);
+    transport.observer.on("rtcptuple", onRtcpTuple);
+    transport.observer.on("sctpstatechange", onSctpStateChange);
+  }
+  addPipeTransport(transport) {
+    const history = [];
+    const transportSample = {
+      id: transport.id,
+      type: "pipe",
+      createdAt: Date.now(),
+      tuple: transport.tuple,
+      history
+    };
+    this.sample.transports.push(transportSample);
+    const onSctpStateChange = (sctpState) => {
+      if (sctpState === "connected" && transportSample.connectedAt === void 0) {
+        transportSample.connectedAt = Date.now();
+      }
+      history.push({
+        type: `sctpstate-changed-to-${sctpState}`,
+        timestamp: Date.now()
+      });
+    };
+    this._attachTransportObserverListeners(transport, transportSample, () => {
+      transport.observer.off("sctpstatechange", onSctpStateChange);
+    });
+    transport.observer.on("sctpstatechange", onSctpStateChange);
+  }
+  addDirectTransport(transport) {
+    const now = Date.now();
+    const transportSample = {
+      id: transport.id,
+      type: "direct",
+      createdAt: now,
+      // A DirectTransport has no network layer — it is connected the instant it exists.
+      connectedAt: now,
+      history: []
+    };
+    this.sample.transports.push(transportSample);
+    this._attachTransportObserverListeners(transport, transportSample);
+  }
+  addProducer(transport, producer) {
+    const firstCodec = producer.rtpParameters.codecs[0];
+    const codecInfo = {
+      mimeType: firstCodec?.mimeType ?? "unknown/unknown",
+      payloadType: firstCodec?.payloadType ?? 0,
+      clockRate: firstCodec?.clockRate ?? 0,
+      channels: firstCodec?.channels,
+      parameters: firstCodec?.parameters,
+      rtcpFeedback: firstCodec?.rtcpFeedback
+    };
+    const producerSample = {
+      id: producer.id,
+      createdAt: Date.now(),
+      kind: producer.kind,
+      codecInfo,
+      ssrcs: producer.rtpParameters.encodings?.map((encoding) => encoding.ssrc).filter((ssrc) => typeof ssrc === "number"),
+      rids: producer.rtpParameters.encodings?.map((encoding) => encoding.rid).filter((rid) => typeof rid === "string"),
+      history: [],
+      transportId: transport.id
+    };
+    this.sample.producers.push(producerSample);
+    const onPause = () => {
+      producerSample.history.push({
+        type: "pause",
+        timestamp: Date.now()
+      });
+    };
+    const onResume = () => {
+      producerSample.history.push({
+        type: "resume",
+        timestamp: Date.now()
+      });
+    };
+    producer.observer.once("close", () => {
+      producer.observer.off("pause", onPause);
+      producer.observer.off("resume", onResume);
+      producerSample.closedAt = Date.now();
+    });
+    producer.observer.on("pause", onPause);
+    producer.observer.on("resume", onResume);
+  }
+  addConsumer(transport, consumer) {
+    const consumerSample = {
+      id: consumer.id,
+      producerId: consumer.producerId,
+      transportId: transport.id,
+      createdAt: Date.now(),
+      kind: consumer.kind,
+      history: []
+    };
+    this.sample.consumers.push(consumerSample);
+    const onPause = () => {
+      consumerSample.history.push({
+        type: "pause",
+        timestamp: Date.now()
+      });
+    };
+    const onResume = () => {
+      consumerSample.history.push({
+        type: "resume",
+        timestamp: Date.now()
+      });
+    };
+    const onProducerPause = () => {
+      consumerSample.history.push({
+        type: "producerPaused",
+        timestamp: Date.now()
+      });
+    };
+    const onProducerResume = () => {
+      consumerSample.history.push({
+        type: "producerResumed",
+        timestamp: Date.now()
+      });
+    };
+    consumer.observer.once("close", () => {
+      consumer.observer.off("pause", onPause);
+      consumer.observer.off("resume", onResume);
+      consumer.off("producerresume", onProducerResume);
+      consumer.off("producerpause", onProducerPause);
+      consumerSample.closedAt = Date.now();
+    });
+    consumer.observer.on("pause", onPause);
+    consumer.observer.on("resume", onResume);
+    consumer.on("producerpause", onProducerPause);
+    consumer.on("producerresume", onProducerResume);
+  }
+  addDataProducer(transport, dataProducer) {
+    const dataProducerSample = {
+      id: dataProducer.id,
+      transportId: transport.id,
+      createdAt: Date.now(),
+      label: dataProducer.label,
+      protocol: dataProducer.protocol
+    };
+    this.sample.dataProducers.push(dataProducerSample);
+    dataProducer.observer.once("close", () => {
+      dataProducerSample.closedAt = Date.now();
+    });
+  }
+  addDataConsumer(transport, dataConsumer) {
+    const dataConsumerSample = {
+      id: dataConsumer.id,
+      dataProducerId: dataConsumer.dataProducerId,
+      transportId: transport.id,
+      createdAt: Date.now(),
+      label: dataConsumer.label,
+      protocol: dataConsumer.protocol
+    };
+    this.sample.dataConsumers.push(dataConsumerSample);
+    dataConsumer.observer.once("close", () => {
+      dataConsumerSample.closedAt = Date.now();
+    });
+  }
+  close() {
+    if (this.closed) return;
+    this.closed = true;
+    this.emit("close");
+  }
+  attachRouterListeners() {
+    this.router.observer.once("close", () => {
+      this.router.observer.off("newtransport", this.addTransport);
+      this.sample.closedAt = Date.now();
+      this.close();
+    });
+    this.router.observer.on("newtransport", this.addTransport);
+  }
+  _attachTransportObserverListeners(transport, transportSample, onClose) {
+    const onNewProducer = (producer) => {
+      this.addProducer(transport, producer);
+    };
+    const onNewConsumer = (consumer) => {
+      this.addConsumer(transport, consumer);
+    };
+    const onNewDataProducer = (dataProducer) => {
+      this.addDataProducer(transport, dataProducer);
+    };
+    const onNewDataConsumer = (dataConsumer) => {
+      this.addDataConsumer(transport, dataConsumer);
+    };
+    transport.observer.once("close", () => {
+      transport.observer.off("newproducer", onNewProducer);
+      transport.observer.off("newconsumer", onNewConsumer);
+      transport.observer.off("newdataproducer", onNewDataProducer);
+      transport.observer.off("newdataconsumer", onNewDataConsumer);
+      onClose?.();
+      transportSample.closedAt = Date.now();
+    });
+    transport.observer.on("newproducer", onNewProducer);
+    transport.observer.on("newconsumer", onNewConsumer);
+    transport.observer.on("newdataproducer", onNewDataProducer);
+    transport.observer.on("newdataconsumer", onNewDataConsumer);
+  }
+};
+
+// src/Observer.ts
+var logger7 = createLogger("Observer");
+var Observer = class extends EventEmitter6 {
+  constructor(config = {
+    updatePolicy: "update-when-all-call-updated",
+    appData: {}
+  }) {
+    super();
+    this.config = config;
+    this.setMaxListeners(Infinity);
+    this.update = this.update.bind(this);
+    const currentUpdatePolicy = config?.updatePolicy ?? "update-when-all-call-updated";
+    switch (currentUpdatePolicy) {
+      case "update-on-any-call-updated":
+        this.updater = new OnAnyCallObserverUpdater(this);
+        break;
+      case "update-when-all-call-updated":
+        this.updater = new OnAllCallObserverUpdater(this);
+        break;
+      case "none":
+        break;
+    }
+  }
+  config;
+  observedTURN = new ObservedTURN();
+  observedCalls = /* @__PURE__ */ new Map();
+  observedMediasoupRouters = /* @__PURE__ */ new Map();
+  updater;
+  /** Ancestry base shared by all Observer-bus events originating at the observer. */
+  eventScope = { observer: this };
+  closed = false;
+  totalAddedCall = 0;
+  totalRemovedCall = 0;
+  numberOfClientsUsingTurn = 0;
+  numberOfClients = 0;
+  numberOfInboundRtpStreams = 0;
+  numberOfOutboundRtpStreams = 0;
+  numberOfDataChannels = 0;
+  numberOfPeerConnections = 0;
+  /** Global, pre-dispatch middleware chain run on every accepted sample. */
+  acceptMiddlewares = new MiddlewareProcessor();
+  get numberOfCalls() {
+    return this.observedCalls.size;
+  }
+  get appData() {
+    return this.config.appData;
+  }
+  getObservedCall(callId) {
+    if (this.closed || !this.observedCalls.has(callId)) return;
+    return this.observedCalls.get(callId);
+  }
+  createObservedCall(settings) {
+    if (this.closed) {
+      logger7.warn("Attempted to create a call (callId: %s) on a closed observer", settings.callId);
+      return void 0;
+    }
+    if (this.observedCalls.has(settings.callId)) {
+      logger7.warn("Observed Call with id %s already exists; returning the existing instance", settings.callId);
+      return this.observedCalls.get(settings.callId);
+    }
+    const callSettings = {
+      ...settings,
+      updatePolicy: settings.updatePolicy ?? this.config.defaultCallUpdatePolicy,
+      closeCallIfEmptyForMs: settings.closeCallIfEmptyForMs ?? this.config.closeCallIfEmptyForMs,
+      appData: settings.appData ?? this.config.createCallAppData?.({ callId: settings.callId, observer: this })
+    };
+    const observedCall = new ObservedCall(callSettings, this);
+    observedCall.remoteTrackResolver = this.config.createTrackResolver?.(observedCall);
+    observedCall.once("close", () => {
+      this.observedCalls.delete(observedCall.callId);
+      ++this.totalRemovedCall;
+    });
+    this.observedCalls.set(observedCall.callId, observedCall);
+    ++this.totalAddedCall;
+    this._notify("call-added", { ...this.eventScope, observedCall });
+    return observedCall;
+  }
+  getOrCreateObservedCall(settings) {
+    return this.getObservedCall(settings.callId) ?? this.createObservedCall(settings);
+  }
+  createObservedMediasoupRouter(settings) {
+    if (this.closed) {
+      logger7.warn("Attempted to create mediasoup router (id: %d) on a closed observer", settings.router.id);
+      return void 0;
+    }
+    if (this.observedMediasoupRouters.has(settings.router.id)) {
+      logger7.warn("Observed Mediasoup Router (id %s) already exists; returning the existing instance", settings.router.id);
+      return this.observedMediasoupRouters.get(settings.router.id);
+    }
+    const observedMediasoupRouter = new ObservedMediasoupRouter(settings);
+    const observedMediasoupRouterScope = {
+      observedMediasoupRouter,
+      observer: this
+    };
+    const onPeerConnectionAdded = (observedPeerConnectionScope) => {
+      if (!observedMediasoupRouter.webrtcTransportIds.has(observedPeerConnectionScope.observedPeerConnection.peerConnectionId)) return;
+      this.emit("mediasoup-router-matched-with-peer-connection", {
+        ...observedMediasoupRouterScope,
+        ...observedPeerConnectionScope
+      });
+    };
+    const stopMatching = () => this.off("peer-connection-added", onPeerConnectionAdded);
+    this.on("peer-connection-added", onPeerConnectionAdded);
+    this.once("observer-closed", stopMatching);
+    observedMediasoupRouter.once("close", stopMatching);
+    observedMediasoupRouter.once("close", () => {
+      this.observedMediasoupRouters.delete(observedMediasoupRouter.id);
+      this.emit("mediasoup-router-removed", observedMediasoupRouterScope);
+    });
+    this.observedMediasoupRouters.set(observedMediasoupRouter.id, observedMediasoupRouter);
+    this.emit("mediasoup-router-added", observedMediasoupRouterScope);
+    return observedMediasoupRouter;
+  }
+  close() {
+    if (this.closed) {
+      return logger7.debug("Attempted to close twice");
+    }
+    this.closed = true;
+    this.observedCalls.forEach((call) => call.close());
+    this._notify("observer-closed", { ...this.eventScope });
+  }
+  accept(sample, context) {
+    if (this.closed) {
+      return this._notify("sample-rejected", { ...this.eventScope, reason: "observer-closed", sample });
+    }
+    try {
+      this.acceptMiddlewares.process({ sample, context });
+    } catch (err) {
+      logger7.warn("An accept middleware threw; dropping the sample. %o", err);
+    }
+    if (!sample.callId) {
+      this._notify("sample-rejected", { ...this.eventScope, reason: "missing-callId", sample });
+      return;
+    }
+    if (!sample.clientId) {
+      this._notify("sample-rejected", { ...this.eventScope, reason: "missing-clientId", sample });
+      return;
+    }
+    let call = this.getObservedCall(sample.callId);
+    if (!call) {
+      call = this.createObservedCall({
+        callId: sample.callId,
+        appData: this.config.createCallAppData?.({ callId: sample.callId, observer: this })
+      });
+    }
+    if (!call) return;
+    let client = call.getObservedClient(sample.clientId);
+    if (!client) {
+      client = call.createObservedClient({
+        clientId: sample.clientId,
+        appData: this.config.createClientAppData?.({ clientId: sample.clientId, observedCall: call })
+      });
+    }
+    if (!client) return;
+    client.accept(sample, context);
+  }
+  update() {
+    if (this.closed) {
+      return;
+    }
+    this.numberOfInboundRtpStreams = 0;
+    this.numberOfOutboundRtpStreams = 0;
+    this.numberOfPeerConnections = 0;
+    this.numberOfDataChannels = 0;
+    this.numberOfClients = 0;
+    this.numberOfClientsUsingTurn = 0;
+    for (const call of this.observedCalls.values()) {
+      this.numberOfInboundRtpStreams += call.numberOfInboundRtpStreams;
+      this.numberOfOutboundRtpStreams += call.numberOfOutboundRtpStreams;
+      this.numberOfPeerConnections += call.numberOfPeerConnections;
+      this.numberOfDataChannels += call.numberOfDataChannels;
+      this.numberOfClients += call.numberOfClients;
+      this.numberOfClientsUsingTurn += call.clientsUsedTurn.size;
+    }
+    this.observedTURN.update();
+    this._notify("observer-updated", { ...this.eventScope });
+  }
+  /** Emit an Observer-bus event. */
+  _notify(type, ...args) {
+    this.emit(type, ...args);
+  }
+};
+
+// src/sinks/ClientSampleSink.ts
+import { EventEmitter as EventEmitter7 } from "events";
+var ClientSampleSink = class extends EventEmitter7 {
+};
+
+// src/sinks/JsonlFileSink.ts
+import * as fs from "fs";
+import * as path from "path";
+var JsonlFileSink = class extends ClientSampleSink {
+  /** The file this sink writes to. Read it (e.g. in a `close` handler) to upload/move the file. */
+  path;
+  _stream;
+  _serializeSample;
+  constructor(options) {
+    super();
+    this.path = options.path;
+    this._stream = fs.createWriteStream(this.path, { flags: "a" });
+    this._stream.on("close", () => this.emit("close"));
+    this._stream.on("finish", () => this.emit("finish"));
+    this._stream.on("drain", () => this.emit("drain"));
+    this._stream.on("error", (err) => this.emit("error", err));
+    this._serializeSample = options.serializeSample ?? ((sample) => JSON.stringify(sample));
+  }
+  write(sample) {
+    return this._stream.write(`${this._serializeSample(sample)}
+`);
+  }
+  end() {
+    this._stream.end();
+  }
+};
+function createJsonlFileSink(options) {
+  return new JsonlFileSink(options);
+}
+function createJsonlFileSinkFactory(options) {
+  return ({ clientId, observedCall }) => {
+    const filename = options.getFileName?.({ callId: observedCall.callId, clientId }) ?? `${observedCall.callId}__${clientId}.jsonl`;
+    return createJsonlFileSink({
+      path: path.join(options.directory, filename),
+      serializeSample: options.serializeSample
+    });
+  };
+}
+
+// src/sinks/InMemorySink.ts
+var InMemorySink = class extends ClientSampleSink {
+  constructor(samples = []) {
+    super();
+    this.samples = samples;
+  }
+  samples;
+  write(sample) {
+    this.samples.push(sample);
+    return true;
+  }
+  end() {
+    this.emit("close");
+  }
+};
+function createInMemorySink(samples) {
+  return new InMemorySink(samples);
+}
+
+// src/utils/RemoteTrackResolver.ts
+var RemoteTrackResolver = class {
+  constructor(observedCall, resolvers) {
+    this.observedCall = observedCall;
+    this.resolvers = resolvers;
+    const observer = observedCall.observer;
+    const onInboundAdded = (p) => {
+      if (p.observedCall === this.observedCall) this._addInboundTrack(p.observedInboundTrack);
+    };
+    const onInboundRemoved = (p) => {
+      if (p.observedCall === this.observedCall) this._removeInboundTrack(p.observedInboundTrack);
+    };
+    const onOutboundAdded = (p) => {
+      if (p.observedCall === this.observedCall) this._addOutboundTrack(p.observedOutboundTrack);
+    };
+    const onOutboundRemoved = (p) => {
+      if (p.observedCall === this.observedCall) this._removeOutboundTrack(p.observedOutboundTrack);
+    };
+    observedCall.once("close", () => {
+      observer.off("inbound-track-added", onInboundAdded);
+      observer.off("inbound-track-removed", onInboundRemoved);
+      observer.off("outbound-track-added", onOutboundAdded);
+      observer.off("outbound-track-removed", onOutboundRemoved);
+    });
+    observer.on("inbound-track-added", onInboundAdded);
+    observer.on("inbound-track-removed", onInboundRemoved);
+    observer.on("outbound-track-added", onOutboundAdded);
+    observer.on("outbound-track-removed", onOutboundRemoved);
+  }
+  observedCall;
+  resolvers;
+  _publisherIdToOutboundTrack = /* @__PURE__ */ new Map();
+  _subscriberIdToInboundTrack = /* @__PURE__ */ new Map();
+  /** The published (outbound) track for a publisher id, if any. */
+  getOutboundTrackByPublisherId(publisherId) {
+    return this._publisherIdToOutboundTrack.get(publisherId);
+  }
+  /** The subscribed (inbound) track for a subscriber id, if the strategy resolves subscriber ids. */
+  getInboundTrackBySubscriberId(subscriberId) {
+    return this._subscriberIdToInboundTrack.get(subscriberId);
+  }
+  // RemoteTrackResolver interface — thin readers over the links maintained on the tracks.
+  resolveRemoteOutboundTrack(inboundTrack) {
+    return inboundTrack.remoteOutboundTrack;
+  }
+  resolveRemoteInboundTracks(outboundTrack) {
+    return [...outboundTrack.remoteInboundTracks];
+  }
+  _addInboundTrack(inboundTrack) {
+    const publisherId = this.resolvers.resolveInboundTrackPublisherId(inboundTrack);
+    if (!publisherId) return;
+    const subscriberId = this.resolvers.resolveInboundTrackSubscriberId?.(inboundTrack);
+    if (subscriberId) {
+      this._subscriberIdToInboundTrack.set(subscriberId, inboundTrack);
+    }
+    const outboundTrack = this._publisherIdToOutboundTrack.get(publisherId);
+    if (!outboundTrack) return;
+    outboundTrack.remoteInboundTracks.add(inboundTrack);
+    inboundTrack.remoteOutboundTrack = outboundTrack;
+  }
+  _removeInboundTrack(inboundTrack) {
+    inboundTrack.remoteOutboundTrack?.remoteInboundTracks.delete(inboundTrack);
+    inboundTrack.remoteOutboundTrack = void 0;
+    const subscriberId = this.resolvers.resolveInboundTrackSubscriberId?.(inboundTrack);
+    if (subscriberId) {
+      this._subscriberIdToInboundTrack.delete(subscriberId);
+    }
+  }
+  _addOutboundTrack(outboundTrack) {
+    const publisherId = this.resolvers.resolveOutboundTrackPublisherId(outboundTrack);
+    if (!publisherId) return;
+    this._publisherIdToOutboundTrack.set(publisherId, outboundTrack);
+    for (const observedClient of this.observedCall.observedClients.values()) {
+      for (const observedPeerConnection of observedClient.observedPeerConnections.values()) {
+        for (const inboundTrack of observedPeerConnection.observedInboundTracks.values()) {
+          if (this.resolvers.resolveInboundTrackPublisherId(inboundTrack) !== publisherId) continue;
+          outboundTrack.remoteInboundTracks.add(inboundTrack);
+          inboundTrack.remoteOutboundTrack = outboundTrack;
+        }
+      }
+    }
+  }
+  _removeOutboundTrack(outboundTrack) {
+    const publisherId = this.resolvers.resolveOutboundTrackPublisherId(outboundTrack);
+    if (publisherId && this._publisherIdToOutboundTrack.get(publisherId) === outboundTrack) {
+      this._publisherIdToOutboundTrack.delete(publisherId);
+    }
+    for (const inboundTrack of outboundTrack.remoteInboundTracks) {
+      inboundTrack.remoteOutboundTrack = void 0;
+    }
+    outboundTrack.remoteInboundTracks.clear();
+  }
+};
+
+// src/utils/RemoteTrackResolverFactories.ts
+function createDefaultMediasoupRemoteTrackResolverFactory() {
+  return (observedCall) => new RemoteTrackResolver(observedCall, {
+    resolveInboundTrackPublisherId: (inboundTrack) => inboundTrack.attachments?.producerId,
+    resolveInboundTrackSubscriberId: (inboundTrack) => inboundTrack.attachments?.consumerId,
+    resolveOutboundTrackPublisherId: (outboundTrack) => outboundTrack.attachments?.producerId
+  });
+}
+function createP2pRemoteTrackResolverFactory() {
+  return (observedCall) => new RemoteTrackResolver(observedCall, {
+    resolveInboundTrackPublisherId: (inboundTrack) => {
+      const ssrc = inboundTrack.getInboundRtp()?.ssrc;
+      return ssrc ? `${ssrc}` : void 0;
+    },
+    resolveInboundTrackSubscriberId: (inboundTrack) => {
+      const ssrc = inboundTrack.getInboundRtp()?.ssrc;
+      return ssrc ? `${ssrc}` : void 0;
+    },
+    resolveOutboundTrackPublisherId: (outboundTrack) => {
+      const rtps = outboundTrack.getOutboundRtps();
+      if (!rtps || rtps.length === 0) return void 0;
+      return rtps.map((rtp) => rtp.ssrc).join(",");
+    }
+  });
+}
+export {
+  ClientEventTypes,
+  ClientMetaTypes,
+  ClientSampleSink,
+  Detectors,
+  InMemorySink,
+  JsonlFileSink,
+  ObservedCall,
+  ObservedCertificate,
+  ObservedClient,
+  ObservedCodec,
+  ObservedDataChannel,
+  ObservedIceCandidate,
+  ObservedIceCandidatePair,
+  ObservedIceTransport,
+  ObservedInboundRtp,
+  ObservedInboundTrack,
+  ObservedMediaPlayout,
+  ObservedMediaSource,
+  ObservedMediasoupRouter,
+  ObservedOutboundRtp,
+  ObservedOutboundTrack,
+  ObservedPeerConnection,
+  ObservedPeerConnectionTransport,
+  ObservedRemoteInboundRtp,
+  ObservedRemoteOutboundRtp,
+  Observer,
+  RemoteTrackResolver,
+  createDefaultMediasoupRemoteTrackResolverFactory,
+  createInMemorySink,
+  createJsonlFileSink,
+  createJsonlFileSinkFactory,
+  createLogger,
+  createP2pRemoteTrackResolverFactory,
+  setObserverLogger
+};
+//# sourceMappingURL=index.mjs.map