@observertc/observer-js 1.0.0-beta.11 → 1.0.0-beta.12

package/README.md

@@ -245,8 +245,7 @@ observer.addAcceptMiddleware(route, filter);
 // observer.removeAcceptMiddleware(route);
 ```
 
-This is a lightweight global injection point, distinct from the larger (not-yet-built)
-`ClientSampleProcessor` pipeline in the roadmap. When no middleware is registered, `accept()`
+This is a lightweight global injection point. When no middleware is registered, `accept()`
 dispatches directly with no overhead.
 
 ### `context` (the `AcceptContext`)
@@ -409,7 +408,6 @@ See [Mediasoup router observation](#mediasoup-router-observation) for the full d
 | `peer-connection-added` / `peer-connection-closed` | — | lifecycle of the PC |
 | `peer-connection-updated` | `{ context?: AcceptContext }` | the PC processed a sample |
 | `ice-connection-state-changed` / `ice-gathering-state-changed` / `connection-state-changed` | `{ state: string }` | driven by client events |
-| `selected-candidate-pair-changed` | — | *declared; not currently emitted* |
 | `inbound-track-added` / `-updated` / `-removed` / `-muted` / `-unmuted` | `{ observedInboundTrack }` | |
 | `outbound-track-added` / `-updated` / `-removed` / `-muted` / `-unmuted` | `{ observedOutboundTrack }` | |
 | `inbound-rtp-added` / `-updated` / `-removed` | `{ observedInboundRtp }` | `-updated` fires every tick |
@@ -462,8 +460,8 @@ type ObserverConfig<AppData = Record<string, unknown>> = {
     createClientAppData?: (p: { clientId: string; observedCall: ObservedCall }) => Record<string, unknown>;
     // sink factory — produces a per-client sink that receives every accepted sample (see Sinks).
     createClientSink?: (p: { clientId: string; observedCall: ObservedCall }) => ClientSampleSink | undefined;
-    // track-resolver factory — produces a call's RemoteTrackResolver (see Remote track resolution).
-    createTrackResolver?: (observedCall: ObservedCall) => RemoteTrackResolver | undefined;
+    // remote-track-resolver factory — produces a call's RemoteTrackResolver (see Remote track resolution).
+    createRemoteTrackResolver?: (observedCall: ObservedCall) => RemoteTrackResolver | undefined;
   };
 ```
 
