@fishjam-cloud/ts-client 0.5.1

package/dist/src/webrtc/ConnectionManager.js

@@ -0,0 +1,82 @@
+export class ConnectionManager {
+    connection;
+    constructor(turnServers) {
+        this.connection = new RTCPeerConnection({
+            bundlePolicy: 'max-bundle',
+            iceServers: this.getIceServers(turnServers),
+            iceTransportPolicy: 'relay',
+        });
+    }
+    isConnectionUnstable = () => {
+        if (!this.connection)
+            return false;
+        const isSignalingUnstable = this.connection.signalingState !== 'stable';
+        const isConnectionNotConnected = this.connection.connectionState !== 'connected';
+        const isIceNotConnected = this.connection.iceConnectionState !== 'connected';
+        return isSignalingUnstable && isConnectionNotConnected && isIceNotConnected;
+    };
+    /**
+     * Configures TURN servers for WebRTC connections by adding them to the provided RTCConfiguration object.
+     */
+    getIceServers = (turnServers) => {
+        return turnServers.map((turnServer) => {
+            const transport = turnServer.transport === 'tls' ? 'tcp' : turnServer.transport;
+            const uri = turnServer.transport === 'tls' ? 'turns' : 'turn';
+            const address = turnServer.serverAddr;
+            const port = turnServer.serverPort;
+            return {
+                credential: turnServer.password,
+                urls: uri.concat(':', address, ':', port, '?transport=', transport),
+                username: turnServer.username,
+            };
+        });
+    };
+    getConnection = () => {
+        return this.connection;
+    };
+    setTransceiversToReadOnly = () => {
+        this.connection
+            .getTransceivers()
+            .forEach((transceiver) => (transceiver.direction = 'sendonly'));
+    };
+    addTransceiversIfNeeded = (serverTracks) => {
+        const recvTransceivers = this.connection
+            .getTransceivers()
+            .filter((elem) => elem.direction === 'recvonly');
+        ['audio', 'video']
+            .flatMap((type) => this.getNeededTransceiversTypes(type, recvTransceivers, serverTracks))
+            .forEach((kind) => this.connection.addTransceiver(kind, { direction: 'recvonly' }));
+    };
+    getNeededTransceiversTypes = (type, recvTransceivers, serverTracks) => {
+        const typeNumber = serverTracks.get(type) ?? 0;
+        const typeTransceiversNumber = recvTransceivers.filter((elem) => elem.receiver.track.kind === type).length;
+        return Array(typeNumber - typeTransceiversNumber).fill(type);
+    };
+    addTransceiver = (track, transceiverConfig) => {
+        this.connection.addTransceiver(track, transceiverConfig);
+    };
+    setOnTrackReady = (onTrackReady) => {
+        this.connection.ontrack = onTrackReady;
+    };
+    setRemoteDescription = async (data) => {
+        await this.connection.setRemoteDescription(data);
+    };
+    isTrackInUse = (track) => this.connection.getSenders().some((val) => val.track === track);
+    setTransceiverDirection = () => {
+        this.connection
+            .getTransceivers()
+            .filter((transceiver) => transceiver.direction === 'sendrecv')
+            .forEach((transceiver) => {
+            transceiver.direction = 'sendonly';
+        });
+    };
+    removeTrack = (sender) => {
+        this.connection.removeTrack(sender);
+    };
+    findSender = (mediaStreamTrackId) => this.connection
+        .getSenders()
+        .find((sender) => sender.track && sender.track.id === mediaStreamTrackId);
+    addIceCandidate = async (iceCandidate) => {
+        await this.connection.addIceCandidate(iceCandidate);
+    };
+}

package/dist/src/webrtc/bitrate.d.ts

@@ -0,0 +1,12 @@
+import type { Encoding } from './types';
+import { type BandwidthLimit } from './types';
+export type Bitrate = number;
+export type Bitrates = Record<Encoding, Bitrate> | Bitrate;
+export declare const defaultBitrates: {
+    readonly audio: Bitrate;
+    readonly video: Bitrate;
+};
+export declare const UNLIMITED_BANDWIDTH: Bitrate;
+export declare const defaultSimulcastBitrates: {
+    [key in Encoding]: BandwidthLimit;
+};

