@observertc/observer-js 1.0.0-beta.5 → 1.0.0-beta.7

package/dist/index.js

@@ -55,10 +55,13 @@ __export(src_exports, {
   ObservedRemoteInboundRtp: () => ObservedRemoteInboundRtp,
   ObservedRemoteOutboundRtp: () => ObservedRemoteOutboundRtp,
   Observer: () => Observer,
+  RemoteTrackResolver: () => RemoteTrackResolver,
+  createDefaultMediasoupRemoteTrackResolverFactory: () => createDefaultMediasoupRemoteTrackResolverFactory,
   createInMemorySink: () => createInMemorySink,
   createJsonlFileSink: () => createJsonlFileSink,
   createJsonlFileSinkFactory: () => createJsonlFileSinkFactory,
   createLogger: () => createLogger,
+  createP2pRemoteTrackResolverFactory: () => createP2pRemoteTrackResolverFactory,
   setObserverLogger: () => setObserverLogger
 });
 module.exports = __toCommonJS(src_exports);
@@ -1128,20 +1131,6 @@ var ObservedInboundTrack = class {
     this._peerConnection = _peerConnection;
     this._inboundRtp = _inboundRtp;
     this._mediaPlayout = _mediaPlayout;
-    this.report = {
-      trackId: this.id,
-      kind: this.kind,
-      fractionLostDistribution: {
-        gtOrEq050: 0,
-        lt001: 0,
-        lt005: 0,
-        lt010: 0,
-        lt020: 0,
-        lt050: 0,
-        count: 0,
-        sum: 0
-      }
-    };
   }
   timestamp;
   id;
@@ -1154,7 +1143,7 @@ var ObservedInboundTrack = class {
     value: void 0
   };
   appData;
-  report;
+  remoteOutboundTrack;
   _visited = false;
   addedAt;
   removedAt;
@@ -1177,25 +1166,11 @@ var ObservedInboundTrack = class {
   getMediaPlayout() {
     return this._mediaPlayout;
   }
-  getRemoteOutboundTrack() {
-    return this._peerConnection.client.call.remoteTrackResolver?.resolveRemoteOutboundTrack(this);
-  }
   update(stats) {
     this._visited = true;
     this.timestamp = stats.timestamp;
     this.calculatedScore.value = stats.score;
     this.attachments = stats.attachments;
-    const fl = this._inboundRtp?.fractionLost;
-    if (fl !== void 0) {
-      if (fl < 0.01) this.report.fractionLostDistribution.lt001 += 1;
-      else if (fl < 0.05) this.report.fractionLostDistribution.lt005 += 1;
-      else if (fl < 0.1) this.report.fractionLostDistribution.lt010 += 1;
-      else if (fl < 0.2) this.report.fractionLostDistribution.lt020 += 1;
-      else if (fl < 0.5) this.report.fractionLostDistribution.lt050 += 1;
-      else this.report.fractionLostDistribution.gtOrEq050 += 1;
-      this.report.fractionLostDistribution.count += 1;
-      this.report.fractionLostDistribution.sum += fl;
-    }
   }
 };
 
@@ -1208,10 +1183,6 @@ var ObservedOutboundTrack = class {
     this._peerConnection = _peerConnection;
     this._outboundRtps = _outboundRtps;
     this._mediaSource = _mediaSource;
-    this.report = {
-      trackId: this.id,
-      kind: this.kind
-    };
   }
   timestamp;
   id;