@@ -517,7 +515,7 @@ Key members:
 - `addIssue(issue: ClientIssue): void` — raise a **call-level** issue → emits `call-issue`
 - `readonly detectors: Detectors` — server-side detector registry (empty by default; see [Detectors](#detectors-server-side-extension-point))
 - `scoreCalculator: ScoreCalculator`, `get score()`, `readonly calculatedScore`
-- `remoteTrackResolver?: RemoteTrackResolver` — set from `ObserverConfig.createTrackResolver` at call creation (see [Remote track resolution](#remote-track-resolution-mediasoup--sfu))
+- `remoteTrackResolver?: RemoteTrackResolver` — set from `ObserverConfig.createRemoteTrackResolver` at call creation (see [Remote track resolution](#remote-track-resolution-mediasoup--sfu))
 - aggregates: `numberOfIssues`, `numberOfPeerConnections`, `numberOfInboundRtpStreams`,
   `numberOfOutboundRtpStreams`, `numberOfDataChannels`, `maxNumberOfClients`,
   `clientsUsedTurn: Set<string>`, `startedAt?`, `endedAt?`, `closedAt?`, `closed`
@@ -752,7 +750,7 @@ class Detectors {
 
 In an SFU, one participant's **outbound** track is delivered to other participants as **inbound**
 tracks (one **publisher** → many **subscribers**). Correlation is **opt-in** per observer: set
-`ObserverConfig.createTrackResolver`, a factory invoked when each call is created that returns the
+`ObserverConfig.createRemoteTrackResolver`, a factory invoked when each call is created that returns the
 call's `RemoteTrackResolver` (or `undefined` for none).
 
 `RemoteTrackResolver` is a generic, strategy-driven class. It subscribes to the bus (filtered to
@@ -763,7 +761,7 @@ the tracks: `inboundTrack.remoteOutboundTrack` and `outboundTrack.remoteInboundT
 import { Observer, createDefaultMediasoupRemoteTrackResolverFactory } from '@observertc/observer-js';
 
 const observer = new Observer({
-  createTrackResolver: createDefaultMediasoupRemoteTrackResolverFactory(),
+  createRemoteTrackResolver: createDefaultMediasoupRemoteTrackResolverFactory(),
 });
 
 // later, given tracks (links are kept up to date as tracks come and go):
@@ -782,7 +780,7 @@ id is just whatever links a subscribed track to the published one:
 import { Observer, RemoteTrackResolver } from '@observertc/observer-js';
 
 const observer = new Observer({
-  createTrackResolver: (observedCall) => new RemoteTrackResolver(observedCall, {
+  createRemoteTrackResolver: (observedCall) => new RemoteTrackResolver(observedCall, {
     resolveOutboundTrackPublisherId: (out) => out.attachments?.mediaId as string | undefined,
     resolveInboundTrackPublisherId:  (inb) => inb.attachments?.mediaId as string | undefined,
     resolveInboundTrackSubscriberId: (inb) => inb.attachments?.subId  as string | undefined, // optional
@@ -806,19 +804,37 @@ transitions. `ObservedMediasoupRouter` captures that server-side view into a
 ### The concept
 
 You hand the observer a live mediasoup `Router`; it attaches to mediasoup's own `observer` API and,
-from then on, **passively records** the router's topology and lifecycle — with no polling and no
+from then on, **passively tracks** the router's topology and lifecycle — with no polling and no
 changes to your media code:
 
-- new transports (`webrtc` / `plain` / `pipe` / `direct`), their selected `tuple`, and ICE state
-  transitions;
+- new transports (`webrtc` / `plain` / `pipe` / `direct`), their selected `tuple`, ICE/DTLS/SCTP
+  state transitions and `connectedAt`;
 - producers (codec, SSRCs/RIDs, `pause`/`resume`) and consumers (`pause`/`resume`,
   `producerPaused`/`producerResumed`);
 - data producers and data consumers;
 - `createdAt` / `closedAt` for every entity above.
 
-All of it accumulates on `observedMediasoupRouter.sample` (a `MediasoupRouterSample` — see
-[`src/schema/MediasoupRouter.ts`](./src/schema/MediasoupRouter.ts)). This is a *Sample*, not a
-*Report*: it mirrors the naming of `ClientSample` and is yours to snapshot, persist, or correlate.
+It keeps all of this **in memory**, in a single `MediasoupRouterSample` exposed as
+`observedRouter.sample` — see [`src/schema/MediasoupRouter.ts`](./src/schema/MediasoupRouter.ts). The
+sample **accumulates for the life of the router**: closed transports/producers/consumers are kept
+(with their `closedAt` set), not removed. Read it whenever you like — it's a plain object you own.
+
+### Memory & large meetings
+
+This is intentionally the **simplest** approach — everything lives in memory and nothing is sampled
+or evicted for you. That's fine for typical rooms, but be aware of the cost at scale:
+
+- **Consumers grow as O(N²)** on a single flat router: with `N` participants each producing audio +
+  video and consuming everyone else, the sample holds roughly `2·N·(N−1)` consumer records (≈ 19,800
+  for `N` = 100).
+- The sample is **cumulative** — closed entities and their `history` are retained — so it also grows
+  with call duration and churn (renegotiation, simulcast layer changes, rejoins).
+
+A 100-participant flat router can therefore reach tens of MB and keep growing. There is **no built-in
+sink, snapshotting, or eviction** — by design. **If you run large meetings, do your own sampling:**
+on your own cadence read `observedRouter.sample` (snapshot/serialize/persist what you need), drop what
+you don't, and close routers you no longer track. (mediasoup also typically shards routers across
+workers/cores, which keeps any one router small.)
 
 ### Matching peer connections — by **event**, not by storage
 
@@ -841,32 +857,54 @@ router serving many participants emits one match per participant's transport. Wh
 or `false`, no matching is performed and the event never fires. The internal listener is removed
 automatically when the router closes or the observer closes.
 
+### Ordering contract — observe the router first
+
+Matching is **forward-only by design**, and that is sufficient because the lifecycle ordering is
+**guaranteed, not racy**:
+
+- `ObservedMediasoupRouter` works purely by **subscribing to mediasoup's `observer` API**, so it can
+  only see events that happen *after* it is created. You therefore create it the moment the router
+  exists — **before** any transport is added to it — and it captures the rest going forward.
+- A mediasoup transport is always created **on the server first**; only then can the client connect
+  to it, produce/consume, and begin shipping `ClientSample`s. So a peer connection — and the
+  `peer-connection-added` event it triggers — can never appear before its server-side WebRTC
+  transport already exists (and has been observed by the router).
+
+Put together: by the time a `peer-connection-added` fires, the router has already recorded that
+transport's id in `webrtcTransportIds`, so a single forward-looking listener catches every match. No
+back-scan of existing peer connections and no re-check on transport creation are needed — the
+observer deliberately does **not** look backwards.
+
+**Your responsibility:** call `createObservedMediasoupRouter(...)` as early as the router exists
+(before transports are added or samples are accepted). If you register the router *after* its
+transports are created or after the client's first sample, those events are already in the past and
+the corresponding matches are missed.
+
 When the underlying mediasoup router closes, its `close` propagates to `ObservedMediasoupRouter`,
-which emits **`mediasoup-router-removed`**. That is your cue to do whatever cleanup or persistence
-you want with the now-final `sample` — again, the observer itself keeps nothing.
+which sets the sample's `closedAt` and emits **`mediasoup-router-removed`** — your cue to read /
+persist the final `observedRouter.sample` and drop your reference to it.
 
 ### Options — `observer.createObservedMediasoupRouter(settings)`
 
 | Field | Type | Required | Meaning |
 |-------|------|----------|---------|
-| `router` | `mediasoup.types.Router` | yes | the live router to observe; the observer attaches to `router.observer` |
-| `routerId` | `string` | yes | your id for the router (the sample also carries `router.id`) |
+| `router` | `mediasoup.types.Router` | yes | the live router to observe; the observer attaches to `router.observer`. `.id` and the sample's `routerId` come from `router.id` |
 | `appData` | `Record<string, unknown>` | no | application-owned bag on the `ObservedMediasoupRouter` |
-| `attachments` | `Record<string, unknown>` | no | free-form data copied onto `sample.attachments` |
+| `attachments` | `Record<string, unknown>` | no | free-form data; carried on `sample.attachments` |
 | `matchPeerConnectionByWebRtcTransportId` | `boolean` | no | opt in to peer-connection matching: emit `mediasoup-router-matched-with-peer-connection` for each peer connection whose id matches one of the router's WebRTC transport ids. Omitted / `false` → no matching, the event never fires |
 
 Peer-connection matching is **off by default**; enable it with
 `matchPeerConnectionByWebRtcTransportId: true`. Returns the `ObservedMediasoupRouter`, or `undefined`
 if the observer is closed (a router with the same id returns the existing instance — both warn).
 
-Useful members on the returned object: `.sample` (the `MediasoupRouterSample`), `.appData`,
-`.attachments` (getter over `sample.attachments`), `.webrtcTransportIds: Set<string>`, `.id`,
-`.close()`.
+Useful members on the returned object: `.sample` (the in-memory `MediasoupRouterSample`, with
+`createdAt` / `closedAt?` on it), `.appData`, `.attachments`, `.webrtcTransportIds: Set<string>`,
+`.id`, `.close()`.
 
 ### Example
 
 ```ts
-import { Observer } from '@observertc/observer-js';
+import { Observer, InMemorySink } from '@observertc/observer-js';
 import type { ObservedMediasoupRouterScope, ObservedPeerConnectionScope } from '@observertc/observer-js';
 
 const observer = new Observer();
@@ -874,46 +912,42 @@ const observer = new Observer();
 // 1) Feed client samples as usual so the observer knows about calls, clients & peer connections.
 //    (e.g. transport-layer: observer.accept(clientSample, context))
 
-// 2) Observe the SFU side, opting in to peer-connection matching for this router's transports.
+// 2) Observe the SFU side; opt in to peer-connection matching. State accumulates in `.sample`.
 const router = /* your mediasoup router */ undefined as any;
 const observedRouter = observer.createObservedMediasoupRouter({
   router,
-  routerId: router.id,
   matchPeerConnectionByWebRtcTransportId: true,
 });
 
+// For large meetings, sample it yourself on your own cadence (see "Memory & large meetings"):
+// setInterval(() => persist(observedRouter.sample), 10_000);
+
 // 3) Every peer connection whose id matches one of the router's WebRTC transport ids fires this —
 //    WE decide what to do with each pairing. The payload carries the full ancestry.
 observer.on('mediasoup-router-matched-with-peer-connection',
-  ({ observedMediasoupRouter, observedCall, observedClient, observedPeerConnection }:
+  ({ observedMediasoupRouter, observedCall, observedPeerConnection }:
      ObservedMediasoupRouterScope & ObservedPeerConnectionScope) => {
-    // e.g. remember which router serves this peer connection / client…
     (observedPeerConnection.appData ??= {}).routerId = observedMediasoupRouter.id;
-    // …or index the server sample by call in your own store:
-    myStore.linkRouterToCall(observedCall.callId, observedMediasoupRouter.sample);
+    myStore.linkRouterToCall(observedCall.callId, observedMediasoupRouter.id);
   },
 );
 
-// 4) The router closed — WE decide what to persist/forward with the final sample.
+// 4) The router closed — read/persist the final state, then drop your reference.
 observer.on('mediasoup-router-removed', ({ observedMediasoupRouter }: ObservedMediasoupRouterScope) => {
-  myStore.saveRouterSample(observedMediasoupRouter.sample);
-});
-
-// (optional) react to the router being registered at all:
-observer.on('mediasoup-router-added', ({ observedMediasoupRouter }) => {
-  console.log('observing router', observedMediasoupRouter.id);
+  persist(observedMediasoupRouter.sample);   // its `closedAt` is set
 });
 ```
 
-### Why event-driven instead of storing on the call
+### Why event-driven matching instead of storing on the call
 
 - **Loose coupling.** The call model stays about client telemetry; the SFU view lives on its own
-  object and is associated only if and how *you* choose.
+  `ObservedMediasoupRouter` and is associated only if and how *you* choose.
 - **You own the association.** One router serves many peer connections (across clients and calls),
   and the right place to keep that mapping is application-specific — so the observer hands you each
-  peer-connection match and the final sample, and gets out of the way.
-- **No silent accumulation.** Nothing is appended to `ObservedCall`, so there is no hidden growth or
-  lifetime you have to reason about; the router sample lives exactly as long as you keep a reference.
+  peer-connection match and gets out of the way.
+- **You own the sampling.** The router sample is plain in-memory state you read on your own terms;
+  for large meetings, sample/persist it yourself (see [Memory & large meetings](#memory--large-meetings))
+  rather than relying on the library to evict — it deliberately doesn't.
 
 ---
 

package/dist/index.d.mts

@@ -2232,15 +2232,28 @@ declare interface ObservedMediasoupRouter {
     once<U extends keyof ObservedMediasoupRouterEvents>(event: U, listener: (...args: ObservedMediasoupRouterEvents[U]) => void): this;
     emit<U extends keyof ObservedMediasoupRouterEvents>(event: U, ...args: ObservedMediasoupRouterEvents[U]): boolean;
 }
+/**
+ * Observes a live mediasoup `Router` by subscribing to its `observer` API and **accumulates** its
+ * topology and lifecycle into an in-memory `MediasoupRouterSample` (`observedRouter.sample`):
+ * transports, producers, consumers, data producers/consumers, their state-change history and
+ * `createdAt` / `closedAt`. The sample grows for the life of the router (closed entities are kept,
+ * with their `closedAt` set) and is yours to read, snapshot, or persist.
+ *
+ * NOTE: this is intentionally the simplest approach — everything is held in memory. For very large
+ * routers (e.g. ~100 participants producing and consuming on one router, where consumers grow as
+ * O(N²)) this can become substantial; in that case do your own periodic sampling/persistence and
+ * discard what you don't need (see the README's "Memory & large meetings" note).
+ */
 declare class ObservedMediasoupRouter<AppData extends Record<string, unknown> = Record<string, unknown>> extends EventEmitter {
     readonly router: types.Router;
-    readonly sample: MediasoupRouterSample;
     appData: AppData;
+    readonly sample: MediasoupRouterSample;
     readonly webrtcTransportIds: Set<string>;
-    get attachments(): Record<string, unknown>;
     closed: boolean;
     constructor(settings: ObservedMediasoupRouterSettings<AppData>);
     get id(): string;
+    get attachments(): Record<string, unknown>;
+    close(): void;
     addTransport: (transport: types.Transport) => void;
     addWebRtcTransport(transport: types.WebRtcTransport): void;
     addPlainTransport(transport: types.PlainTransport): void;
@@ -2250,7 +2263,6 @@ declare class ObservedMediasoupRouter<AppData extends Record<string, unknown> =
     addConsumer(transport: types.Transport, consumer: types.Consumer): void;
     addDataProducer(transport: types.Transport, dataProducer: types.DataProducer): void;
     addDataConsumer(transport: types.Transport, dataConsumer: types.DataConsumer): void;
-    close(): void;
     private attachRouterListeners;
     private _attachTransportObserverListeners;
 }
@@ -2805,7 +2817,7 @@ type ObserverConfig<AppData extends Record<string, unknown> = Record<string, unk
      * (`createDefaultMediasoupRemoteTrackResolverFactory()` / `createP2pRemoteTrackResolverFactory()`)
      * or build a `RemoteTrackResolver` with custom publisher/subscriber id resolvers.
      */
-    createTrackResolver?: RemoteTrackResolverFactory;
+    createRemoteTrackResolver?: RemoteTrackResolverFactory;
 };
 declare interface Observer {
     on<U extends keyof ObserverEvents>(event: U, listener: (...args: ObserverEvents[U]) => void): this;

package/dist/index.d.ts

@@ -2232,15 +2232,28 @@ declare interface ObservedMediasoupRouter {
     once<U extends keyof ObservedMediasoupRouterEvents>(event: U, listener: (...args: ObservedMediasoupRouterEvents[U]) => void): this;
     emit<U extends keyof ObservedMediasoupRouterEvents>(event: U, ...args: ObservedMediasoupRouterEvents[U]): boolean;
 }
+/**
+ * Observes a live mediasoup `Router` by subscribing to its `observer` API and **accumulates** its
+ * topology and lifecycle into an in-memory `MediasoupRouterSample` (`observedRouter.sample`):
+ * transports, producers, consumers, data producers/consumers, their state-change history and
+ * `createdAt` / `closedAt`. The sample grows for the life of the router (closed entities are kept,
+ * with their `closedAt` set) and is yours to read, snapshot, or persist.
+ *
+ * NOTE: this is intentionally the simplest approach — everything is held in memory. For very large
+ * routers (e.g. ~100 participants producing and consuming on one router, where consumers grow as
+ * O(N²)) this can become substantial; in that case do your own periodic sampling/persistence and
+ * discard what you don't need (see the README's "Memory & large meetings" note).
+ */
 declare class ObservedMediasoupRouter<AppData extends Record<string, unknown> = Record<string, unknown>> extends EventEmitter {
     readonly router: types.Router;
-    readonly sample: MediasoupRouterSample;
     appData: AppData;
+    readonly sample: MediasoupRouterSample;
     readonly webrtcTransportIds: Set<string>;
-    get attachments(): Record<string, unknown>;
     closed: boolean;
     constructor(settings: ObservedMediasoupRouterSettings<AppData>);
     get id(): string;
+    get attachments(): Record<string, unknown>;
+    close(): void;
     addTransport: (transport: types.Transport) => void;
     addWebRtcTransport(transport: types.WebRtcTransport): void;
     addPlainTransport(transport: types.PlainTransport): void;
@@ -2250,7 +2263,6 @@ declare class ObservedMediasoupRouter<AppData extends Record<string, unknown> =
     addConsumer(transport: types.Transport, consumer: types.Consumer): void;
     addDataProducer(transport: types.Transport, dataProducer: types.DataProducer): void;
     addDataConsumer(transport: types.Transport, dataConsumer: types.DataConsumer): void;
-    close(): void;
     private attachRouterListeners;
     private _attachTransportObserverListeners;
 }
@@ -2805,7 +2817,7 @@ type ObserverConfig<AppData extends Record<string, unknown> = Record<string, unk
      * (`createDefaultMediasoupRemoteTrackResolverFactory()` / `createP2pRemoteTrackResolverFactory()`)
      * or build a `RemoteTrackResolver` with custom publisher/subscriber id resolvers.
      */
-    createTrackResolver?: RemoteTrackResolverFactory;
+    createRemoteTrackResolver?: RemoteTrackResolverFactory;
 };
 declare interface Observer {
     on<U extends keyof ObserverEvents>(event: U, listener: (...args: ObserverEvents[U]) => void): this;

package/dist/index.js

@@ -3358,12 +3358,9 @@ var import_events5 = require("events");
 var logger6 = createLogger("ObservedMediasoupRouter");
 var ObservedMediasoupRouter = class extends import_events5.EventEmitter {
   router;
-  sample;
   appData;
+  sample;
   webrtcTransportIds = /* @__PURE__ */ new Set();
-  get attachments() {
-    return this.sample.attachments;
-  }
   closed = false;
   constructor(settings) {
     super();
@@ -3384,6 +3381,15 @@ var ObservedMediasoupRouter = class extends import_events5.EventEmitter {
   get id() {
     return this.router.id;
   }
+  get attachments() {
+    return this.sample.attachments;
+  }
+  close() {
+    if (this.closed) return;
+    this.closed = true;
+    if (this.sample.closedAt === void 0) this.sample.closedAt = Date.now();
+    this.emit("close");
+  }
   addTransport = (transport) => {
     let transportType = transport.type;
     if (!transportType) {
@@ -3416,35 +3422,17 @@ var ObservedMediasoupRouter = class extends import_events5.EventEmitter {
       history
     };
     this.sample.transports.push(transportSample);
-    const onIceStateChange = (iceState) => {
-      history.push({
-        type: `icestate-changed-to-${iceState}`,
-        timestamp: Date.now()
-      });
-    };
+    this.webrtcTransportIds.add(transport.id);
+    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
-      });
+      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()
-      });
+      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);
@@ -3456,7 +3444,6 @@ var ObservedMediasoupRouter = class extends import_events5.EventEmitter {
     transport.observer.on("iceselectedtuplechange", onIceSelectedTupleChange);
     transport.observer.on("dtlsstatechange", onDtlsStateChange);
     transport.observer.on("sctpstatechange", onSctpStateChange);
-    this.webrtcTransportIds.add(transport.id);
   }
   addPlainTransport(transport) {
     const history = [];
@@ -3479,13 +3466,8 @@ var ObservedMediasoupRouter = class extends import_events5.EventEmitter {
       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()
-      });
+      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);
@@ -3507,13 +3489,8 @@ var ObservedMediasoupRouter = class extends import_events5.EventEmitter {
     };
     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()
-      });
+      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);
@@ -3526,7 +3503,6 @@ var ObservedMediasoupRouter = class extends import_events5.EventEmitter {
       id: transport.id,
       type: "direct",
       createdAt: now,
-      // A DirectTransport has no network layer — it is connected the instant it exists.
       connectedAt: now,
       history: []
     };
@@ -3535,37 +3511,26 @@ var ObservedMediasoupRouter = class extends import_events5.EventEmitter {
   }
   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,
+      transportId: transport.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
+      codecInfo: {
+        mimeType: firstCodec?.mimeType ?? "unknown/unknown",
+        payloadType: firstCodec?.payloadType ?? 0,
+        clockRate: firstCodec?.clockRate ?? 0,
+        channels: firstCodec?.channels,
+        parameters: firstCodec?.parameters,
+        rtcpFeedback: firstCodec?.rtcpFeedback
+      },
+      ssrcs: producer.rtpParameters.encodings?.map((e) => e.ssrc).filter((s) => typeof s === "number"),
+      rids: producer.rtpParameters.encodings?.map((e) => e.rid).filter((r) => typeof r === "string"),
+      history: []
     };
     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()
-      });
-    };
+    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);
@@ -3584,30 +3549,10 @@ var ObservedMediasoupRouter = class extends import_events5.EventEmitter {
       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()
-      });
-    };
+    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);
@@ -3629,9 +3574,7 @@ var ObservedMediasoupRouter = class extends import_events5.EventEmitter {
       protocol: dataProducer.protocol
     };
     this.sample.dataProducers.push(dataProducerSample);
-    dataProducer.observer.once("close", () => {
-      dataProducerSample.closedAt = Date.now();
-    });
+    dataProducer.observer.once("close", () => dataProducerSample.closedAt = Date.now());
   }
   addDataConsumer(transport, dataConsumer) {
     const dataConsumerSample = {
@@ -3643,14 +3586,7 @@ var ObservedMediasoupRouter = class extends import_events5.EventEmitter {
       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");
+    dataConsumer.observer.once("close", () => dataConsumerSample.closedAt = Date.now());
   }
   attachRouterListeners() {
     this.router.observer.once("close", () => {
@@ -3661,18 +3597,10 @@ var ObservedMediasoupRouter = class extends import_events5.EventEmitter {
     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);
-    };
+    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);
@@ -3755,7 +3683,7 @@ var Observer = class extends import_events6.EventEmitter {
       appData: settings.appData ?? this.config.createCallAppData?.({ callId: settings.callId, observer: this })
     };
     const observedCall = new ObservedCall(callSettings, this);
-    observedCall.remoteTrackResolver = this.config.createTrackResolver?.(observedCall);
+    observedCall.remoteTrackResolver = this.config.createRemoteTrackResolver?.(observedCall);
     observedCall.once("close", () => {
       this.observedCalls.delete(observedCall.callId);
       ++this.totalRemovedCall;