@fishjam-cloud/ts-client 0.5.1

package/dist/src/webrtc/tracks/LocalTrack.js

@@ -0,0 +1,235 @@
+import { generateCustomEvent, generateMediaEvent } from '../mediaEvent';
+import { defaultBitrates, defaultSimulcastBitrates, UNLIMITED_BANDWIDTH, } from '../bitrate';
+import { getEncodingParameters } from './encodings';
+import { createTransceiverConfig } from './transceivers';
+/**
+ * This is a wrapper over `TrackContext` that adds additional properties such as:
+ * - `MLineId`: required to generate sdpOffer
+ * - `MediaStreamTrackId`: required to generate sdpOffer and match RTCRtpSender
+ * - `RTCRtpSender`: required to manage RTCPeerConnection track, e.g.:
+ *   - enable/disable encoding
+ *   - remove from connection
+ *   - replace track
+ *   - set track bandwidth
+ *
+ * In the future, this object could potentially be merged with `TrackContextImpl`.
+ *
+ * # Lifecycle, state transitions
+ *
+ * I identified the following states
+ * - Before creating `Connection` object
+ *   - connection === null
+ *   - sender === null
+ *   - mLineId === null
+ * - After creating `Connection` object, during `onOfferData` handler
+ *   // TODO: Verify if the track acquires a sender at this point or if it's only for past tracks
+ *   - connection !== null
+ *   - sender !== null
+ *   - mLineId === null
+ * - After establishing connection, during `onSdpAnswer`, track is being sent
+ *   - connection !== null
+ *   - sender !== null
+ *   - mLineId !== null
+ */
+export class LocalTrack {
+    id;
+    mediaStreamTrackId = null;
+    mLineId = null;
+    trackContext;
+    sender = null;
+    encodings;
+    metadataParser;
+    connection;
+    constructor(connection, id, trackContext, metadataParser) {
+        this.connection = connection;
+        this.id = id;
+        this.trackContext = trackContext;
+        // todo maybe we could remove this object and use sender.getParameters().encodings.encodingParameter.active instead
+        this.encodings = { h: true, m: true, l: true };
+        if (trackContext.track?.id) {
+            this.mediaStreamTrackId = trackContext.track?.id;
+        }
+        this.metadataParser = metadataParser;
+    }
+    updateSender = () => {
+        if (this.mediaStreamTrackId && this.connection) {
+            this.sender = this.connection.findSender(this.mediaStreamTrackId);
+        }
+    };
+    updateConnection = (connection) => {
+        this.connection = connection;
+    };
+    disableTrackEncoding = async (encoding) => {
+        if (!this.sender)
+            throw new Error(`RTCRtpSender for track ${this.id} not found`);
+        const params = this.sender.getParameters();
+        const encodings = params.encodings;
+        const encodingParameter = encodings.find((en) => en.rid == encoding);
+        if (!encodingParameter)
+            throw new Error(`RTCRtpEncodingParameters for track ${this.id} not found`);
+        encodingParameter.active = false;
+        this.encodings[encoding] = false;
+        await this.sender.setParameters(params);
+    };
+    addTrackToConnection = () => {
+        if (!this.trackContext.track)
+            throw Error(`MediaStreamTrack for track ${this.id} does not exist`);
+        if (!this.connection)
+            throw new Error(`There is no active RTCPeerConnection`);
+        const transceiverConfig = createTransceiverConfig(this.trackContext);
+        this.updateEncodings();
+        this.connection.addTransceiver(this.trackContext.track, transceiverConfig);
+    };
+    // 1
+    updateEncodings = () => {
+        if (this.trackContext?.track?.kind === 'video' &&
+            this.trackContext.simulcastConfig?.activeEncodings) {
+            const activeEncodings = this.trackContext.simulcastConfig.activeEncodings;
+            this.encodings.l = activeEncodings.some((e) => e === 'l');
+            this.encodings.m = activeEncodings.some((e) => e === 'm');
+            this.encodings.h = activeEncodings.some((e) => e === 'h');
+        }
+    };
+    removeFromConnection = () => {
+        if (!this.sender)
+            throw new Error(`RTCRtpSender for track ${this.id} not found`);
+        if (!this.connection)
+            throw new Error(`There is no active RTCPeerConnection`);
+        this.connection.removeTrack(this.sender);
+    };
+    // TODO: Remove `newTrackMetadata` parameter because this function should be an atomic operation.
+    //  Metadata are updated after `await this.sender.replaceTrack(newTrack)`,
+    //  so it could be chained by the user.
+    replaceTrack = async (newTrack, 
+    // todo remove webrtc with newTrackMetadata
+    newTrackMetadata, 
+    // todo remove webrtc with newTrackMetadata
+    webrtc) => {
+        const trackId = this.id;
+        const stream = this.trackContext.stream;
+        if (!this.sender)
+            throw Error('There is no RTCRtpSender for this track id!');
+        stream?.getTracks().forEach((track) => {
+            stream?.removeTrack(track);
+        });
+        if (newTrack) {
+            stream?.addTrack(newTrack);
+        }
+        if (this.trackContext.track && !newTrack) {
+            const mediaEvent = generateMediaEvent('muteTrack', { trackId: trackId });
+            webrtc.sendMediaEvent(mediaEvent);
+            webrtc.emit('localTrackMuted', { trackId: trackId });
+        }
+        else if (!this.trackContext.track && newTrack) {
+            const mediaEvent = generateMediaEvent('unmuteTrack', {
+                trackId: trackId,
+            });
+            webrtc.sendMediaEvent(mediaEvent);
+            webrtc.emit('localTrackUnmuted', { trackId: trackId });
+        }
+        this.mediaStreamTrackId = newTrack?.id ?? null;
+        try {
+            await this.sender.replaceTrack(newTrack);
+            this.trackContext.track = newTrack;
+            if (newTrackMetadata) {
+                webrtc.updateTrackMetadata(trackId, newTrackMetadata);
+            }
+        }
+        catch (error) {
+            // ignore
+        }
+    };
+    setTrackBandwidth = (bandwidth) => {
+        if (!this.sender)
+            throw new Error(`RTCRtpSender for track ${this.id} not found`);
+        const parameters = this.sender.getParameters();
+        parameters.encodings = getEncodingParameters(parameters, bandwidth);
+        return this.sender.setParameters(parameters);
+    };
+    setEncodingBandwidth(rid, bandwidth) {
+        if (!this.sender)
+            throw new Error(`RTCRtpSender for track ${this.id} not found`);
+        const parameters = this.sender.getParameters();
+        const encoding = parameters.encodings.find((encoding) => encoding.rid === rid);
+        if (!encoding) {
+            return Promise.reject(`Encoding with rid '${rid}' doesn't exist`);
+        }
+        else if (bandwidth === 0) {
+            delete encoding.maxBitrate;
+        }
+        else {
+            encoding.maxBitrate = bandwidth * 1024;
+        }
+        return this.sender.setParameters(parameters);
+    }
+    updateTrackMetadata = (metadata) => {
+        const trackContext = this.trackContext;
+        try {
+            trackContext.metadata = this.metadataParser(metadata);
+            trackContext.rawMetadata = metadata;
+            trackContext.metadataParsingError = undefined;
+        }
+        catch (error) {
+            trackContext.metadata = undefined;
+            trackContext.metadataParsingError = error;
+            throw error;
+        }
+    };
+    enableTrackEncoding = (encoding) => {
+        if (!this.sender)
+            throw new Error(`RTCRtpSender for track ${this.id} not found`);
+        const params = this.sender.getParameters();
+        const encodingParameters = params.encodings.find((en) => en.rid == encoding);
+        if (!encodingParameters)
+            throw new Error(`RTCRtEncodingParameters ${encoding} for track ${this.id} not found`);
+        encodingParameters.active = true;
+        this.encodings[encoding] = true;
+        return this.sender.setParameters(params);
+    };
+    getDisabledEncodings = () => {
+        return Object.entries(this.encodings)
+            .filter(([_, value]) => !value)
+            .map(([encoding]) => encoding)
+            .reduce((acc, encoding) => [...acc, encoding], []);
+    };
+    setMLineId = (mLineId) => {
+        this.mLineId = mLineId;
+    };
+    isNotSimulcastTrack = (encodings) => encodings.length === 1 && !encodings[0].rid;
+    getTrackBitrates = () => {
+        const trackContext = this.trackContext;
+        const kind = this.trackContext.track?.kind;
+        if (!trackContext.track) {
+            if (!trackContext.trackKind) {
+                throw new Error('trackContext.trackKind is empty');
+            }
+            return defaultBitrates[trackContext.trackKind];
+        }
+        if (!this.sender)
+            throw new Error(`RTCRtpSender for track ${this.id} not found`);
+        const encodings = this.sender.getParameters().encodings;
+        if (this.isNotSimulcastTrack(encodings)) {
+            return (encodings[0].maxBitrate ||
+                (kind ? defaultBitrates[kind] : UNLIMITED_BANDWIDTH));
+        }
+        else if (kind === 'audio') {
+            throw 'Audio track cannot have multiple encodings';
+        }
+        return encodings
+            .filter((encoding) => encoding.rid)
+            .reduce((acc, encoding) => {
+            const rid = encoding.rid;
+            acc[rid] = encoding.maxBitrate || defaultSimulcastBitrates[rid];
+            return acc;
+        }, {});
+    };
+    createTrackVariantBitratesEvent = () => {
+        return generateCustomEvent({
+            type: 'trackVariantBitrates',
+            data: {
+                trackId: this.id,
+                variantBitrates: this.getTrackBitrates(),
+            },
+        });
+    };
+}

