@observertc/observer-js 0.30.6-beta → 0.40.1-beta

package/src/ObservedPeerConnection.ts

@@ -1,13 +1,11 @@
 import { EventEmitter } from 'events';
-import * as Models from './models/Models';
-import { StorageProvider } from './storages/StorageProvider';
 import { PeerConnectionTransport } from '@observertc/sample-schemas-js';
 import { ObservedClient } from './ObservedClient';
-import { ObservedInboundTrack, ObservedInboundTrackConfig } from './ObservedInboundTrack';
-import { ObservedOutboundTrack, ObservedOutboundTrackConfig } from './ObservedOutboundTrack';
+import { ObservedInboundTrack, ObservedInboundTrackModel } from './ObservedInboundTrack';
+import { ObservedOutboundTrack, ObservedOutboundTrackModel } from './ObservedOutboundTrack';
 import { PeerConnectionTransportReport } from '@observertc/report-schemas-js';
-import { createSingleExecutor } from './common/SingleExecutor';
 import { ObservedICE } from './ObservedICE';
+import { ObservedDataChannel } from './ObservedDataChannel';
 
 export type ObservedPeerConnectionEvents = {
 	update: [],
@@ -18,8 +16,9 @@ export type ObservedPeerConnectionEvents = {
 	newoutboundvideotrack: [ObservedOutboundTrack<'video'>],
 };
 
-export type ObservedPeerConnectionConfig = {
+export type ObservedPeerConnectionModel = {
 	peerConnectionId: string;
+	label?: string;
 };
 
 export type ObservedPeerConnectionStats = Omit<PeerConnectionTransport, 'transportId' | 'label'>;
@@ -32,27 +31,7 @@ export declare interface ObservedPeerConnection {
 }
 
 export class ObservedPeerConnection extends EventEmitter {
-	public static async create(
-		config: ObservedPeerConnectionConfig,
-		client: ObservedClient,
-		storageProvider: StorageProvider,
-	): Promise<ObservedPeerConnection> {
-		const model = new Models.PeerConnection({
-			roomId: client.roomId,
-			serviceId: client.serviceId,
-			callId: client.callId,
-			clientId: client.clientId,
-			peerConnectionId: config.peerConnectionId,
-		});
-
-		const alreadyInserted = await storageProvider.peerConnectionStorage.insert(config.peerConnectionId, model);
-
-		if (alreadyInserted) throw new Error(`PeerConnection with id ${config.peerConnectionId} already exists`);
-
-		return new ObservedPeerConnection(model, client, storageProvider);
-	}
-
-	public created = Date.now();
+	public readonly created = Date.now();
 
 	public totalInboundPacketsLost = 0;
 	public totalInboundPacketsReceived = 0;
@@ -99,20 +78,43 @@ export class ObservedPeerConnection extends EventEmitter {
 	private readonly _inboundVideoTracks = new Map<string, ObservedInboundTrack<'video'>>();
 	private readonly _outboundAudioTracks = new Map<string, ObservedOutboundTrack<'audio'>>();
 	private readonly _outboundVideoTracks = new Map<string, ObservedOutboundTrack<'video'>>();
-	private readonly _execute = createSingleExecutor();
+	private readonly _dataChannels = new Map<number, ObservedDataChannel>();
 	
-	private constructor(
-		private readonly _model: Models.PeerConnection,
+	public constructor(
+		private readonly _model: ObservedPeerConnectionModel,
 		public readonly client: ObservedClient,
-		private readonly _storageProvider: StorageProvider,
 	) {
 		super();
 	}
 
+	public get serviceId() {
+		return this.client.serviceId;
+	}
+
+	public get roomId() {
+		return this.client.roomId;
+	}
+
+	public get callId() {
+		return this.client.callId;
+	}
+
+	public get clientId() {
+		return this.client.clientId;
+	}
+
+	public get mediaUnitId() {
+		return this.client.mediaUnitId;
+	}
+
 	public get label() {
 		return this._model.label;
 	}
 
+	public set label(value: string | undefined) {
+		this._model.label = value;
+	}
+
 	public get usingTURN() {
 		return this.ICE.selectedRemoteCandidate?.candidateType?.toLowerCase() === 'relay';
 	}
@@ -158,6 +160,10 @@ export class ObservedPeerConnection extends EventEmitter {
 		return this._outboundVideoTracks;
 	}
 
+	public get dataChannels(): ReadonlyMap<number, ObservedDataChannel> {
+		return this._dataChannels;
+	}
+
 	public get uptimeInMs() {
 		return this._updated - this.created;
 	}
@@ -175,9 +181,7 @@ export class ObservedPeerConnection extends EventEmitter {
 		Array.from(this._outboundAudioTracks.values()).forEach((track) => track.close());
 		Array.from(this._outboundVideoTracks.values()).forEach((track) => track.close());
 
-		this._execute(() => this._storageProvider.peerConnectionStorage.remove(this.peerConnectionId))
-			.catch(() => void 0)
-			.finally(() => this.emit('close')); 
+		this.emit('close');
 	}
 
 	public getTrack(trackId: string): ObservedInboundTrack<'audio'> | ObservedInboundTrack<'video'> | ObservedOutboundTrack<'audio'> | ObservedOutboundTrack<'video'> | undefined {
@@ -287,6 +291,14 @@ export class ObservedPeerConnection extends EventEmitter {
 
 			sumRttInMs = (track.rttInMs ?? 0);
 		});
+
+		this._dataChannels.forEach((channel) => {
+			this.deltaDataChannelBytesSent += channel.deltaBytesSent;
+			this.deltaDataChannelBytesReceived += channel.deltaBytesReceived;
+			this.totalDataChannelBytesSent += channel.totalBytesSent;
+			this.totalDataChannelBytesReceived += channel.totalBytesReceived;
+		});
+
 		const iceRttInMs = this.ICE.stats?.currentRoundTripTime;
 		let nrOfBelongings = this._inboundAudioTracks.size + this._inboundVideoTracks.size + this._outboundAudioTracks.size + this._outboundVideoTracks.size;
 
@@ -297,14 +309,13 @@ export class ObservedPeerConnection extends EventEmitter {
 		this.avgRttInMs = 0 < nrOfBelongings ? sumRttInMs / nrOfBelongings : undefined;
 	}
 
-	public async update(sample: PeerConnectionTransport, timestamp: number) {
+	public update(sample: PeerConnectionTransport, timestamp: number) {
 		if (this._closed) return;
 		if (sample.peerConnectionId !== this._model.peerConnectionId) throw new Error(`TransportId mismatch. PeerConnectionId: ${ this._model.peerConnectionId } TransportId: ${ sample.transportId}`);
 
 		this._sample = sample;
 		if (this._model.label !== sample.label) {
 			this._model.label = sample.label;
-			await this._save().catch(() => void 0);
 		}
 
 		const report: PeerConnectionTransportReport = {
@@ -321,138 +332,94 @@ export class ObservedPeerConnection extends EventEmitter {
 
 		this.reports.addPeerConnectionTransportReports(report);
 		
-		this._updated = timestamp;
+		this._updated = Date.now();
 		this.emit('update');
 	}
 
-	public async createInboundAudioTrack(config: Omit<ObservedInboundTrackConfig<'audio'>, 'kind'>): Promise<ObservedInboundTrack<'audio'>> {
+	public createInboundAudioTrack(config: Omit<ObservedInboundTrackModel<'audio'>, 'kind'>): ObservedInboundTrack<'audio'> {
 		if (this._closed) throw new Error(`PeerConnection ${this.peerConnectionId} is closed`);
-
-		const result = await ObservedInboundTrack.create<'audio'>({
+		
+		const result = new ObservedInboundTrack<'audio'>({
 			kind: 'audio',
-			trackId: config.trackId,
-		}, this, this._storageProvider);
+			...config,
+		}, this);
 
-		const pendingTracksTimestamp = this.client.ωpendingCreatedTracksTimestamp.get(result.trackId);
-
-		if (pendingTracksTimestamp) {
-			this.client.ωpendingCreatedTracksTimestamp.delete(result.trackId);
-			result.created = pendingTracksTimestamp;
-		}
-		
 		result.on('close', () => {
 			this._inboundAudioTracks.delete(result.trackId);
-			this._model.inboundTrackIds = this._model.inboundTrackIds.filter((id) => id !== result.trackId);
-			!this._closed &&this._save().catch(() => void 0);
 		});
 		this._inboundAudioTracks.set(result.trackId, result);
-		this._model.inboundTrackIds = [ ...(new Set<string>([ ...this._model.inboundTrackIds, result.trackId ])) ];
-		await this._save();
 
 		this.emit('newinboudaudiotrack', result);
 
 		return result;
 	}
 
-	public async createInboundVideoTrack(config: Omit<ObservedInboundTrackConfig<'video'>, 'kind'>): Promise<ObservedInboundTrack<'video'>> {
+	public createInboundVideoTrack(config: Omit<ObservedInboundTrackModel<'video'>, 'kind'>): ObservedInboundTrack<'video'> {
 		if (this._closed) throw new Error(`PeerConnection ${this.peerConnectionId} is closed`);
-
-		const result = await ObservedInboundTrack.create<'video'>({
-			kind: 'video',
-			trackId: config.trackId,
-		}, this, this._storageProvider);
 		
-		const pendingTracksTimestamp = this.client.ωpendingCreatedTracksTimestamp.get(result.trackId);
-
-		if (pendingTracksTimestamp) {
-			this.client.ωpendingCreatedTracksTimestamp.delete(result.trackId);
-			result.created = pendingTracksTimestamp;
-		}
+		const result = new ObservedInboundTrack<'video'>({
+			kind: 'video',
+			...config,
+		}, this);
 
 		result.on('close', () => {
 			this._inboundVideoTracks.delete(result.trackId);
-			this._model.inboundTrackIds = this._model.inboundTrackIds.filter((id) => id !== result.trackId);
-			!this._closed &&this._save().catch(() => void 0);
 		});
 		this._inboundVideoTracks.set(result.trackId, result);
-		this._model.inboundTrackIds = [ ...(new Set<string>([ ...this._model.inboundTrackIds, result.trackId ])) ];
-		await this._save();
 
-		this.emit('newinboudvideotrack', result);	
-		
+		this.emit('newinboudvideotrack', result);
+
 		return result;
 	}
 
-	public async createOutboundAudioTrack(config: Omit<ObservedOutboundTrackConfig<'audio'>, 'kind'>): Promise<ObservedOutboundTrack<'audio'>> {
+	public createOutboundAudioTrack(config: Omit<ObservedOutboundTrackModel<'audio'>, 'kind'>): ObservedOutboundTrack<'audio'> {
 		if (this._closed) throw new Error(`PeerConnection ${this.peerConnectionId} is closed`);
 		
-		const result = await ObservedOutboundTrack.create<'audio'>({
+		const result = new ObservedOutboundTrack<'audio'>({
 			kind: 'audio',
-			trackId: config.trackId,
-		}, this, this._storageProvider);
-
-		const pendingTracksTimestamp = this.client.ωpendingCreatedTracksTimestamp.get(result.trackId);
-
-		if (pendingTracksTimestamp) {
-			this.client.ωpendingCreatedTracksTimestamp.delete(result.trackId);
-			result.created = pendingTracksTimestamp;
-		}
+			...config,
+		}, this);
 
 		result.on('close', () => {
 			this._outboundAudioTracks.delete(result.trackId);
-			this._model.outboundTrackIds = this._model.outboundTrackIds.filter((id) => id !== result.trackId);
-			
-			result.sfuStreamId && this.client.call.sfuStreamIdToOutboundAudioTrack.delete(result.sfuStreamId);
-			!this._closed &&this._save().catch(() => void 0);
 		});
 		this._outboundAudioTracks.set(result.trackId, result);
-		this._model.outboundTrackIds = [ ...(new Set<string>([ ...this._model.outboundTrackIds, result.trackId ])) ];
-		
-		result.sfuStreamId && this.client.call.sfuStreamIdToOutboundAudioTrack.set(result.sfuStreamId, result);
-		await this._save();
 
 		this.emit('newoutboundaudiotrack', result);
 
 		return result;
 	}
 
-	public async createOutboundVideoTrack(config: Omit<ObservedOutboundTrackConfig<'video'>, 'kind'>): Promise<ObservedOutboundTrack<'video'>> {
+	public createOutboundVideoTrack(config: Omit<ObservedOutboundTrackModel<'video'>, 'kind'>): ObservedOutboundTrack<'video'> {
 		if (this._closed) throw new Error(`PeerConnection ${this.peerConnectionId} is closed`);
 		
-		const result = await ObservedOutboundTrack.create<'video'>({
+		const result = new ObservedOutboundTrack<'video'>({
 			kind: 'video',
-			trackId: config.trackId,
-		}, this, this._storageProvider);
-
-		const pendingTracksTimestamp = this.client.ωpendingCreatedTracksTimestamp.get(result.trackId);
-
-		if (pendingTracksTimestamp) {
-			this.client.ωpendingCreatedTracksTimestamp.delete(result.trackId);
-			result.created = pendingTracksTimestamp;
-		}
+			...config,
+		}, this);
 
 		result.on('close', () => {
 			this._outboundVideoTracks.delete(result.trackId);
-			result.sfuStreamId && this.client.call.sfuStreamIdToOutboundVideoTrack.set(result.sfuStreamId, result);
-			this._model.outboundTrackIds = this._model.outboundTrackIds.filter((id) => id !== result.trackId);
-			!this._closed && this._save().catch(() => void 0);
 		});
 		this._outboundVideoTracks.set(result.trackId, result);
-		result.sfuStreamId && this.client.call.sfuStreamIdToOutboundVideoTrack.set(result.sfuStreamId, result);
-		this._model.outboundTrackIds = [ ...(new Set<string>([ ...this._model.outboundTrackIds, result.trackId ])) ];
-		await this._save();
 
 		this.emit('newoutboundvideotrack', result);
-		
+
 		return result;
 	}
 
-	private async _save() {
+	public createDataChannel(channelId: number) {
 		if (this._closed) throw new Error(`PeerConnection ${this.peerConnectionId} is closed`);
 		
-		return this._execute(async () => {
-			if (this._closed) throw new Error(`PeerConnection ${this.peerConnectionId} is closed`);
-			await this._storageProvider.peerConnectionStorage.set(this.peerConnectionId, this._model);
+		const result = new ObservedDataChannel({
+			channelId,
+		}, this);
+
+		result.on('close', () => {
+			this._dataChannels.delete(result.channelId);
 		});
+		this._dataChannels.set(result.channelId, result);
+
+		return result;
 	}
 }

package/src/ObservedSfu.ts

@@ -1,14 +1,11 @@
 import { EventEmitter } from 'events';
-import * as Models from './models/Models';
 import { Observer } from './Observer';
-import { createSingleExecutor } from './common/SingleExecutor';
 import { SfuSample } from '@observertc/sample-schemas-js';
 
-export type ObservedSfuConfig<AppData extends Record<string, unknown> = Record<string, unknown>> = {
+export type ObservedSfuModel= {
 	serviceId: string;
 	sfuId: string;
 	joined?: number;
-	appData: AppData;
 };
 
 export type ObservedSfuEvents = {
@@ -24,36 +21,13 @@ export declare interface ObservedSfu {
 }
 
 export class ObservedSfu<AppData extends Record<string, unknown> = Record<string, unknown>> extends EventEmitter {
-	public static async create<T extends Record<string, unknown> = Record<string, unknown>>(
-		config: ObservedSfuConfig<T>, 
-		observer: Observer,
-		// reportsCollector: ReportsCollector,
-	) {
-		const model = new Models.Sfu({
-			serviceId: config.serviceId,
-			sfuId: config.sfuId,
-			sfuTransportIds: [],
-			joined: BigInt(config.joined ?? Date.now()),
-		});
-		const result = new ObservedSfu(
-			model,
-			observer,
-			config.appData,
-		);
-
-		const alreadyInserted = await observer.storage.sfuStorage.insert(config.sfuId, model);
-
-		if (alreadyInserted) throw new Error(`Sfu with id ${config.sfuId} already exists`);
-
-		return result;
-	}
+	public readonly created = Date.now();
 
 	private _updated = Date.now();
-	private readonly _execute = createSingleExecutor();
 	private _closed = false;
 	
-	private constructor(
-		private readonly _model: Models.Sfu,
+	public constructor(
+		private readonly _model: ObservedSfuModel,
 		public readonly observer: Observer,
 		public readonly appData: AppData,
 	) {
@@ -75,6 +49,10 @@ export class ObservedSfu<AppData extends Record<string, unknown> = Record<string
 		return Number(this._model.joined!);
 	}
 
+	public get updated() {
+		return this._updated;
+	}
+
 	public get closed() {
 		return this._closed;
 	}
@@ -85,24 +63,11 @@ export class ObservedSfu<AppData extends Record<string, unknown> = Record<string
 		this.emit('close');
 	}
 
-	public async update(sample: SfuSample) {
+	public update(sample: SfuSample) {
 		if (this._closed) throw new Error(`Sfu ${this.sfuId} is closed`);
 		if (sample.sfuId !== this.sfuId) throw new Error(`Sfu ${this.sfuId} is not the same as sample.sfuId`);
 		
-		return this._execute(async () => {
-			if (this._closed) throw new Error(`Sfu ${this.sfuId} is closed`);
-			await this._save();
-			this.emit('update');
-		});
-	}
-
-	private async _save() {
-		if (this._closed) throw new Error(`Sfu ${this.sfuId} is closed`);
-		
-		return this._execute(async () => {
-			if (this._closed) throw new Error(`Sfu ${this.sfuId} is closed`);
-			await this.observer.storage.sfuStorage.set(this.sfuId, this._model);
-		});		
+		this._updated = Date.now();
+		this.emit('update');
 	}
-	
 }

package/src/Observer.ts

@@ -1,10 +1,9 @@
 import { createLogger } from './common/logger';
-import { StorageProvider, createSimpleStorageProvider } from './storages/StorageProvider';
-import { ObservedCall, ObservedCallConfig } from './ObservedCall';
+import { ObservedCall, ObservedCallModel } from './ObservedCall';
 import { ReportsCollector } from './ReportsCollector';
 import { EventEmitter } from 'events';
 import { PartialBy } from './common/utils';
-import { createCallStartedEventReport } from './common/callEventReports';
+import { createCallEndedEventReport, createCallStartedEventReport } from './common/callEventReports';
 
 const logger = createLogger('Observer');
 
@@ -36,8 +35,6 @@ export type ObserverConfig = {
 	maxCollectingTimeInMs?: number | undefined;
 	
 	maxEntryIdleTimeInMs?: number | undefined;
-
-	storages?: StorageProvider;
 };
 
 export declare interface Observer {
@@ -63,9 +60,7 @@ export class Observer extends EventEmitter {
 			providedConfig
 		);
 
-		const storages = providedConfig.storages ?? createSimpleStorageProvider();
-		
-		return new Observer(config, storages);
+		return new Observer(config);
 	}
 
 	public readonly reports = new ReportsCollector();
@@ -74,7 +69,6 @@ export class Observer extends EventEmitter {
 	private _closed = false;
 	public constructor(
 		public readonly config: ObserverConfig,
-		public readonly storage: StorageProvider,
 	) {
 		super();
 		logger.debug('Observer is created with config', this.config);
@@ -91,25 +85,26 @@ export class Observer extends EventEmitter {
 		this.reports.on('newreport', onNewReport);
 	}
 
-	public async createObservedCall<T extends Record<string, unknown> = Record<string, unknown>>(
-		config: PartialBy<ObservedCallConfig<T>, 'serviceId' | 'started'>
-	): Promise<ObservedCall<T>> {
+	public createObservedCall<T extends Record<string, unknown> = Record<string, unknown>>(
+		config: PartialBy<ObservedCallModel, 'serviceId' | 'started'> & { appData: T }
+	): ObservedCall<T> {
 		if (this._closed) {
 			throw new Error('Attempted to create a call source on a closed observer');
 		}
 
-		const call = await ObservedCall.create({
+		const { appData, ...model } = config;
+		const call = new ObservedCall({
+			...model,
 			serviceId: this.config.defaultServiceId,
 			started: Date.now(),
-			...config,
-		}, this);
+		}, this, appData);
 
 		if (this._closed) throw new Error('Cannot create an observed call on a closed observer');
 		if (this._observedCalls.has(call.callId)) throw new Error(`Observed Call with id ${call.callId} already exists`);
 
 		call.once('close', () => {
 			this._observedCalls.delete(call.callId);
-			this.reports.addCallEventReport(createCallStartedEventReport(
+			this.reports.addCallEventReport(createCallEndedEventReport(
 				call.serviceId,
 				call.roomId,
 				call.callId,

package/src/common/types.ts

@@ -18,78 +18,9 @@ import {
 	SfuSctpStreamReport,
 	SFUTransportReport,
 } from '@observertc/report-schemas-js';
-import * as Models from '../models/Models';
-import { StorageProvider } from '../storages/StorageProvider';
-import { Message } from '@bufbuild/protobuf';
 
 export type MediaKind = 'audio' | 'video';
 
-export interface EvaluatorContext {
-	readonly startedCallIds: string[];
-	readonly endedCalls: (Omit<Models.Call, keyof Message> & {
-		ended: number;
-	})[];
-
-	readonly joinedClientIds: string[];
-	readonly detachedClients: (Omit<Models.Client, keyof Message> & {
-		detached: number;
-	})[];
-
-	readonly openedPeerConnectionIds: string[];
-	readonly closedPeerConnections: (Omit<Models.PeerConnection, keyof Message> & {
-		closed: number;
-	})[];
-
-	readonly addedInboundAudioTrackIds: string[];
-	readonly removedInboundAudioTracks: (Omit<Models.InboundTrack, keyof Message> & {
-		removed: number;
-	})[];
-
-	readonly addedInboundVideoTrackIds: string[];
-	readonly removedInboundVideoTracks: (Omit<Models.InboundTrack, keyof Message> & {
-		removed: number;
-	})[];
-
-	readonly addedOutboundAudioTrackIds: string[];
-	readonly removedOutboundAudioTracks: (Omit<Models.OutboundTrack, keyof Message> & {
-		removed: number;
-	})[];
-
-	readonly addedOutboundVideoTrackIds: string[];
-	readonly removedOutboundVideoTracks: (Omit<Models.OutboundTrack, keyof Message> & {
-		removed: number;
-	})[];
-
-	readonly joinedSfuIds: string[];
-	readonly detachedSfus: (Omit<Models.Sfu, keyof Message> & {
-		detached: number;
-	})[];
-
-	readonly openedSfuTransportIds: string[];
-	readonly closedSfuTransports: (Omit<Models.SfuTransport, keyof Message> & {
-		closed: number;
-	})[];
-
-	readonly addedSfuInbounRtpPadIds: string[];
-	readonly removedSfuInbounRtpPadIds: (Omit<Models.SfuInboundRtpPad, keyof Message> & {
-		removed: number;
-	})[];
-
-	readonly addedSfuOutbounRtpPadIds: string[];
-	readonly removedSfuOutbounRtpPadIds: (Omit<Models.SfuOutboundRtpPad, keyof Message> & {
-		removed: number;
-	})[];
-
-	readonly openedSfuSctpChannelIds: string[];
-	readonly closedSfuSctpChannels: (Omit<Models.SfuSctpChannel, keyof Message> & {
-		closed: number;
-	})[];
-
-	readonly storages: StorageProvider;
-	readonly reports: ObserverSinkContext;
-
-}
-
 // export type EvaluatorMiddleware = Middleware<EvaluatorContext>;
 
 export interface ObserverSinkContext {

package/src/index.ts

@@ -1,8 +1,6 @@
 export type { ObserverConfig, ObserverEvents } from './Observer';
 
 export { Observer } from './Observer';
-export type { ObserverStorage } from './storages/ObserverStorage';
-export type { StorageProvider } from './storages/StorageProvider';
 
 export * as SampleSchema from '@observertc/sample-schemas-js';
 export * as ReportSchema from '@observertc/report-schemas-js';
@@ -54,12 +52,12 @@ export type {
 	SFUTransportReport,
 } from '@observertc/report-schemas-js';
 
-export type { ObservedClient, ObservedClientConfig } from './ObservedClient';
-export type { ObservedPeerConnection, ObservedPeerConnectionConfig, ObservedPeerConnectionEvents } from './ObservedPeerConnection';
-export type { ObservedInboundTrack, ObservedInboundTrackConfig, ObservedInboundTrackEvents } from './ObservedInboundTrack';
-export type { ObservedOutboundTrack, ObservedOutboundTrackConfig, ObservedOutboundTrackEvents } from './ObservedOutboundTrack';
+export type { ObservedClient, ObservedClientModel } from './ObservedClient';
+export type { ObservedPeerConnection, ObservedPeerConnectionModel, ObservedPeerConnectionEvents } from './ObservedPeerConnection';
+export type { ObservedInboundTrack, ObservedInboundTrackModel, ObservedInboundTrackEvents } from './ObservedInboundTrack';
+export type { ObservedOutboundTrack, ObservedOutboundTrackModel, ObservedOutboundTrackEvents } from './ObservedOutboundTrack';
 
-export type { EvaluatorContext, ObserverSinkContext } from './common/types';
+export type { ObserverSinkContext } from './common/types';
 
 import { Observer, ObserverConfig } from './Observer';
 export function createObserver(config?: Partial<ObserverConfig>) {