@fishjam-cloud/webrtc-client 0.14.0

package/dist/webrtc-client/src/tracks/Local.js

@@ -0,0 +1,243 @@
+import { MediaEvent as PeerMediaEvent, MediaEvent_DisableTrackVariant, MediaEvent_EnableTrackVariant, MediaEvent_RenegotiateTracks, MediaEvent_SdpOffer, MediaEvent_TrackBitrates, MediaEvent_UpdateEndpointMetadata, MediaEvent_UpdateTrackMetadata, } from '@fishjam-cloud/protobufs/peer';
+import { Variant } from '@fishjam-cloud/protobufs/shared';
+import { isTrackKind, TrackContextImpl } from '../internal';
+import { LocalTrack } from './LocalTrack';
+/**
+ * This class encapsulates methods related to handling the list of local tracks and local endpoint.
+ * It stores and mutates part of the client state for this local peer.
+ * It emits local events for local tracks and endpoints,
+ * and delegates mutation logic to the appropriate `LocalTrack` objects.
+ * It's responsible for creating `MidToTrackId` record which is required in `sdpOffer`
+ */
+export class Local {
+    localTracks = {};
+    localEndpoint = {
+        id: '',
+        type: 'webrtc',
+        metadata: undefined,
+        tracks: new Map(),
+    };
+    emit;
+    sendMediaEvent;
+    connection = null;
+    constructor(emit, sendMediaEvent) {
+        this.emit = emit;
+        this.sendMediaEvent = sendMediaEvent;
+    }
+    updateSenders = () => {
+        Object.values(this.localTracks).forEach((localTrack) => {
+            localTrack.updateSender();
+        });
+    };
+    updateMLineIds = (midToTrackIds) => {
+        Object.entries(midToTrackIds).forEach(([mid, trackId]) => {
+            this.localTracks[trackId]?.setMLineId(mid);
+        });
+    };
+    updateConnection = (connection) => {
+        this.connection = connection;
+        Object.values(this.localTracks).forEach((track) => {
+            track.updateConnection(connection);
+        });
+    };
+    createSdpOfferEvent = (sdpOffer) => {
+        const trackIdToMetadataJson = this.getTrackIdToMetadataJson();
+        const trackIdToBitrates = this.getTrackIdToTrackBitrates();
+        const midToTrackId = this.getMidToTrackId();
+        return MediaEvent_SdpOffer.create({
+            sdp: sdpOffer.sdp,
+            midToTrackId,
+            trackIdToBitrates,
+            trackIdToMetadataJson,
+        });
+    };
+    addTrack = (connection, trackId, track, stream, trackMetadata, simulcastConfig, maxBandwidth) => {
+        const trackContext = new TrackContextImpl(this.localEndpoint, trackId, trackMetadata, simulcastConfig);
+        trackContext.track = track;
+        trackContext.stream = stream;
+        trackContext.maxBandwidth = maxBandwidth;
+        if (!isTrackKind(track.kind))
+            throw new Error('Track has no kind');
+        trackContext.trackKind = track.kind;
+        this.localEndpoint.tracks.set(trackId, trackContext);
+        const trackManager = new LocalTrack(connection, trackId, trackContext);
+        this.localTracks[trackId] = trackManager;
+        return trackManager;
+    };
+    getTrackByMidOrNull = (mid) => {
+        return Object.values(this.localTracks).find((track) => track.mLineId === mid) ?? null;
+    };
+    removeTrack = (trackId) => {
+        const trackManager = this.localTracks[trackId];
+        if (!trackManager)
+            throw new Error(`Cannot find ${trackId}`);
+        trackManager.removeFromConnection();
+        const renegotiateTracks = MediaEvent_RenegotiateTracks.create({});
+        this.sendMediaEvent({ renegotiateTracks });
+        this.localEndpoint.tracks.delete(trackId);
+        delete this.localTracks[trackId];
+    };
+    replaceTrack = async (webrtc, trackId, newTrack) => {
+        // TODO add validation to track.kind, you cannot replace video with audio
+        const trackManager = this.localTracks[trackId];
+        if (!trackManager)
+            throw new Error(`Cannot find ${trackId}`);
+        await trackManager.replaceTrack(newTrack, webrtc);
+    };
+    setEndpointMetadata = (metadata) => {
+        this.localEndpoint.metadata = metadata;
+    };
+    getEndpoint = () => {
+        return this.localEndpoint;
+    };
+    setTrackBandwidth = async (trackId, bandwidth) => {
+        // FIXME: maxBandwidth in TrackContext is not updated
+        const trackManager = this.localTracks[trackId];
+        if (!trackManager)
+            throw new Error(`Cannot find ${trackId}`);
+        await trackManager.setTrackBandwidth(bandwidth);
+        const trackBitrates = MediaEvent_TrackBitrates.create({
+            trackId,
+            variantBitrates: [{ variant: Variant.VARIANT_UNSPECIFIED, bitrate: bandwidth }],
+        });
+        this.sendMediaEvent(PeerMediaEvent.create({ trackBitrates }));
+        this.emit('localTrackBandwidthSet', {
+            trackId,
+            bandwidth,
+        });
+    };
+    getTrackIdToTrack = () => {
+        const entries = Object.values(this.localTracks).map((track) => [track.id, track.trackContext]);
+        return new Map(entries);
+    };
+    setLocalEndpointId = (endpointId) => {
+        this.localEndpoint.id = endpointId;
+    };
+    setEncodingBandwidth = async (trackId, rid, bandwidth) => {
+        const trackManager = this.localTracks[trackId];
+        if (!trackManager)
+            throw new Error(`Cannot find ${trackId}`);
+        await trackManager.setEncodingBandwidth(rid, bandwidth);
+        const bitrates = trackManager.getTrackBitrates();
+        let variantBitrates = [];
+        if (typeof bitrates === 'number') {
+            variantBitrates = [{ variant: Variant.VARIANT_UNSPECIFIED, bitrate: bitrates }];
+        }
+        else if (bitrates) {
+            variantBitrates = Object.entries(bitrates).map(([variant, bitrate]) => ({
+                variant: Number(variant),
+                bitrate,
+            }));
+        }
+        const trackBitrates = MediaEvent_TrackBitrates.create({
+            trackId,
+            variantBitrates,
+        });
+        this.sendMediaEvent(PeerMediaEvent.create({ trackBitrates }));
+        this.emit('localTrackEncodingBandwidthSet', {
+            trackId,
+            rid,
+            bandwidth,
+        });
+    };
+    updateEndpointMetadata = (metadata) => {
+        this.localEndpoint.metadata = metadata;
+        const updateEndpointMetadata = MediaEvent_UpdateEndpointMetadata.create({
+            metadataJson: JSON.stringify(this.localEndpoint.metadata),
+        });
+        this.sendMediaEvent({ updateEndpointMetadata });
+        this.emit('localEndpointMetadataChanged', {
+            metadata: this.localEndpoint.metadata,
+        });
+    };
+    updateLocalTrackMetadata = (trackId, metadata) => {
+        const trackManager = this.localTracks[trackId];
+        if (!trackManager)
+            throw new Error(`Cannot find ${trackId}`);
+        trackManager.updateTrackMetadata(metadata);
+        const trackContext = trackManager.trackContext;
+        const updateTrackMetadata = MediaEvent_UpdateTrackMetadata.create({
+            trackId,
+            metadataJson: metadata ? JSON.stringify(metadata) : undefined,
+        });
+        switch (trackContext.negotiationStatus) {
+            case 'done':
+                this.sendMediaEvent({ updateTrackMetadata });
+                this.emit('localTrackMetadataChanged', {
+                    trackId,
+                    metadata: trackContext.metadata,
+                });
+                break;
+            case 'offered':
+                trackContext.pendingMetadataUpdate = true;
+                break;
+            case 'awaiting':
+                // We don't need to do anything
+                break;
+        }
+    };
+    disableLocalTrackEncoding = async (trackId, encoding) => {
+        const localTrack = this.localTracks[trackId];
+        if (!localTrack)
+            throw new Error(`Track ${trackId} not found`);
+        await localTrack.disableTrackEncoding(encoding);
+        const disableTrackVariant = MediaEvent_DisableTrackVariant.create({ trackId, variant: encoding });
+        this.sendMediaEvent(PeerMediaEvent.create({ disableTrackVariant }));
+        this.emit('localTrackEncodingEnabled', {
+            trackId,
+            encoding,
+        });
+    };
+    enableLocalTrackEncoding = async (trackId, variant) => {
+        const trackManager = this.localTracks[trackId];
+        if (!trackManager)
+            throw new Error(`Cannot find ${trackId}`);
+        await trackManager.enableTrackEncoding(variant);
+        const enableTrackVariant = MediaEvent_EnableTrackVariant.create({ trackId, variant });
+        this.sendMediaEvent(PeerMediaEvent.create({ enableTrackVariant }));
+        this.emit('localTrackEncodingEnabled', {
+            trackId,
+            encoding: variant,
+        });
+    };
+    getTrackIdToMetadataJson = () => Object.values(this.localTracks).reduce((acc, { id, trackContext }) => ({ ...acc, [id]: JSON.stringify(trackContext.metadata) }), {});
+    // TODO add bitrates
+    getTrackIdToTrackBitrates = () => Object.values(this.localTracks).reduce((acc, { id }) => ({ ...acc, [id]: { bitrate: 1_500_000 } }), {});
+    getMidToTrackId = () => {
+        if (!this.connection)
+            return {};
+        // - negotiated unmuted tracks: tracks added in previous negotiation, data is being transmitted
+        // - not yet negotiated tracks: tracks added in this negotiation, data will be transmitted after successful negotiation
+        const mappingFromTransceivers = this.getTransceiverMapping();
+        // - negotiated unmuted tracks: tracks added in previous negotiation, data is being transmitted
+        // - negotiated muted tracks: tracks added in previous negotiation, data is not being transmitted but can be transmitted in the future
+        const mappingFromLocalNegotiatedTracks = Object.values(this.localTracks)
+            .filter((track) => !!track.mLineId)
+            .reduce((acc, { id, mLineId }) => ({ ...acc, [mLineId]: id }), {});
+        return { ...mappingFromTransceivers, ...mappingFromLocalNegotiatedTracks };
+    };
+    getTransceiverMapping = () => {
+        if (!this.connection)
+            return {};
+        return this.connection
+            .getConnection()
+            .getTransceivers()
+            .filter((transceiver) => Boolean(transceiver.sender.track?.id && transceiver.mid))
+            .reduce((acc, { sender, mid }) => {
+            const localTrack = Object.values(this.localTracks).find((track) => track.mediaStreamTrackId === sender.track.id);
+            if (!localTrack)
+                throw new Error('Local track not found');
+            return { ...acc, [mid]: localTrack.id };
+        }, {});
+    };
+    setLocalTrackStatusToOffered = () => {
+        Object.values(this.localTracks).forEach((localTrack) => {
+            localTrack.trackContext.negotiationStatus = 'offered';
+        });
+    };
+    addAllTracksToConnection = () => {
+        Object.values(this.localTracks).forEach((localTrack) => {
+            localTrack.addTrackToConnection();
+        });
+    };
+}