package/dist/src/webrtc/tracks/LocalTrackManager.d.ts

@@ -0,0 +1,38 @@
+import type { SimulcastConfig, TrackBandwidthLimit } from '../types';
+import { type MediaEvent } from '../mediaEvent';
+import type { ConnectionManager } from '../ConnectionManager';
+import type { Local } from './Local';
+import type { WebRTCEndpoint } from '../webRTCEndpoint';
+/**
+ * This class is responsible for handling asynchronous operations related to track management.
+ * It contains methods and state associated with handling a single operation
+ * (adding, removing, and replacing a track).
+ * It facilitates the preparation of events that will later be handled by the `CommandsQueue`.
+ * It informs the `CommandsQueue` whether the previous task has been completed
+ *
+ * Adding and removing tracks requires renegotiation.
+ *
+ * Replacing a track relies on `ongoingTrackReplacement`, which probably could be removed
+ * and replaced with a Promise, because it does not require renegotiation.
+ */
+export declare class LocalTrackManager<EndpointMetadata, TrackMetadata> {
+    connection?: ConnectionManager;
+    private readonly local;
+    ongoingTrackReplacement: boolean;
+    /**
+     * Indicates if an ongoing renegotiation is active.
+     * During renegotiation, both parties are expected to actively exchange events: renegotiateTracks, offerData, sdpOffer, sdpAnswer.
+     */
+    ongoingRenegotiation: boolean;
+    private readonly sendMediaEvent;
+    constructor(local: Local<EndpointMetadata, TrackMetadata>, sendMediaEvent: (mediaEvent: MediaEvent) => void);
+    isNegotiationInProgress: () => boolean;
+    cleanUp: () => void;
+    parseAddTrack: (track: MediaStreamTrack, simulcastConfig: SimulcastConfig, maxBandwidth: TrackBandwidthLimit) => void;
+    addTrackHandler: (trackId: string, track: MediaStreamTrack, stream: MediaStream, trackMetadata: TrackMetadata | undefined, simulcastConfig: SimulcastConfig, maxBandwidth: TrackBandwidthLimit) => void;
+    removeTrackHandler: (trackId: string) => void;
+    replaceTrackHandler: (webrtc: WebRTCEndpoint<EndpointMetadata, TrackMetadata>, trackId: string, newTrack: MediaStreamTrack | null, newTrackMetadata?: TrackMetadata) => Promise<void>;
+    getEndpointId: () => string;
+    updateConnection: (connection: ConnectionManager) => void;
+    updateSenders: () => void;
+}