package/dist/src/webrtc/bitrate.js

@@ -0,0 +1,12 @@
+// The suggested bitrate values are based on our internal tests.
+export const defaultBitrates = {
+    audio: 50_000,
+    video: 2_500_000,
+};
+export const UNLIMITED_BANDWIDTH = 0;
+// The suggested bitrate values are based on our internal tests.
+export const defaultSimulcastBitrates = {
+    h: 2_500_000,
+    m: 500_000,
+    l: 150_000,
+};

package/dist/src/webrtc/deferred.d.ts

@@ -0,0 +1,8 @@
+export declare class Deferred<T, E = unknown> {
+    promise: Promise<T>;
+    private resolveFn;
+    private rejectFn;
+    constructor();
+    resolve(value: T): void;
+    reject(reason?: E): void;
+}

package/dist/src/webrtc/deferred.js

@@ -0,0 +1,17 @@
+export class Deferred {
+    promise;
+    resolveFn = () => null;
+    rejectFn = () => null;
+    constructor() {
+        this.promise = new Promise((resolve, reject) => {
+            this.resolveFn = resolve;
+            this.rejectFn = reject;
+        });
+    }
+    resolve(value) {
+        this.resolveFn(value);
+    }
+    reject(reason) {
+        this.rejectFn(reason);
+    }
+}

package/dist/src/webrtc/index.d.ts

@@ -0,0 +1,3 @@
+export type { TrackBandwidthLimit, SimulcastBandwidthLimit, BandwidthLimit, WebRTCEndpointEvents, TrackContextEvents, Endpoint, SimulcastConfig, TrackContext, Encoding, VadStatus, EncodingReason, Config, MetadataParser, TrackKind, } from './types';
+export { WebRTCEndpoint } from './webRTCEndpoint';
+export type { SerializedMediaEvent, MediaEvent } from './mediaEvent';

package/dist/src/webrtc/index.js

@@ -0,0 +1 @@
+export { WebRTCEndpoint } from './webRTCEndpoint';

package/dist/src/webrtc/internal.d.ts

@@ -0,0 +1,26 @@
+import type TypedEmitter from 'typed-emitter';
+import type { EncodingReason, Endpoint, MetadataParser, SimulcastConfig, TrackBandwidthLimit, TrackContext, TrackContextEvents, Encoding, TrackKind, TrackNegotiationStatus, VadStatus } from './types';
+export declare const isTrackKind: (kind: string) => kind is TrackKind;
+declare const TrackContextImpl_base: new <EndpointMetadata_1, ParsedMetadata_1>() => TypedEmitter<Required<TrackContextEvents<EndpointMetadata_1, ParsedMetadata_1>>>;
+export declare class TrackContextImpl<EndpointMetadata, ParsedMetadata> extends TrackContextImpl_base<EndpointMetadata, ParsedMetadata> implements TrackContext<EndpointMetadata, ParsedMetadata> {
+    endpoint: Endpoint<EndpointMetadata, ParsedMetadata>;
+    trackId: string;
+    track: MediaStreamTrack | null;
+    trackKind: TrackKind | null;
+    stream: MediaStream | null;
+    metadata?: ParsedMetadata;
+    rawMetadata: any;
+    metadataParsingError?: any;
+    simulcastConfig?: SimulcastConfig;
+    maxBandwidth: TrackBandwidthLimit;
+    encoding?: Encoding;
+    encodingReason?: EncodingReason;
+    vadStatus: VadStatus;
+    negotiationStatus: TrackNegotiationStatus;
+    pendingMetadataUpdate: boolean;
+    constructor(endpoint: Endpoint<EndpointMetadata, ParsedMetadata>, trackId: string, metadata: any, simulcastConfig: SimulcastConfig, metadataParser: MetadataParser<ParsedMetadata>);
+}
+export type EndpointWithTrackContext<EndpointMetadata, TrackMetadata> = Omit<Endpoint<EndpointMetadata, TrackMetadata>, 'tracks'> & {
+    tracks: Map<string, TrackContextImpl<EndpointMetadata, TrackMetadata>>;
+};
+export {};