@@ -1221,7 +1192,7 @@ var ObservedOutboundTrack = class {
   _mediaSource;
   _visited = false;
   appData;
-  report;
+  remoteInboundTracks = /* @__PURE__ */ new Set();
   calculatedScore = {
     weight: 1,
     value: void 0
@@ -1247,9 +1218,6 @@ var ObservedOutboundTrack = class {
   getMediaSource() {
     return this._mediaSource;
   }
-  getRemoteInboundTracks() {
-    return this._peerConnection.client.call.remoteTrackResolver?.resolveRemoteInboundTracks(this);
-  }
   update(stats) {
     this._visited = true;
     this.timestamp = stats.timestamp;
@@ -2209,43 +2177,6 @@ var ObservedClient = class extends import_events2.EventEmitter {
     this.settings = {
       closeClientIfIdleForMs: settings.closeClientIfIdleForMs
     };
-    this.report = {
-      callId: this.call.callId,
-      clientId: this.clientId,
-      rttDistribution: {
-        gtOrEq300ms: 0,
-        lt50ms: 0,
-        lt150ms: 0,
-        lt300ms: 0,
-        count: 0,
-        sum: 0
-      },
-      scoreDistribution: {
-        "0": 0,
-        "1": 0,
-        "2": 0,
-        "3": 0,
-        "4": 0,
-        "5": 0,
-        count: 0,
-        sum: 0
-      },
-      issues: {},
-      totalAudioBytesReceived: 0,
-      totalVideoBytesReceived: 0,
-      totalAudioBytesSent: 0,
-      totalVideoBytesSent: 0,
-      totalDataChannelBytesReceived: 0,
-      totalDataChannelBytesSent: 0,
-      totalDataChannelMessagesReceived: 0,
-      totalDataChannelMessagesSent: 0,
-      totalInboundRtpBytesReceived: 0,
-      totalInboundRtpPacketsLost: 0,
-      totalInboundRtpPacketsReceived: 0,
-      totalOutboundRtpBytesSent: 0,
-      totalOutboundRtpPacketsSent: 0,
-      totalNumberOfIssues: 0
-    };
     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));
@@ -2316,7 +2247,6 @@ var ObservedClient = class extends import_events2.EventEmitter {
   totalScoreSum = 0;
   numberOfScoreMeasurements = 0;
   // public totalNumberOfIssues = 0;
-  report;
   mediaDevices = [];
   issues = [];
   _injections = {};
@@ -2449,19 +2379,13 @@ var ObservedClient = class extends import_events2.EventEmitter {
         }
         if (observedPeerConnection.currentRttInMs < 50) {
           this.deltaRttLt50Measurements += 1;
-          this.report.rttDistribution.lt50ms += 1;
         } else if (observedPeerConnection.currentRttInMs < 150) {
           this.deltaRttLt150Measurements += 1;
-          this.report.rttDistribution.lt150ms += 1;
         } else if (observedPeerConnection.currentRttInMs < 300) {
           this.deltaRttLt300Measurements += 1;
-          this.report.rttDistribution.lt300ms += 1;
         } else if (300 <= observedPeerConnection.currentRttInMs) {
           this.deltaRttGtOrEq300Measurements += 1;
-          this.report.rttDistribution.gtOrEq300ms += 1;
         }
-        this.report.rttDistribution.count += 1;
-        this.report.rttDistribution.sum += observedPeerConnection.currentRttInMs;
         sumOfRtts += observedPeerConnection.currentRttInMs;
         ++numberOfRttMeasurements;
       }
@@ -2470,32 +2394,12 @@ var ObservedClient = class extends import_events2.EventEmitter {
       this._processClientEvent(clientEvent);
     }
     this.attachments = sample.attachments;
-    this.report.totalDataChannelBytesReceived += this.deltaDataChannelBytesReceived;
-    this.report.totalDataChannelBytesSent += this.deltaDataChannelBytesSent;
-    this.report.totalDataChannelMessagesReceived += this.deltaDataChannelMessagesReceived;
-    this.report.totalDataChannelMessagesSent += this.deltaDataChannelMessagesSent;
-    this.report.totalInboundRtpPacketsLost += this.deltaInboundPacketsLost;
-    this.report.totalInboundRtpPacketsReceived += this.deltaInboundPacketsReceived;
-    this.report.totalOutboundRtpPacketsSent += this.deltaOutboundPacketsSent;
-    this.report.totalAudioBytesReceived += this.deltaReceivedAudioBytes;
-    this.report.totalVideoBytesReceived += this.deltaReceivedVideoBytes;
-    this.report.totalAudioBytesSent += this.deltaSentAudioBytes;
-    this.report.totalVideoBytesSent += this.deltaSentVideoBytes;
-    this.report.totalInboundRtpBytesReceived += this.deltaTransportReceivedBytes;
-    this.report.totalOutboundRtpBytesSent += this.deltaTransportSentBytes;
-    this.report.totalNumberOfIssues += this.deltaNumberOfIssues;
     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;
-    if (sample.score !== void 0) {
-      const bucket = Math.floor(sample.score).toString();
-      this.report.scoreDistribution[bucket] = (this.report.scoreDistribution[bucket] ?? 0) + 1;
-      this.report.scoreDistribution.count += 1;
-      this.report.scoreDistribution.sum += sample.score;
-    }
     this.lastSampleTimestamp = sample.timestamp;
     const elapsedTimeInMs = now - this.updated;
     this.emit("update", sample, elapsedTimeInMs, context);
@@ -2560,7 +2464,6 @@ var ObservedClient = class extends import_events2.EventEmitter {
   }
   addIssue(issue) {
     if (this.closed) return;
-    this.report.issues[issue.type] = (this.report.issues[issue.type] ?? 0) + 1;
     this._notify("client-issue", { ...this.eventScope, issue });
   }
   addExtensionStats(stats) {
@@ -2787,31 +2690,9 @@ var ObservedClient = class extends import_events2.EventEmitter {
         ), void 0;
       }
       const newObservedPeerConnection = new ObservedPeerConnection(sample.peerConnectionId, this);
-      const onInboundTrackRemoved = (track) => {
-        this._notify("client-track-report", {
-          ...this.eventScope,
-          report: {
-            direction: "inbound",
-            ...track.report
-          }
-        });
-      };
-      const onOutboundTrackRemoved = (track) => {
-        this._notify("client-track-report", {
-          ...this.eventScope,
-          report: {
-            direction: "outbound",
-            ...track.report
-          }
-        });
-      };
       newObservedPeerConnection.once("close", () => {
-        newObservedPeerConnection?.off("removed-inbound-track", onInboundTrackRemoved);
-        newObservedPeerConnection?.off("removed-outbound-track", onOutboundTrackRemoved);
         this.observedPeerConnections.delete(sample.peerConnectionId);
       });
-      newObservedPeerConnection.on("removed-inbound-track", onInboundTrackRemoved);
-      newObservedPeerConnection.on("removed-outbound-track", onOutboundTrackRemoved);
       this.observedPeerConnections.set(sample.peerConnectionId, newObservedPeerConnection);
       this._notify("peer-connection-added", { ...this.eventScope, observedPeerConnection: newObservedPeerConnection });
       observedPeerConnection = newObservedPeerConnection;
@@ -2918,21 +2799,6 @@ var OnAllClientCallUpdater = class {
   }
 };
 
-// src/updaters/OnIntervalUpdater.ts
-var OnIntervalUpdater = class {
-  constructor(intervalInMs, _update) {
-    this._update = _update;
-    this.timer = setInterval(() => this._update(), intervalInMs);
-  }
-  _update;
-  name = "OnIntervalUpdater";
-  description = "Call the update() method given in the constructor once the interval elapsed";
-  timer;
-  close() {
-    clearInterval(this.timer);
-  }
-};
-
 // src/updaters/OnAnyClientCallUpdater.ts
 var OnAnyClientCallUpdater = class {
   constructor(_observedCall) {
@@ -3006,9 +2872,6 @@ var ObservedCall = class extends import_events3.EventEmitter {
     this.appData = settings.appData ?? {};
     this.scoreCalculator = new DefaultCallScoreCalculator(this);
     this.detectors = new Detectors();
-    if (settings.updateIntervalInMs && settings.updatePolicy !== "update-on-interval") {
-      logger4.warn('updateIntervalInMs is ignored unless updatePolicy is "update-on-interval" (callId: %s)', settings.callId);
-    }
     switch (settings.updatePolicy) {
       case "update-on-any-client-updated":
         this.updater = new OnAnyClientCallUpdater(this);
@@ -3016,17 +2879,6 @@ var ObservedCall = class extends import_events3.EventEmitter {
       case "update-when-all-client-updated":
         this.updater = new OnAllClientCallUpdater(this);
         break;
-      case "update-on-interval":
-        if (!settings.updateIntervalInMs) {
-          logger4.warn('updateIntervalInMs must be set when updatePolicy is "update-on-interval"; falling back to "update-when-all-client-updated" (callId: %s)', settings.callId);
-          this.updater = new OnAllClientCallUpdater(this);
-        } else {
-          this.updater = new OnIntervalUpdater(
-            settings.updateIntervalInMs,
-            this.update.bind(this)
-          );
-        }
-        break;
     }
     this.settings = {
       closeCallIfEmptyForMs: settings.closeCallIfEmptyForMs
@@ -3388,122 +3240,60 @@ var OnAnyCallObserverUpdater = class {
   }
 };
 
-// src/utils/MediasoupRemoteTrackResolver.ts
-var MediasoupRemoteTrackResolver = class {
-  constructor(observedCall) {
-    this.observedCall = observedCall;
-    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);
-    };
-    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.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);
-    });
-  }
-  observedCall;
-  _consumerIdToProducerId = /* @__PURE__ */ new Map();
-  _producerIdToOutboundTrack = /* @__PURE__ */ new Map();
-  _consumerIdToInboundTrack = /* @__PURE__ */ new Map();
-  // private _producerIdToOutboundTrack = new Map<string, ObservedOutboundTrack>();
-  _inboundTrackToConsumerId = /* @__PURE__ */ new Map();
-  _producerIdToConsumerIds = /* @__PURE__ */ new Map();
-  _outboundTrackToProducerId = /* @__PURE__ */ new Map();
-  resolveRemoteOutboundTrack(inboundTrack) {
-    const consumerId = this._inboundTrackToConsumerId.get(inboundTrack.id);
-    if (!consumerId) return;
-    const producerId = this._consumerIdToProducerId.get(consumerId);
-    if (!producerId) return;
-    return this._producerIdToOutboundTrack.get(producerId);
+// 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);
   }
-  resolveRemoteInboundTracks(outboundTrack) {
-    const producerId = this._outboundTrackToProducerId.get(outboundTrack.id);
-    if (!producerId) return;
-    const consumerIds = this._producerIdToConsumerIds.get(producerId);
-    if (!consumerIds) return;
-    return consumerIds.map((consumerId) => this._consumerIdToInboundTrack.get(consumerId)).filter((inboundTrack) => Boolean(inboundTrack));
-  }
-  _addInboundTrack(inboundTrack) {
-    const attachments = this._getInboundTrackAttachments(inboundTrack);
-    if (!attachments) return;
-    const {
-      producerId,
-      consumerId
-    } = attachments;
-    this._inboundTrackToConsumerId.set(inboundTrack.id, consumerId);
-    this._consumerIdToProducerId.set(consumerId, producerId);
-    this._consumerIdToInboundTrack.set(consumerId, inboundTrack);
-    let producerConsumers = this._producerIdToConsumerIds.get(producerId);
-    if (!producerConsumers) {
-      producerConsumers = [];
-      this._producerIdToConsumerIds.set(producerId, producerConsumers);
-    }
-    producerConsumers.push(consumerId);
-  }
-  _removeInboundTrack(inboundTrack) {
-    const consumerId = this._inboundTrackToConsumerId.get(inboundTrack.id);
-    if (!consumerId) return;
-    this._inboundTrackToConsumerId.delete(inboundTrack.id);
-    this._consumerIdToProducerId.delete(consumerId);
-    this._consumerIdToInboundTrack.delete(consumerId);
-    const producerConsumers = this._producerIdToConsumerIds.get(consumerId);
-    if (!producerConsumers) return;
-    const filteredProducerConsumers = producerConsumers.filter((id) => id !== consumerId);
-    if (filteredProducerConsumers.length === 0) {
-      this._producerIdToConsumerIds.delete(consumerId);
-    } else {
-      this._producerIdToConsumerIds.set(consumerId, filteredProducerConsumers);
+};
+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;
   }
-  _addOutboundTrack(outboundTrack) {
-    const attachments = this._getOutboundTrackAttachments(outboundTrack);
-    if (!attachments) return;
-    const {
-      producerId
-    } = attachments;
-    this._producerIdToOutboundTrack.set(producerId, outboundTrack);
-    this._outboundTrackToProducerId.set(outboundTrack.id, producerId);
-  }
-  _removeOutboundTrack(outboundTrack) {
-    const producerId = this._outboundTrackToProducerId.get(outboundTrack.id);
-    if (!producerId) return;
-    this._producerIdToOutboundTrack.delete(producerId);
-    this._outboundTrackToProducerId.delete(outboundTrack.id);
-  }
-  _getInboundTrackAttachments(inboundTrack) {
-    const {
-      producerId,
-      consumerId
-    } = inboundTrack.attachments ?? {};
-    if (!producerId || !consumerId || typeof producerId !== "string" || typeof consumerId !== "string") return;
-    return {
-      producerId,
-      consumerId
-    };
-  }
-  _getOutboundTrackAttachments(outboundTrack) {
-    const {
-      producerId
-    } = outboundTrack.attachments ?? {};
-    if (!producerId || typeof producerId !== "string") return;
-    return {
-      producerId
-    };
+  process(value) {
+    if (this.stack.length === 0) {
+      return this.finalCallback?.(value);
+    }
+    const executor = new Executor(this.stack, this.finalCallback);
+    executor.execute(value);
   }
 };
 
@@ -3526,19 +3316,6 @@ var Observer = class extends import_events5.EventEmitter {
       case "update-when-all-call-updated":
         this.updater = new OnAllCallObserverUpdater(this);
         break;
-      case "update-on-interval": {
-        const interval = config?.updateIntervalInMs;
-        if (!interval) {
-          logger6.warn('updateIntervalInMs must be set when updatePolicy is "update-on-interval"; falling back to "update-when-all-call-updated"');
-          this.updater = new OnAllCallObserverUpdater(this);
-        } else {
-          this.updater = new OnIntervalUpdater(
-            interval,
-            this.update.bind(this)
-          );
-        }
-        break;
-      }
     }
   }
   config;
@@ -3556,7 +3333,8 @@ var Observer = class extends import_events5.EventEmitter {
   numberOfOutboundRtpStreams = 0;
   numberOfDataChannels = 0;
   numberOfPeerConnections = 0;
-  _timer;
+  /** Global, pre-dispatch middleware chain run on every accepted sample. */
+  acceptMiddlewares = new MiddlewareProcessor();
   get numberOfCalls() {
     return this.observedCalls.size;
   }
@@ -3579,14 +3357,11 @@ var Observer = class extends import_events5.EventEmitter {
     const callSettings = {
       ...settings,
       updatePolicy: settings.updatePolicy ?? this.config.defaultCallUpdatePolicy,
-      updateIntervalInMs: settings.updateIntervalInMs ?? this.config.defaultCallUpdateIntervalInMs,
       closeCallIfEmptyForMs: settings.closeCallIfEmptyForMs ?? this.config.closeCallIfEmptyForMs,
       appData: settings.appData ?? this.config.createCallAppData?.({ callId: settings.callId, observer: this })
     };
     const observedCall = new ObservedCall(callSettings, this);
-    if (callSettings.remoteTrackResolvePolicy === "mediasoup-sfu") {
-      observedCall.remoteTrackResolver = new MediasoupRemoteTrackResolver(observedCall);
-    }
+    observedCall.remoteTrackResolver = this.config.createTrackResolver?.(observedCall);
     observedCall.once("close", () => {
       this.observedCalls.delete(observedCall.callId);
       ++this.totalRemovedCall;
@@ -3604,15 +3379,17 @@ var Observer = class extends import_events5.EventEmitter {
       return logger6.debug("Attempted to close twice");
     }
     this.closed = true;
-    clearInterval(this._timer);
-    this._timer = void 0;
     this.observedCalls.forEach((call) => call.close());
     this._notify("observer-closed", { ...this.eventScope });
   }
   accept(sample, context) {
     if (this.closed) {
-      this._notify("sample-rejected", { ...this.eventScope, reason: "observer-closed", sample });
-      return;
+      return this._notify("sample-rejected", { ...this.eventScope, reason: "observer-closed", sample });
+    }
+    try {
+      this.acceptMiddlewares.process({ sample, context });
+    } catch (err) {
+      logger6.warn("An accept middleware threw; dropping the sample. %o", err);
     }
     if (!sample.callId) {
       this._notify("sample-rejected", { ...this.eventScope, reason: "missing-callId", sample });
@@ -3729,6 +3506,126 @@ var InMemorySink = class extends ClientSampleSink {
 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(",");
+    }
+  });
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ClientEventTypes,
@@ -3756,10 +3653,13 @@ function createInMemorySink(samples) {
   ObservedRemoteInboundRtp,
   ObservedRemoteOutboundRtp,
   Observer,
+  RemoteTrackResolver,
+  createDefaultMediasoupRemoteTrackResolverFactory,
   createInMemorySink,
   createJsonlFileSink,
   createJsonlFileSinkFactory,
   createLogger,
+  createP2pRemoteTrackResolverFactory,
   setObserverLogger
 });
 //# sourceMappingURL=index.js.map