package/dist/src/webrtc/tracks/LocalTrackManager.js

@@ -0,0 +1,83 @@
+import { generateCustomEvent } from '../mediaEvent';
+/**
+ * This class is responsible for handling asynchronous operations related to track management.
+ * It contains methods and state associated with handling a single operation
+ * (adding, removing, and replacing a track).
+ * It facilitates the preparation of events that will later be handled by the `CommandsQueue`.
+ * It informs the `CommandsQueue` whether the previous task has been completed
+ *
+ * Adding and removing tracks requires renegotiation.
+ *
+ * Replacing a track relies on `ongoingTrackReplacement`, which probably could be removed
+ * and replaced with a Promise, because it does not require renegotiation.
+ */
+export class LocalTrackManager {
+    connection;
+    local;
+    ongoingTrackReplacement = false;
+    /**
+     * Indicates if an ongoing renegotiation is active.
+     * During renegotiation, both parties are expected to actively exchange events: renegotiateTracks, offerData, sdpOffer, sdpAnswer.
+     */
+    ongoingRenegotiation = false;
+    sendMediaEvent;
+    constructor(local, sendMediaEvent) {
+        this.local = local;
+        this.sendMediaEvent = sendMediaEvent;
+    }
+    isNegotiationInProgress = () => {
+        return this.ongoingRenegotiation || this.ongoingTrackReplacement;
+    };
+    cleanUp = () => {
+        this.ongoingTrackReplacement = false;
+        this.ongoingRenegotiation = false;
+    };
+    parseAddTrack = (track, simulcastConfig, maxBandwidth) => {
+        if (this.getEndpointId() === '') {
+            throw new Error('Cannot add tracks before being accepted by the server');
+        }
+        if (!simulcastConfig.enabled && !(typeof maxBandwidth === 'number')) {
+            throw new Error('Invalid type of `maxBandwidth` argument for a non-simulcast track, expected: number');
+        }
+        if (this.connection?.isTrackInUse(track)) {
+            throw new Error("This track was already added to peerConnection, it can't be added again!");
+        }
+    };
+    addTrackHandler = (trackId, track, stream, trackMetadata, simulcastConfig, maxBandwidth) => {
+        this.ongoingRenegotiation = true;
+        const trackManager = this.local.addTrack(this.connection, trackId, track, stream, trackMetadata, simulcastConfig, maxBandwidth);
+        if (this.connection) {
+            trackManager.addTrackToConnection();
+            this.connection.setTransceiverDirection();
+        }
+        const mediaEvent = generateCustomEvent({ type: 'renegotiateTracks' });
+        this.sendMediaEvent(mediaEvent);
+    };
+    removeTrackHandler = (trackId) => {
+        if (!this.connection)
+            throw new Error(`There is no active RTCPeerConnection`);
+        this.ongoingRenegotiation = true;
+        this.local.removeTrack(trackId);
+    };
+    replaceTrackHandler = async (
+    // todo remove webrtc with newTrackMetadata
+    webrtc, trackId, newTrack, 
+    // todo remove webrtc with newTrackMetadata
+    newTrackMetadata) => {
+        this.ongoingTrackReplacement = true;
+        try {
+            await this.local.replaceTrack(webrtc, trackId, newTrack, newTrackMetadata);
+        }
+        catch (e) {
+            this.ongoingTrackReplacement = false;
+        }
+        this.ongoingTrackReplacement = false;
+    };
+    getEndpointId = () => this.local.getEndpoint().id;
+    updateConnection = (connection) => {
+        this.connection = connection;
+    };
+    updateSenders = () => {
+        this.local.updateSenders();
+    };
+}