package/dist/src/webrtc/internal.js

@@ -0,0 +1,34 @@
+import EventEmitter from 'events';
+export const isTrackKind = (kind) => kind === 'audio' || kind === 'video';
+export class TrackContextImpl extends EventEmitter {
+    endpoint;
+    trackId;
+    track = null;
+    trackKind = null;
+    stream = null;
+    metadata;
+    rawMetadata;
+    metadataParsingError;
+    simulcastConfig;
+    maxBandwidth = 0;
+    encoding;
+    encodingReason;
+    vadStatus = 'silence';
+    negotiationStatus = 'awaiting';
+    // Indicates that metadata were changed when in "offered" negotiationStatus
+    // and `updateTrackMetadata` Media Event should be sent after the transition to "done"
+    pendingMetadataUpdate = false;
+    constructor(endpoint, trackId, metadata, simulcastConfig, metadataParser) {
+        super();
+        this.endpoint = endpoint;
+        this.trackId = trackId;
+        try {
+            this.metadata = metadataParser(metadata);
+        }
+        catch (error) {
+            this.metadataParsingError = error;
+        }
+        this.rawMetadata = metadata;
+        this.simulcastConfig = simulcastConfig;
+    }
+}

package/dist/src/webrtc/mediaEvent.d.ts

@@ -0,0 +1,10 @@
+export type SerializedMediaEvent = string;
+export interface MediaEvent {
+    type: string;
+    key?: string;
+    data?: any;
+}
+export declare function serializeMediaEvent(mediaEvent: MediaEvent): SerializedMediaEvent;
+export declare function deserializeMediaEvent(serializedMediaEvent: SerializedMediaEvent): MediaEvent;
+export declare function generateMediaEvent(type: string, data?: any): MediaEvent;
+export declare function generateCustomEvent(data?: any): MediaEvent;

package/dist/src/webrtc/mediaEvent.js

@@ -0,0 +1,16 @@
+export function serializeMediaEvent(mediaEvent) {
+    return JSON.stringify(mediaEvent);
+}
+export function deserializeMediaEvent(serializedMediaEvent) {
+    return JSON.parse(serializedMediaEvent);
+}
+export function generateMediaEvent(type, data) {
+    let event = { type };
+    if (data) {
+        event = { ...event, data };
+    }
+    return event;
+}
+export function generateCustomEvent(data) {
+    return generateMediaEvent('custom', data);
+}

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