package/dist/webrtc-client/src/tracks/LocalTrack.d.ts

@@ -0,0 +1,61 @@
+import { Variant } from '@fishjam-cloud/protobufs/shared';
+import type { Bitrates } from '../bitrate';
+import type { ConnectionManager } from '../ConnectionManager';
+import type { TrackContextImpl } from '../internal';
+import type { BandwidthLimit, LocalTrackId, MediaStreamTrackId, MLineId } from '../types';
+import type { WebRTCEndpoint } from '../webRTCEndpoint';
+import type { TrackCommon, TrackEncodings, TrackId } from './TrackCommon';
+/**
+ * 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 declare class LocalTrack implements TrackCommon {
+    readonly id: TrackId;
+    mediaStreamTrackId: MediaStreamTrackId | null;
+    mLineId: MLineId | null;
+    readonly trackContext: TrackContextImpl;
+    private sender;
+    readonly encodings: TrackEncodings;
+    connection: ConnectionManager | undefined;
+    constructor(connection: ConnectionManager | undefined, id: LocalTrackId, trackContext: TrackContextImpl);
+    updateSender: () => void;
+    updateConnection: (connection: ConnectionManager) => void;
+    disableTrackEncoding: (encoding: Variant) => Promise<void>;
+    addTrackToConnection: () => void;
+    private updateEncodings;
+    removeFromConnection: () => void;
+    replaceTrack: (newTrack: MediaStreamTrack | null, webrtc: WebRTCEndpoint) => Promise<void>;
+    setTrackBandwidth: (bandwidth: BandwidthLimit) => Promise<void>;
+    setEncodingBandwidth(variant: Variant, bandwidth: BandwidthLimit): Promise<void>;
+    updateTrackMetadata: (metadata: unknown) => void;
+    enableTrackEncoding: (encoding: Variant) => Promise<void>;
+    setMLineId: (mLineId: MLineId) => void;
+    private isNotSimulcastTrack;
+    getTrackBitrates: () => Bitrates | undefined;
+    createTrackVariantBitratesEvent: () => void;
+}

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

@@ -0,0 +1,212 @@
+import { Variant } from '@fishjam-cloud/protobufs/shared';
+import { defaultBitrates, defaultSimulcastBitrates, UNLIMITED_BANDWIDTH } from '../bitrate';
+import { encodingToVariantMap, getEncodingParameters } from './encodings';
+import { emitMutableEvents, getActionType } from './muteTrackUtils';
+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 = {
+        [Variant.UNRECOGNIZED]: false,
+        [Variant.VARIANT_UNSPECIFIED]: false,
+        [Variant.VARIANT_LOW]: false,
+        [Variant.VARIANT_MEDIUM]: false,
+        [Variant.VARIANT_HIGH]: false,
+    };
+    connection;
+    constructor(connection, id, trackContext) {
+        this.connection = connection;
+        this.id = id;
+        this.trackContext = trackContext;
+        // todo maybe we could remove this object and use sender.getParameters().encodings.encodingParameter.active instead
+        if (trackContext.track?.id) {
+            this.mediaStreamTrackId = trackContext.track?.id;
+        }
+    }
+    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 && encodingToVariantMap[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);
+    };
+    updateEncodings = () => {
+        const enabledVariants = this.trackContext.simulcastConfig?.enabledVariants;
+        if (this.trackContext?.track?.kind === 'video' && enabledVariants) {
+            this.encodings[Variant.VARIANT_LOW] = enabledVariants.some((e) => e === Variant.VARIANT_LOW);
+            this.encodings[Variant.VARIANT_MEDIUM] = enabledVariants.some((e) => e === Variant.VARIANT_MEDIUM);
+            this.encodings[Variant.VARIANT_HIGH] = enabledVariants.some((e) => e === Variant.VARIANT_HIGH);
+        }
+    };
+    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);
+    };
+    replaceTrack = async (newTrack, webrtc) => {
+        const trackId = this.id;
+        const stream = this.trackContext.stream;
+        const oldTrack = this.trackContext.track;
+        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);
+        }
+        this.trackContext.track = newTrack;
+        this.mediaStreamTrackId = newTrack?.id ?? null;
+        const action = getActionType(this.trackContext.track, newTrack);
+        if (action === 'mute' || action === 'unmute') {
+            emitMutableEvents(action, webrtc, trackId);
+        }
+        try {
+            await this.sender.replaceTrack(newTrack);
+        }
+        catch (_error) {
+            // rollback: emit opposite events and revert internal state
+            if (action === 'mute') {
+                emitMutableEvents('unmute', webrtc, trackId);
+            }
+            else if (action === 'unmute') {
+                emitMutableEvents('mute', webrtc, trackId);
+            }
+            this.trackContext.track = oldTrack;
+            this.mediaStreamTrackId = oldTrack?.id ?? null;
+        }
+    };
+    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(variant, bandwidth) {
+        if (!this.sender)
+            throw new Error(`RTCRtpSender for track ${this.id} not found`);
+        const parameters = this.sender.getParameters();
+        const encoding = parameters.encodings.find((enc) => enc.rid && encodingToVariantMap[enc.rid] === variant);
+        if (!encoding) {
+            return Promise.reject(`Encoding with Variant '${variant}' doesn't exist`);
+        }
+        else if (bandwidth === 0) {
+            delete encoding.maxBitrate;
+        }
+        else {
+            encoding.maxBitrate = bandwidth * 1024;
+        }
+        return this.sender.setParameters(parameters);
+    }
+    updateTrackMetadata = (metadata) => {
+        this.trackContext.metadata = metadata;
+    };
+    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 && encodingToVariantMap[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);
+    };
+    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)
+            return undefined;
+        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 variant = encodingToVariantMap[encoding.rid] ?? Variant.VARIANT_UNSPECIFIED;
+            acc[variant] = encoding.maxBitrate || defaultSimulcastBitrates[variant];
+            return acc;
+        }, {});
+    };
+    createTrackVariantBitratesEvent = () => {
+        // TODO implement this when simulcast is supported
+        // return generateCustomEvent({
+        //   type: 'trackVariantBitrates',
+        //   data: {
+        //     trackId: this.id,
+        //     variantBitrates: this.getTrackBitrates(),
+        //   },
+        // });
+    };
+}

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

@@ -0,0 +1,39 @@
+import { type MediaEvent as PeerMediaEvent } from '@fishjam-cloud/protobufs/peer';
+import type { SimulcastConfig } from '..';
+import type { ConnectionManager } from '../ConnectionManager';
+import type { TrackBandwidthLimit } from '../types';
+import type { WebRTCEndpoint } from '../webRTCEndpoint';
+import type { Local } from './Local';
+/**
+ * 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 {
+    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, sendMediaEvent: (mediaEvent: PeerMediaEvent) => void);
+    isNegotiationInProgress: () => boolean;
+    cleanUp: () => void;
+    parseAddTrack: (track: MediaStreamTrack, simulcastConfig: SimulcastConfig, maxBandwidth: TrackBandwidthLimit) => void;
+    addTrackHandler: (trackId: string, track: MediaStreamTrack, stream: MediaStream, trackMetadata: unknown | undefined, simulcastConfig: SimulcastConfig, maxBandwidth: TrackBandwidthLimit) => void;
+    removeTrackHandler: (trackId: string) => void;
+    replaceTrackHandler: (webrtc: WebRTCEndpoint, trackId: string, newTrack: MediaStreamTrack | null) => Promise<void>;
+    getEndpointId: () => string;
+    updateConnection: (connection: ConnectionManager) => void;
+    updateSenders: () => void;
+}

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

@@ -0,0 +1,76 @@
+import { MediaEvent_RenegotiateTracks } from '@fishjam-cloud/protobufs/peer';
+/**
+ * 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.sendMediaEvent({ renegotiateTracks: MediaEvent_RenegotiateTracks.create() });
+    };
+    removeTrackHandler = (trackId) => {
+        if (!this.connection)
+            throw new Error(`There is no active RTCPeerConnection`);
+        this.ongoingRenegotiation = true;
+        this.local.removeTrack(trackId);
+    };
+    replaceTrackHandler = async (webrtc, trackId, newTrack) => {
+        this.ongoingTrackReplacement = true;
+        try {
+            await this.local.replaceTrack(webrtc, trackId, newTrack);
+        }
+        finally {
+            this.ongoingTrackReplacement = false;
+        }
+    };
+    getEndpointId = () => this.local.getEndpoint().id;
+    updateConnection = (connection) => {
+        this.connection = connection;
+    };
+    updateSenders = () => {
+        this.local.updateSenders();
+    };
+}

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

@@ -0,0 +1,32 @@
+import type { MediaEvent as PeerMediaEvent } from '@fishjam-cloud/protobufs/peer';
+import type { MediaEvent_Track } from '@fishjam-cloud/protobufs/server';
+import { MediaEvent_VadNotification_Status } from '@fishjam-cloud/protobufs/server';
+import type { Variant } from '@fishjam-cloud/protobufs/shared';
+import type { EndpointWithTrackContext } from '../internal';
+import type { EncodingReason, MetadataJson, RemoteTrackId, TrackContext, WebRTCEndpointEvents } from '../types';
+import { RemoteTrack } from './RemoteTrack';
+import type { EndpointId, TrackId } from './TrackCommon';
+export declare class Remote {
+    private readonly remoteTracks;
+    private readonly remoteEndpoints;
+    private readonly emit;
+    private readonly sendMediaEvent;
+    constructor(emit: <E extends keyof Required<WebRTCEndpointEvents>>(event: E, ...args: Parameters<Required<WebRTCEndpointEvents>[E]>) => void, sendMediaEvent: (mediaEvent: PeerMediaEvent) => void);
+    getTrackByMid: (mid: string) => RemoteTrack;
+    addTracks: (endpointId: EndpointId, tracks: Record<TrackId, MediaEvent_Track>) => void;
+    removeTracks: (trackIds: TrackId[]) => void;
+    private removeRemoteTrack;
+    addRemoteEndpoint: (endpointId: string, metadataJson?: MetadataJson, tracks?: Record<RemoteTrackId, MediaEvent_Track>, sendNotification?: boolean) => void;
+    private addEndpoint;
+    updateRemoteEndpoint: (endpointId: string, metadataJson?: MetadataJson) => void;
+    removeRemoteEndpoint: (endpointId: EndpointId) => void;
+    updateRemoteTrack: (endpointId: string, trackId: string, metadataJson?: MetadataJson) => void;
+    disableRemoteTrackEncoding: (trackId: TrackId, encoding: Variant) => void;
+    enableRemoteTrackEncoding: (trackId: TrackId, encoding: Variant) => void;
+    setRemoteTrackEncoding: (trackId: TrackId, encoding: Variant, reason?: EncodingReason) => void;
+    setRemoteTrackVadStatus: (trackId: TrackId, vadStatus: MediaEvent_VadNotification_Status) => void;
+    getRemoteTrackContexts: () => Record<string, TrackContext>;
+    getRemoteEndpoints: () => Record<string, EndpointWithTrackContext>;
+    setTargetRemoteTrackEncoding: (trackId: TrackId, variant: Variant) => void;
+    updateMLineIds: (midToTrackIds: Record<string, string>) => void;
+}