package/dist/src/webrtc/tracks/Remote.d.ts

@@ -0,0 +1,38 @@
+import type { Encoding, EncodingReason, MetadataParser, MLineId, SimulcastConfig, TrackContext, WebRTCEndpointEvents } from '../types';
+import { RemoteTrack } from './RemoteTrack';
+import type { EndpointWithTrackContext } from '../internal';
+import { type MediaEvent } from '../mediaEvent';
+import type { EndpointId, TrackId } from './TrackCommon';
+type SDPTrack = {
+    metadata: null;
+    simulcastConfig: SimulcastConfig;
+};
+export declare class Remote<EndpointMetadata, TrackMetadata> {
+    private readonly remoteTracks;
+    private readonly remoteEndpoints;
+    private readonly endpointMetadataParser;
+    private readonly trackMetadataParser;
+    private readonly emit;
+    private readonly sendMediaEvent;
+    constructor(emit: <E extends keyof Required<WebRTCEndpointEvents<EndpointMetadata, TrackMetadata>>>(event: E, ...args: Parameters<Required<WebRTCEndpointEvents<EndpointMetadata, TrackMetadata>>[E]>) => void, sendMediaEvent: (mediaEvent: MediaEvent) => void, endpointMetadataParser: MetadataParser<EndpointMetadata>, trackMetadataParser: MetadataParser<TrackMetadata>);
+    getTrackByMid: (mid: string) => RemoteTrack<EndpointMetadata, TrackMetadata>;
+    addTracks: (endpointId: EndpointId, tracks: Record<TrackId, SDPTrack>, trackIdToMetadata: Record<TrackId, any>) => void;
+    removeTracks: (trackIds: TrackId[]) => void;
+    removeRemoteTrack: (trackId: TrackId) => void;
+    addRemoteEndpoint: (endpoint: any, sendNotification?: boolean) => void;
+    private addEndpoint;
+    updateRemoteEndpoint: (data: any) => void;
+    private updateEndpointMetadata;
+    removeRemoteEndpoint: (endpointId: EndpointId) => void;
+    updateRemoteTrack: (data: any) => void;
+    private updateTrackMetadata;
+    disableRemoteTrackEncoding: (trackId: TrackId, encoding: Encoding) => void;
+    enableRemoteTrackEncoding: (trackId: TrackId, encoding: Encoding) => void;
+    setRemoteTrackEncoding: (trackId: TrackId, encoding: Encoding, reason: EncodingReason) => void;
+    setRemoteTrackVadStatus: (trackId: TrackId, vadStatus: string) => void;
+    getRemoteTrackContexts: () => Record<string, TrackContext<EndpointMetadata, TrackMetadata>>;
+    getRemoteEndpoints: () => Record<string, EndpointWithTrackContext<EndpointMetadata, TrackMetadata>>;
+    setTargetRemoteTrackEncoding: (trackId: TrackId, variant: Encoding) => void;
+    updateMLineIds: (midToTrackId: Record<MLineId, TrackId>) => void;
+}
+export {};