@@ -0,0 +1,51 @@
+import { LocalTrack } from './LocalTrack';
+import type { BandwidthLimit, Encoding, MetadataParser, MLineId, RemoteTrackId, SimulcastConfig, TrackBandwidthLimit, WebRTCEndpointEvents } from '../types';
+import type { EndpointWithTrackContext } from '../internal';
+import { TrackContextImpl } from '../internal';
+import type { MediaEvent } from '../mediaEvent';
+import type { ConnectionManager } from '../ConnectionManager';
+import type { EndpointId, TrackId } from './TrackCommon';
+import type { WebRTCEndpoint } from '../webRTCEndpoint';
+export type MidToTrackId = Record<MLineId, TrackId>;
+/**
+ * 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 declare class Local<EndpointMetadata, TrackMetadata> {
+    private readonly localTracks;
+    private readonly localEndpoint;
+    private readonly endpointMetadataParser;
+    private readonly trackMetadataParser;
+    private readonly emit;
+    private readonly sendMediaEvent;
+    private connection;
+    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>);
+    updateSenders: () => void;
+    updateMLineIds: (midToTrackId: MidToTrackId) => void;
+    updateConnection: (connection: ConnectionManager) => void;
+    createSdpOfferEvent: (offer: RTCSessionDescriptionInit) => MediaEvent;
+    addTrack: (connection: ConnectionManager | undefined, trackId: string, track: MediaStreamTrack, stream: MediaStream, trackMetadata: TrackMetadata | undefined, simulcastConfig: SimulcastConfig, maxBandwidth: TrackBandwidthLimit) => LocalTrack<EndpointMetadata, TrackMetadata>;
+    disableAllLocalTrackEncodings: () => Promise<void>;
+    getTrackByMidOrNull: (mid: string) => LocalTrack<EndpointMetadata, TrackMetadata> | null;
+    removeTrack: (trackId: TrackId) => void;
+    replaceTrack: (webrtc: WebRTCEndpoint<EndpointMetadata, TrackMetadata>, trackId: TrackId, newTrack: MediaStreamTrack | null, newTrackMetadata: TrackMetadata | undefined) => Promise<void>;
+    setEndpointMetadata: (metadata: EndpointMetadata) => void;
+    getEndpoint: () => EndpointWithTrackContext<EndpointMetadata, TrackMetadata>;
+    setTrackBandwidth: (trackId: string, bandwidth: BandwidthLimit) => Promise<void>;
+    getTrackIdToTrack: () => Map<RemoteTrackId, TrackContextImpl<EndpointMetadata, TrackMetadata>>;
+    setLocalEndpointId: (endpointId: EndpointId) => void;
+    setEncodingBandwidth: (trackId: TrackId, rid: Encoding, bandwidth: BandwidthLimit) => Promise<void>;
+    updateEndpointMetadata: (metadata: unknown) => void;
+    updateLocalTrackMetadata: (trackId: TrackId, metadata: unknown) => void;
+    disableLocalTrackEncoding: (trackId: string, encoding: Encoding) => Promise<void>;
+    enableLocalTrackEncoding: (trackId: TrackId, encoding: Encoding) => Promise<void>;
+    private getTrackIdToMetadata;
+    private getTrackIdToTrackBitrates;
+    private getMidToTrackId;
+    private getTransceiverMapping;
+    setLocalTrackStatusToOffered: () => void;
+    addAllTracksToConnection: () => void;
+}

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

@@ -0,0 +1,289 @@
+import { LocalTrack } from './LocalTrack';
+import { isTrackKind, TrackContextImpl } from '../internal';
+import { generateCustomEvent, generateMediaEvent } from '../mediaEvent';
+/**
+ * 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,
+        rawMetadata: undefined,
+        tracks: new Map(),
+    };
+    endpointMetadataParser;
+    trackMetadataParser;
+    emit;
+    sendMediaEvent;
+    connection = null;
+    constructor(emit, sendMediaEvent, endpointMetadataParser, trackMetadataParser) {
+        this.emit = emit;
+        this.sendMediaEvent = sendMediaEvent;
+        this.endpointMetadataParser = endpointMetadataParser;
+        this.trackMetadataParser = trackMetadataParser;
+    }
+    updateSenders = () => {
+        Object.values(this.localTracks).forEach((localTrack) => {
+            localTrack.updateSender();
+        });
+    };
+    updateMLineIds = (midToTrackId) => {
+        Object.entries(midToTrackId).forEach(([mLineId, trackId]) => {
+            const localTrack = this.localTracks[trackId];
+            if (localTrack) {
+                localTrack.setMLineId(mLineId);
+            }
+        });
+    };
+    updateConnection = (connection) => {
+        this.connection = connection;
+        Object.values(this.localTracks).forEach((track) => {
+            track.updateConnection(connection);
+        });
+    };
+    createSdpOfferEvent = (offer) => {
+        const trackIdToTrackMetadata = this.getTrackIdToMetadata();
+        const trackIdToTrackBitrates = this.getTrackIdToTrackBitrates();
+        const midToTrackId = this.getMidToTrackId();
+        return generateCustomEvent({
+            type: 'sdpOffer',
+            data: {
+                sdpOffer: offer,
+                trackIdToTrackMetadata,
+                trackIdToTrackBitrates,
+                midToTrackId,
+            },
+        });
+    };
+    addTrack = (connection, trackId, track, stream, trackMetadata, simulcastConfig, maxBandwidth) => {
+        const trackContext = new TrackContextImpl(this.localEndpoint, trackId, trackMetadata, simulcastConfig, this.trackMetadataParser);
+        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.trackMetadataParser);
+        this.localTracks[trackId] = trackManager;
+        return trackManager;
+    };
+    disableAllLocalTrackEncodings = async () => {
+        // TODO: Why are we disabling already disabled encodings?
+        //  I think this part of the code is invoked to mutate RTCRtpSender.getParameters().encodings.active.
+        //  We should probably implement a separate method for that, because disabling already disabled tracks seems weird.
+        for (const [trackId, trackManager] of Object.entries(this.localTracks)) {
+            for (const encoding of trackManager.getDisabledEncodings()) {
+                await this.disableLocalTrackEncoding(trackId, encoding);
+            }
+        }
+    };
+    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 mediaEvent = generateCustomEvent({ type: 'renegotiateTracks' });
+        this.sendMediaEvent(mediaEvent);
+        this.localEndpoint.tracks.delete(trackId);
+        delete this.localTracks[trackId];
+    };
+    replaceTrack = async (
+    // todo remove webrtc with newTrackMetadata
+    webrtc, trackId, newTrack, 
+    // todo remove webrtc with newTrackMetadata
+    newTrackMetadata) => {
+        // 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, newTrackMetadata, webrtc);
+    };
+    setEndpointMetadata = (metadata) => {
+        try {
+            this.localEndpoint.metadata = this.endpointMetadataParser(metadata);
+            this.localEndpoint.metadataParsingError = undefined;
+        }
+        catch (error) {
+            this.localEndpoint.metadata = undefined;
+            this.localEndpoint.metadataParsingError = error;
+            throw error;
+        }
+        this.localEndpoint.rawMetadata = 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 mediaEvent = trackManager.createTrackVariantBitratesEvent();
+        this.sendMediaEvent(mediaEvent);
+        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 mediaEvent = generateCustomEvent({
+            type: 'trackVariantBitrates',
+            data: {
+                trackId: trackId,
+                variantBitrates: trackManager.getTrackBitrates(),
+            },
+        });
+        this.sendMediaEvent(mediaEvent);
+        this.emit('localTrackEncodingBandwidthSet', {
+            trackId,
+            rid,
+            bandwidth,
+        });
+    };
+    updateEndpointMetadata = (metadata) => {
+        this.localEndpoint.metadata = this.endpointMetadataParser(metadata);
+        this.localEndpoint.rawMetadata = this.localEndpoint.metadata;
+        this.localEndpoint.metadataParsingError = undefined;
+        const mediaEvent = generateMediaEvent('updateEndpointMetadata', {
+            metadata: this.localEndpoint.metadata,
+        });
+        this.sendMediaEvent(mediaEvent);
+        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 mediaEvent = generateMediaEvent('updateTrackMetadata', {
+            trackId,
+            trackMetadata: metadata,
+        });
+        switch (trackContext.negotiationStatus) {
+            case 'done':
+                this.sendMediaEvent(mediaEvent);
+                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 mediaEvent = generateMediaEvent('disableTrackEncoding', {
+            trackId: trackId,
+            encoding: encoding,
+        });
+        this.sendMediaEvent(mediaEvent);
+        this.emit('localTrackEncodingEnabled', {
+            trackId,
+            encoding,
+        });
+    };
+    enableLocalTrackEncoding = async (trackId, encoding) => {
+        const trackManager = this.localTracks[trackId];
+        if (!trackManager)
+            throw new Error(`Cannot find ${trackId}`);
+        await trackManager.enableTrackEncoding(encoding);
+        const mediaEvent = generateMediaEvent('enableTrackEncoding', {
+            trackId: trackId,
+            encoding: encoding,
+        });
+        this.sendMediaEvent(mediaEvent);
+        this.emit('localTrackEncodingEnabled', {
+            trackId,
+            encoding,
+        });
+    };
+    getTrackIdToMetadata = () => {
+        return Object.values(this.localTracks).reduce((previousValue, localTrack) => ({
+            ...previousValue,
+            [localTrack.id]: localTrack.trackContext.metadata,
+        }), {});
+    };
+    getTrackIdToTrackBitrates = () => {
+        return Object.values(this.localTracks).reduce((previousValue, localTrack) => ({
+            ...previousValue,
+            [localTrack.id]: localTrack.getTrackBitrates(),
+        }), {});
+    };
+    getMidToTrackId = () => {
+        if (!this.connection)
+            return null;
+        // - 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).reduce((acc, curr) => {
+            if (curr.mLineId) {
+                acc[curr.mLineId] = curr.id;
+            }
+            return acc;
+        }, {});
+        return { ...mappingFromTransceivers, ...mappingFromLocalNegotiatedTracks };
+    };
+    getTransceiverMapping = () => {
+        if (!this.connection)
+            return {};
+        return this.connection
+            .getConnection()
+            .getTransceivers()
+            .filter((transceiver) => transceiver.sender.track?.id && transceiver.mid)
+            .reduce((acc, transceiver) => {
+            const localTrackId = transceiver.sender.track.id;
+            const mid = transceiver.mid;
+            const localTrack = Object.values(this.localTracks).find((track) => track.mediaStreamTrackId === localTrackId);
+            if (!localTrack)
+                throw new Error('Local track not found');
+            acc[mid] = localTrack.trackContext.trackId;
+            return acc;
+        }, {});
+    };
+    setLocalTrackStatusToOffered = () => {
+        Object.values(this.localTracks).forEach((localTrack) => {
+            localTrack.trackContext.negotiationStatus = 'offered';
+        });
+    };
+    addAllTracksToConnection = () => {
+        Object.values(this.localTracks).forEach((localTrack) => {
+            localTrack.addTrackToConnection();
+        });
+    };
+}

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

@@ -0,0 +1,62 @@
+import type { TrackContextImpl } from '../internal';
+import type { BandwidthLimit, Encoding, LocalTrackId, MediaStreamTrackId, MetadataParser, MLineId } from '../types';
+import type { TrackCommon, TrackEncodings, TrackId } from './TrackCommon';
+import type { WebRTCEndpoint } from '../webRTCEndpoint';
+import type { Bitrates } from '../bitrate';
+import type { ConnectionManager } from '../ConnectionManager';
+/**
+ * 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<EndpointMetadata, TrackMetadata> implements TrackCommon {
+    readonly id: TrackId;
+    mediaStreamTrackId: MediaStreamTrackId | null;
+    mLineId: MLineId | null;
+    readonly trackContext: TrackContextImpl<EndpointMetadata, TrackMetadata>;
+    private sender;
+    readonly encodings: TrackEncodings;
+    private readonly metadataParser;
+    connection: ConnectionManager | undefined;
+    constructor(connection: ConnectionManager | undefined, id: LocalTrackId, trackContext: TrackContextImpl<EndpointMetadata, TrackMetadata>, metadataParser: MetadataParser<TrackMetadata>);
+    updateSender: () => void;
+    updateConnection: (connection: ConnectionManager) => void;
+    disableTrackEncoding: (encoding: Encoding) => Promise<void>;
+    addTrackToConnection: () => void;
+    private updateEncodings;
+    removeFromConnection: () => void;
+    replaceTrack: (newTrack: MediaStreamTrack | null, newTrackMetadata: TrackMetadata | undefined, webrtc: WebRTCEndpoint<EndpointMetadata, TrackMetadata>) => Promise<void>;
+    setTrackBandwidth: (bandwidth: BandwidthLimit) => Promise<void>;
+    setEncodingBandwidth(rid: Encoding, bandwidth: BandwidthLimit): Promise<void>;
+    updateTrackMetadata: (metadata: unknown) => void;
+    enableTrackEncoding: (encoding: Encoding) => Promise<void>;
+    getDisabledEncodings: () => Encoding[];
+    setMLineId: (mLineId: MLineId) => void;
+    private isNotSimulcastTrack;
+    getTrackBitrates: () => Bitrates;
+    createTrackVariantBitratesEvent: () => import("../mediaEvent").MediaEvent;
+}