package/dist/src/webrtc/tracks/Remote.js

@@ -0,0 +1,200 @@
+import { RemoteTrack } from './RemoteTrack';
+import { TrackContextImpl } from '../internal';
+import { isVadStatus } from '../voiceActivityDetection';
+import { generateCustomEvent } from '../mediaEvent';
+export class Remote {
+    remoteTracks = {};
+    remoteEndpoints = {};
+    endpointMetadataParser;
+    trackMetadataParser;
+    emit;
+    sendMediaEvent;
+    constructor(emit, sendMediaEvent, endpointMetadataParser, trackMetadataParser) {
+        this.emit = emit;
+        this.sendMediaEvent = sendMediaEvent;
+        this.endpointMetadataParser = endpointMetadataParser;
+        this.trackMetadataParser = trackMetadataParser;
+    }
+    getTrackByMid = (mid) => {
+        const remoteTrack = Object.values(this.remoteTracks).find((remote) => remote.mLineId === mid);
+        if (!remoteTrack)
+            throw new Error(`Remote track with ${mid} not found`);
+        return remoteTrack;
+    };
+    addTracks = (endpointId, tracks, trackIdToMetadata) => {
+        const endpoint = this.remoteEndpoints[endpointId];
+        if (!endpoint)
+            throw new Error(`Endpoint ${endpointId} not found`);
+        Object.entries(tracks || {})
+            .map(([trackId, { simulcastConfig }]) => {
+            const trackContext = new TrackContextImpl(endpoint, trackId, trackIdToMetadata[trackId], simulcastConfig, this.trackMetadataParser);
+            return new RemoteTrack(trackId, trackContext);
+        })
+            .forEach((remoteTrack) => {
+            this.remoteTracks[remoteTrack.id] = remoteTrack;
+            endpoint.tracks.set(remoteTrack.id, remoteTrack.trackContext);
+            this.emit('trackAdded', remoteTrack.trackContext);
+        });
+    };
+    removeTracks = (trackIds) => {
+        trackIds.forEach((trackId) => {
+            this.removeRemoteTrack(trackId);
+        });
+    };
+    removeRemoteTrack = (trackId) => {
+        const remoteTrack = this.remoteTracks[trackId];
+        if (!remoteTrack)
+            throw new Error(`Track ${trackId} not found`);
+        const remoteEndpoint = this.remoteEndpoints[remoteTrack.trackContext.endpoint.id];
+        if (!remoteEndpoint)
+            throw new Error(`Endpoint ${remoteTrack.trackContext.endpoint.id} not found`);
+        remoteEndpoint.tracks.delete(trackId);
+        delete this.remoteTracks[trackId];
+        this.emit('trackRemoved', remoteTrack.trackContext);
+    };
+    addRemoteEndpoint = (endpoint, sendNotification = true) => {
+        const newEndpoint = {
+            id: endpoint.id,
+            type: endpoint.type,
+            metadata: undefined,
+            rawMetadata: undefined,
+            metadataParsingError: undefined,
+            tracks: new Map(),
+        };
+        // mutation in place
+        this.updateEndpointMetadata(newEndpoint, endpoint.metadata);
+        this.addEndpoint(newEndpoint);
+        this.addTracks(newEndpoint.id, endpoint.tracks, endpoint.trackIdToMetadata);
+        if (sendNotification) {
+            this.emit('endpointAdded', endpoint);
+        }
+    };
+    addEndpoint = (endpoint) => {
+        this.remoteEndpoints[endpoint.id] = endpoint;
+    };
+    updateRemoteEndpoint = (data) => {
+        const endpoint = this.remoteEndpoints[data.id];
+        if (!endpoint)
+            throw new Error(`Endpoint ${data.id} not found`);
+        // mutation in place
+        this.updateEndpointMetadata(endpoint, data.metadata);
+        this.emit('endpointUpdated', endpoint);
+    };
+    updateEndpointMetadata = (endpoint, metadata) => {
+        try {
+            endpoint.metadata = this.endpointMetadataParser(metadata);
+            endpoint.metadataParsingError = undefined;
+        }
+        catch (error) {
+            endpoint.metadata = undefined;
+            endpoint.metadataParsingError = error;
+        }
+        endpoint.rawMetadata = metadata;
+    };
+    removeRemoteEndpoint = (endpointId) => {
+        const endpoint = this.remoteEndpoints[endpointId];
+        if (!endpoint)
+            throw new Error(`Endpoint ${endpointId} not found`);
+        const trackIds = [...endpoint.tracks.values()].map(({ trackId }) => trackId);
+        this.removeTracks(trackIds);
+        delete this.remoteEndpoints[endpointId];
+        this.emit('endpointRemoved', endpoint);
+    };
+    updateRemoteTrack = (data) => {
+        const endpointId = data.endpointId;
+        const endpoint = this.remoteEndpoints[endpointId];
+        if (!endpoint)
+            throw new Error(`Endpoint ${endpointId} not found`);
+        const trackId = data.trackId;
+        const remoteTrack = this.remoteTracks[trackId];
+        if (!remoteTrack)
+            throw new Error(`Track ${trackId} not found`);
+        this.updateTrackMetadata(remoteTrack.trackContext, data.metadata);
+        this.emit('trackUpdated', remoteTrack.trackContext);
+    };
+    updateTrackMetadata = (trackContext, trackMetadata) => {
+        try {
+            trackContext.metadata = this.trackMetadataParser(trackMetadata);
+            trackContext.metadataParsingError = undefined;
+        }
+        catch (error) {
+            trackContext.metadataParsingError = error;
+            trackContext.metadata = undefined;
+        }
+        trackContext.rawMetadata = trackMetadata;
+    };
+    disableRemoteTrackEncoding = (trackId, encoding) => {
+        const remoteTrack = this.remoteTracks[trackId];
+        if (!remoteTrack)
+            throw new Error(`Track ${trackId} not found`);
+        remoteTrack.disableTrackEncoding(encoding);
+        this.emit('trackEncodingDisabled', remoteTrack.trackContext, encoding);
+    };
+    enableRemoteTrackEncoding = (trackId, encoding) => {
+        const remoteTrack = this.remoteTracks[trackId];
+        if (!remoteTrack)
+            throw new Error(`Track ${trackId} not found`);
+        remoteTrack.enableTrackEncoding(encoding);
+        this.emit('trackEncodingEnabled', remoteTrack.trackContext, encoding);
+    };
+    setRemoteTrackEncoding = (trackId, encoding, reason) => {
+        const remoteTrack = this.remoteTracks[trackId];
+        if (!remoteTrack)
+            throw new Error(`Track ${trackId} not found`);
+        remoteTrack.trackContext.encoding = encoding;
+        remoteTrack.trackContext.encodingReason = reason;
+        remoteTrack.trackContext.emit('encodingChanged', remoteTrack.trackContext);
+    };
+    setRemoteTrackVadStatus = (trackId, vadStatus) => {
+        const remoteTrack = this.remoteTracks[trackId];
+        if (!remoteTrack)
+            throw new Error(`Track ${trackId} not found`);
+        if (isVadStatus(vadStatus)) {
+            remoteTrack.trackContext.vadStatus = vadStatus;
+            remoteTrack.trackContext.emit('voiceActivityChanged', remoteTrack.trackContext);
+        }
+        else {
+            console.warn('Received unknown vad status: ', vadStatus);
+        }
+    };
+    getRemoteTrackContexts = () => {
+        return Object.values(this.remoteTracks).reduce((acc, current) => ({
+            ...acc,
+            [current.trackContext.trackId]: current.trackContext,
+        }), {});
+    };
+    getRemoteEndpoints = () => {
+        return Object.values(this.remoteEndpoints).reduce((acc, current) => ({ ...acc, [current.id]: current }), {});
+    };
+    setTargetRemoteTrackEncoding = (trackId, variant) => {
+        const remoteTrack = this.remoteTracks[trackId];
+        if (!remoteTrack)
+            throw new Error(`Track ${trackId} not found`);
+        try {
+            remoteTrack.setTargetTrackEncoding(variant);
+            const mediaEvent = generateCustomEvent({
+                type: 'setTargetTrackVariant',
+                data: {
+                    trackId: trackId,
+                    variant,
+                },
+            });
+            this.sendMediaEvent(mediaEvent);
+            this.emit('targetTrackEncodingRequested', {
+                trackId,
+                variant,
+            });
+        }
+        catch (e) {
+            console.warn(e);
+        }
+    };
+    updateMLineIds = (midToTrackId) => {
+        Object.entries(midToTrackId).forEach(([mLineId, trackId]) => {
+            const remoteTrack = this.remoteTracks[trackId];
+            if (remoteTrack) {
+                remoteTrack.setMLineId(mLineId);
+            }
+        });
+    };
+}

package/dist/src/webrtc/tracks/RemoteTrack.d.ts

@@ -0,0 +1,39 @@
+import type { TrackCommon, TrackEncodings, TrackId } from './TrackCommon';
+import type { LocalTrackId, MLineId, Encoding } from '../types';
+import type { TrackContextImpl } from '../internal';
+/**
+ * This is a wrapper over `TrackContext` that adds additional properties such as:
+ * - `MLineId`: required to generate sdpOffer
+ *
+ * # Lifecycle, state transitions
+ *
+ * I identified the following states
+ * - on `trackAdded`
+ *   - trackContext.stream === null
+ *   - trackContext.track === null
+ *   - trackContext.trackKind === null
+ *   - mLineId === null
+ * - on `onSdpAnswer`
+ *   - trackContext.stream === null
+ *   - trackContext.track === null
+ *   - trackContext.trackKind === null
+ *   - mLineId !== null
+ * - on `trackReady`
+ *   - trackContext.stream !== null
+ *   - trackContext.track !== null
+ *   - trackContext.trackKind !== null
+ *   - mLineId !== null
+ */
+export declare class RemoteTrack<EndpointMetadata, TrackMetadata> implements TrackCommon {
+    id: TrackId;
+    mLineId: MLineId | null;
+    readonly trackContext: TrackContextImpl<EndpointMetadata, TrackMetadata>;
+    readonly encodings: TrackEncodings;
+    private targetEncoding;
+    constructor(id: LocalTrackId, trackContext: TrackContextImpl<EndpointMetadata, TrackMetadata>);
+    setMLineId: (mLineId: MLineId) => void;
+    setReady: (stream: MediaStream, track: MediaStreamTrack) => void;
+    disableTrackEncoding: (encoding: Encoding) => void;
+    enableTrackEncoding: (encoding: Encoding) => void;
+    setTargetTrackEncoding: (variant: Encoding) => void;
+}