livekit-client 2.18.0 → 2.18.2

package/dist/ts4.2/room/RTCEngine.d.ts

@@ -1,15 +1,14 @@
 import type { AddTrackRequest, ConnectionQualityUpdate, JoinResponse, StreamStateUpdate, SubscriptionPermissionUpdate, SubscriptionResponse } from '@livekit/protocol';
-import { DataPacket, DataPacket_Kind, DisconnectReason, Encryption_Type, ParticipantInfo, RequestResponse, Room as RoomModel, RoomMovedResponse, SpeakerInfo, SubscribedQualityUpdate, TrackInfo, TrackUnpublishedResponse, Transcription } from '@livekit/protocol';
+import { DataPacket, DataTrackSubscriberHandles, DisconnectReason, Encryption_Type, ParticipantInfo, PublishDataTrackResponse, RequestResponse, Room as RoomModel, RoomMovedResponse, ServerInfo, SpeakerInfo, SubscribedQualityUpdate, TrackInfo, TrackUnpublishedResponse, Transcription, UnpublishDataTrackResponse } from '@livekit/protocol';
 import type TypedEventEmitter from 'typed-emitter';
 import type { SignalOptions } from '../api/SignalClient';
 import { SignalClient } from '../api/SignalClient';
 import type { BaseE2EEManager } from '../e2ee/E2eeManager';
 import type { InternalRoomOptions } from '../options';
-import TypedPromise from '../utils/TypedPromise';
 import PCTransport from './PCTransport';
 import { PCTransportManager } from './PCTransportManager';
 import type { RegionUrlProvider } from './RegionUrlProvider';
-import { UnexpectedConnectionState } from './errors';
+import { DataTrackInfo } from './data-track/types';
 import { RpcError } from './rpc';
 import type LocalTrack from './track/LocalTrack';
 import type LocalTrackPublication from './track/LocalTrackPublication';
@@ -18,6 +17,11 @@ import type { SimulcastTrackInfo } from './track/LocalVideoTrack';
 import type RemoteTrackPublication from './track/RemoteTrackPublication';
 import type { Track } from './track/Track';
 import type { TrackPublishOptions, VideoCodec } from './track/options';
+export declare enum DataChannelKind {
+    RELIABLE = 0,
+    LOSSY = 1,
+    DATA_TRACK_LOSSY = 2
+}
 declare const RTCEngine_base: new () => TypedEventEmitter<EngineEventCallbacks>;
 /** @internal */
 export default class RTCEngine extends RTCEngine_base {
@@ -43,8 +47,10 @@ export default class RTCEngine extends RTCEngine_base {
     private lossyDC?;
     private lossyDCSub?;
     private reliableDC?;
-    private dcBufferStatus;
     private reliableDCSub?;
+    private dataTrackDC?;
+    private dataTrackDCSub?;
+    private dcBufferStatus;
     private subscriberPrimary;
     private pcState;
     private _isClosed;
@@ -91,7 +97,10 @@ export default class RTCEngine extends RTCEngine_base {
     };
     join(url: string, token: string, opts: SignalOptions, abortSignal?: AbortSignal, 
     /** setting this to true results in dual peer connection mode being used */
-    useV0Path?: boolean): Promise<JoinResponse>;
+    useV0Path?: boolean): Promise<{
+        joinResponse: JoinResponse;
+        serverInfo: Partial<ServerInfo>;
+    }>;
     close(): Promise<void>;
     cleanupPeerConnections(): Promise<void>;
     cleanupLossyDataStats(): void;
@@ -111,9 +120,11 @@ export default class RTCEngine extends RTCEngine_base {
     private configure;
     private setupSignalClientCallbacks;
     private makeRTCConfiguration;
+    private addMediaSections;
     private createDataChannels;
     private handleDataChannel;
     private handleDataMessage;
+    private handleDataTrackMessage;
     private handleDataError;
     private handleBufferedAmountLow;
     createSender(track: LocalTrack, opts: TrackPublishOptions, encodings?: RTCRtpEncodingParameters[]): Promise<RTCRtpSender>;
@@ -133,22 +144,23 @@ export default class RTCEngine extends RTCEngine_base {
     publishRpcResponse(destinationIdentity: string, requestId: string, payload: string | null, error: RpcError | null): Promise<void>;
     /** @internal */
     publishRpcAck(destinationIdentity: string, requestId: string): Promise<void>;
-    sendDataPacket(packet: DataPacket, kind: DataPacket_Kind): Promise<void>;
+    sendDataPacket(packet: DataPacket, kind: DataChannelKind): Promise<void>;
+    sendLossyBytes(bytes: Uint8Array, kind: Exclude<DataChannelKind, DataChannelKind.RELIABLE>, bufferStatusLowBehavior?: 'drop' | 'wait'): Promise<void>;
     private resendReliableMessagesForResume;
     private updateAndEmitDCBufferStatus;
     private isBufferStatusLow;
-    waitForBufferStatusLow(kind: DataPacket_Kind): TypedPromise<void, UnexpectedConnectionState>;
+    waitForBufferStatusLow(kind: DataChannelKind): Promise<void>;
     /**
      * @internal
      */
-    ensureDataTransportConnected(kind: DataPacket_Kind, subscriber?: boolean): Promise<void>;
+    ensureDataTransportConnected(kind: DataChannelKind, subscriber?: boolean): Promise<void>;
     private ensurePublisherConnected;
     verifyTransport(): boolean;
     /** @internal */
     negotiate(): Promise<void>;
-    dataChannelForKind(kind: DataPacket_Kind, sub?: boolean): RTCDataChannel | undefined;
+    dataChannelForKind(kind: DataChannelKind, sub?: boolean): RTCDataChannel | undefined;
     /** @internal */
-    sendSyncState(remoteTracks: RemoteTrackPublication[], localTracks: LocalTrackPublication[]): void;
+    sendSyncState(remoteTracks: RemoteTrackPublication[], localTracks: LocalTrackPublication[], localDataTrackInfos: Array<DataTrackInfo>): void;
     failNext(): void;
     private dataChannelsInfo;
     private clearReconnectTimeout;
@@ -177,7 +189,7 @@ export type EngineEventCallbacks = {
     /** @internal */
     trackSenderAdded: (track: Track, sender: RTCRtpSender) => void;
     rtpVideoMapUpdate: (rtpMap: Map<number, VideoCodec>) => void;
-    dcBufferStatusChanged: (isLow: boolean, kind: DataPacket_Kind) => void;
+    dcBufferStatusChanged: (isLow: boolean, kind: DataChannelKind) => void;
     participantUpdate: (infos: ParticipantInfo[]) => void;
     roomUpdate: (room: RoomModel) => void;
     roomMoved: (room: RoomMovedResponse) => void;
@@ -193,6 +205,11 @@ export type EngineEventCallbacks = {
     offline: () => void;
     signalRequestResponse: (response: RequestResponse) => void;
     signalConnected: (joinResp: JoinResponse) => void;
+    publishDataTrackResponse: (event: PublishDataTrackResponse) => void;
+    unPublishDataTrackResponse: (event: UnpublishDataTrackResponse) => void;
+    dataTrackSubscriberHandles: (event: DataTrackSubscriberHandles) => void;
+    dataTrackPacketReceived: (packet: Uint8Array) => void;
+    joined: (joinResponse: JoinResponse) => void;
 };
 export {};
 //# sourceMappingURL=RTCEngine.d.ts.map

package/dist/ts4.2/room/Room.d.ts

@@ -3,11 +3,14 @@ import 'webrtc-adapter';
 import type TypedEmitter from 'typed-emitter';
 import type { InternalRoomOptions, RoomConnectOptions, RoomOptions } from '../options';
 import TypedPromise from '../utils/TypedPromise';
-import RTCEngine from './RTCEngine';
+import RTCEngine, { DataChannelKind } from './RTCEngine';
 import type { ByteStreamHandler, TextStreamHandler } from './data-stream/incoming/StreamReader';
+import type LocalDataTrack from './data-track/LocalDataTrack';
+import type RemoteDataTrack from './data-track/RemoteDataTrack';
+import type { DataTrackSid } from './data-track/types';
 import { UnexpectedConnectionState } from './errors';
 import LocalParticipant from './participant/LocalParticipant';
-import type Participant from './participant/Participant';
+import Participant from './participant/Participant';
 import type { ConnectionQuality } from './participant/Participant';
 import RemoteParticipant from './participant/RemoteParticipant';
 import type { RpcInvocationData } from './rpc';
@@ -65,6 +68,7 @@ declare class Room extends Room_base {
     private connectFuture?;
     private disconnectLock;
     private e2eeManager;
+    private e2eeStateMutex;
     private connectionReconcileInterval?;
     private regionUrlProvider?;
     private regionUrl?;
@@ -78,6 +82,8 @@ declare class Room extends Room_base {
     private transcriptionReceivedTimes;
     private incomingDataStreamManager;
     private outgoingDataStreamManager;
+    private incomingDataTrackManager;
+    private outgoingDataTrackManager;
     private rpcHandlers;
     get hasE2EESetup(): boolean;
     /**
@@ -216,6 +222,7 @@ declare class Room extends Room_base {
     private recreateEngine;
     private onTrackAdded;
     private handleRestarting;
+    private handleRestarted;
     private handleSignalRestarted;
     private handleDisconnect;
     private handleParticipantUpdates;
@@ -323,11 +330,15 @@ export type RoomEventCallbacks = {
     recordingStatusChanged: (recording: boolean) => void;
     participantEncryptionStatusChanged: (encrypted: boolean, participant?: Participant) => void;
     encryptionError: (error: Error, participant?: Participant) => void;
-    dcBufferStatusChanged: (isLow: boolean, kind: DataPacket_Kind) => void;
+    dcBufferStatusChanged: (isLow: boolean, kind: DataChannelKind) => void;
     activeDeviceChanged: (kind: MediaDeviceKind, deviceId: string) => void;
     chatMessage: (message: ChatMessage, participant?: RemoteParticipant | LocalParticipant) => void;
     localTrackSubscribed: (publication: LocalTrackPublication, participant: LocalParticipant) => void;
     metricsReceived: (metrics: MetricsBatch, participant?: Participant) => void;
     participantActive: (participant: Participant) => void;
+    dataTrackPublished: (track: RemoteDataTrack) => void;
+    dataTrackUnpublished: (sid: DataTrackSid) => void;
+    localDataTrackPublished: (track: LocalDataTrack) => void;
+    localDataTrackUnpublished: (sid: DataTrackSid) => void;
 };
 //# sourceMappingURL=Room.d.ts.map

package/dist/ts4.2/room/data-stream/incoming/IncomingDataStreamManager.d.ts

@@ -7,13 +7,17 @@ export default class IncomingDataStreamManager {
     private textStreamControllers;
     private byteStreamHandlers;
     private textStreamHandlers;
+    private isConnected;
+    private bufferedPackets;
+    setConnected(connected: boolean): void;
+    private flushBufferedPackets;
     registerTextStreamHandler(topic: string, callback: TextStreamHandler): void;
     unregisterTextStreamHandler(topic: string): void;
     registerByteStreamHandler(topic: string, callback: ByteStreamHandler): void;
     unregisterByteStreamHandler(topic: string): void;
     clearControllers(): void;
     validateParticipantHasNoActiveDataStreams(participantIdentity: string): void;
-    handleDataStreamPacket(packet: DataPacket, encryptionType: Encryption_Type): Promise<void>;
+    handleDataStreamPacket(packet: DataPacket, encryptionType: Encryption_Type): void;
     private handleStreamHeader;
     private handleStreamChunk;
     private handleStreamTrailer;

package/dist/ts4.2/room/data-track/LocalDataTrack.d.ts

@@ -1,18 +1,36 @@
+import type { StructuredLogger } from '../../logger';
 import type { DataTrackFrame } from './frame';
+import type { DataTrackHandle } from './handle';
 import type OutgoingDataTrackManager from './outgoing/OutgoingDataTrackManager';
+import { DataTrackPushFrameError } from './outgoing/errors';
+import type { DataTrackOptions } from './outgoing/types';
 import type { IDataTrack, ILocalTrack } from './track-interfaces';
 import type { DataTrackInfo } from './types';
 export default class LocalDataTrack implements ILocalTrack, IDataTrack {
     readonly trackSymbol: symbol;
     readonly isLocal = true;
     readonly typeSymbol: symbol;
-    info: DataTrackInfo;
+    protected options: DataTrackOptions;
+    /** Represents the currently active {@link DataTrackHandle} for the publication. */
+    protected handle: DataTrackHandle | null;
     protected manager: OutgoingDataTrackManager;
+    protected log: StructuredLogger;
     /** @internal */
-    constructor(info: DataTrackInfo, manager: OutgoingDataTrackManager);
+    constructor(options: DataTrackOptions, manager: OutgoingDataTrackManager);
+    /** @internal */
+    static withExplicitHandle(options: DataTrackOptions, manager: OutgoingDataTrackManager, handle: DataTrackHandle): LocalDataTrack;
+    /** Metrics about the data track publication. */
+    get info(): DataTrackInfo | undefined;
     /** The raw descriptor from the manager containing the internal state for this local track. */
     protected get descriptor(): import("./outgoing/OutgoingDataTrackManager").Descriptor | null;
-    isPublished(): boolean;
+    /**
+     * Publish the track to the SFU. This must be done before calling {@link tryPush} for the first time.
+     * @internal
+     * */
+    publish(signal?: AbortSignal): Promise<void>;
+    isPublished(): this is {
+        info: DataTrackInfo;
+    };
     /** Try pushing a frame to subscribers of the track.
      *
      * Pushing a frame can fail for several reasons:
@@ -20,6 +38,11 @@ export default class LocalDataTrack implements ILocalTrack, IDataTrack {
      * - The track has been unpublished by the local participant or SFU
      * - The room is no longer connected
      */
-    tryPush(payload: DataTrackFrame['payload']): import("@livekit/throws-transformer/throws").Throws<void, import("./outgoing/errors").DataTrackPushFrameError<import("./outgoing/errors").DataTrackPushFrameErrorReason.Dropped> | import("./outgoing/errors").DataTrackPushFrameError<import("./outgoing/errors").DataTrackPushFrameErrorReason.TrackUnpublished>>;
+    tryPush(frame: DataTrackFrame): Promise<import("@livekit/throws-transformer/throws").Throws<void, DataTrackPushFrameError<import("./outgoing/errors").DataTrackPushFrameErrorReason.TrackUnpublished> | DataTrackPushFrameError<import("./outgoing/errors").DataTrackPushFrameErrorReason.Dropped>>>;
+    /**
+     * Unpublish the track from the SFU. Once this is called, any further calls to {@link tryPush}
+     * will fail.
+     * */
+    unpublish(): Promise<void>;
 }
 //# sourceMappingURL=LocalDataTrack.d.ts.map

package/dist/ts4.2/room/data-track/RemoteDataTrack.d.ts

@@ -6,11 +6,11 @@ import type { DataTrackInfo } from './types';
 type RemoteDataTrackOptions = {
     publisherIdentity: Participant['identity'];
 };
-export type RemoteDataTrackSubscribeOptions = {
+export type DataTrackSubscribeOptions = {
     signal?: AbortSignal;
     /** The number of {@link DataTrackFrame}s to hold in the ReadableStream before disgarding extra
-     * frames. Defaults to 4, but this may not be good enough for especially high frequency data. */
-    highWaterMark?: number;
+     * frames. Defaults to 16, but this may not be good enough for especially high frequency data. */
+    bufferSize?: number;
 };
 export default class RemoteDataTrack implements IRemoteTrack, IDataTrack {
     readonly trackSymbol: symbol;
@@ -40,7 +40,7 @@ export default class RemoteDataTrack implements IRemoteTrack, IDataTrack {
      * Note that newly created subscriptions only receive frames published after
      * the initial subscription is established.
      */
-    subscribe(options?: RemoteDataTrackSubscribeOptions): Promise<ReadableStream<DataTrackFrame>>;
+    subscribe(options?: DataTrackSubscribeOptions): ReadableStream<DataTrackFrame>;
 }
 export {};
 //# sourceMappingURL=RemoteDataTrack.d.ts.map

package/dist/ts4.2/room/data-track/depacketizer.d.ts

@@ -1,6 +1,6 @@
 import type { Throws } from '@livekit/throws-transformer/throws';
 import { LivekitReasonedError } from '../errors';
-import type { DataTrackFrame } from './frame';
+import type { DataTrackFrameInternal } from './frame';
 import { DataTrackPacket } from './packet';
 /** An error indicating a frame was dropped. */
 export declare class DataTrackDepacketizerDropError<Reason extends DataTrackDepacketizerDropReason = DataTrackDepacketizerDropReason> extends LivekitReasonedError<Reason> {
@@ -11,7 +11,7 @@ export declare class DataTrackDepacketizerDropError<Reason extends DataTrackDepa
     constructor(message: string, reason: Reason, frameNumber: number, options?: {
         cause?: unknown;
     });
-    static interrupted(frameNumber: number): DataTrackDepacketizerDropError<DataTrackDepacketizerDropReason.Interrupted>;
+    static interrupted(frameNumber: number, newFrameNumber: number): DataTrackDepacketizerDropError<DataTrackDepacketizerDropReason.Interrupted>;
     static unknownFrame(frameNumber: number): DataTrackDepacketizerDropError<DataTrackDepacketizerDropReason.UnknownFrame>;
     static bufferFull(frameNumber: number): DataTrackDepacketizerDropError<DataTrackDepacketizerDropReason.BufferFull>;
     static incomplete(frameNumber: number, receivedPackets: number, expectedPackets: number): DataTrackDepacketizerDropError<DataTrackDepacketizerDropReason.Incomplete>;
@@ -35,9 +35,9 @@ export default class DataTrackDepacketizer {
     /** Should be repeatedly called with received {@link DataTrackPacket}s - intermediate calls
      * aggregate the packet's state internally, and return null.
      *
-     * Once this method is called with the final packet to form a frame, a new {@link DataTrackFrame}
+     * Once this method is called with the final packet to form a frame, a new {@link DataTrackFrameInternal}
      * is returned.*/
-    push(packet: DataTrackPacket, options?: PushOptions): Throws<DataTrackFrame | null, DataTrackDepacketizerDropError>;
+    push(packet: DataTrackPacket, options?: PushOptions): Throws<DataTrackFrameInternal | null, DataTrackDepacketizerDropError>;
     reset(): void;
     private frameFromSingle;
     /** Begin assembling a new packet. */

package/dist/ts4.2/room/data-track/frame.d.ts

@@ -1,7 +1,21 @@
 import { DataTrackExtensions } from './packet/extensions';
 /** A pair of payload bytes and packet extensions which can be fed into a {@link DataTrackPacketizer}. */
 export type DataTrackFrame = {
+    payload: Uint8Array;
+    userTimestamp?: bigint;
+};
+/** An internal representation o data track frame which contains all SFU metadata. */
+export type DataTrackFrameInternal = {
     payload: Uint8Array;
     extensions: DataTrackExtensions;
 };
+export declare const DataTrackFrameInternal: {
+    from(frame: DataTrackFrame): {
+        payload: Uint8Array<ArrayBufferLike>;
+        extensions: DataTrackExtensions;
+    };
+    /** Converts from a DataTrackFrameInternal -> DataTrackFrame. Some internal information is
+     * discarded like e2ee encrption extension data. */
+    lossyIntoFrame(frame: DataTrackFrameInternal): DataTrackFrame;
+};
 //# sourceMappingURL=frame.d.ts.map

package/dist/ts4.2/room/data-track/incoming/IncomingDataTrackManager.d.ts

@@ -1,9 +1,9 @@
 import type { Throws } from '@livekit/throws-transformer/throws';
 import type TypedEmitter from 'typed-emitter';
+import type { BaseE2EEManager } from '../../../e2ee/E2eeManager';
 import type Participant from '../../participant/Participant';
 import type RemoteParticipant from '../../participant/RemoteParticipant';
 import { DataTrackDepacketizerDropError } from '../depacketizer';
-import type { DecryptionProvider } from '../e2ee';
 import type { DataTrackFrame } from '../frame';
 import { DataTrackHandle } from '../handle';
 import type { DataTrackInfo, DataTrackSid } from '../types';
@@ -14,20 +14,20 @@ export type DataTrackIncomingManagerCallbacks = {
     sfuUpdateSubscription: (event: EventSfuUpdateSubscription) => void;
     /** A track has been published by a remote participant and is available to be
      * subscribed to. */
-    trackAvailable: (event: EventTrackAvailable) => void;
+    trackPublished: (event: EventTrackAvailable) => void;
     /** A track has been unpublished by a remote participant and can no longer be subscribed to. */
-    trackUnavailable: (event: EventTrackUnavailable) => void;
+    trackUnpublished: (event: EventTrackUnavailable) => void;
 };
 type IncomingDataTrackManagerOptions = {
     /** Provider to use for decrypting incoming frame payloads.
      * If none, remote tracks using end-to-end encryption will not be available
      * for subscription.
      */
-    decryptionProvider: DecryptionProvider | null;
+    e2eeManager?: BaseE2EEManager;
 };
 declare const IncomingDataTrackManager_base: new () => TypedEmitter<DataTrackIncomingManagerCallbacks>;
 export default class IncomingDataTrackManager extends IncomingDataTrackManager_base {
-    private decryptionProvider;
+    private e2eeManager;
     /** Mapping between track SID and descriptor. */
     private descriptors;
     /** Mapping between subscriber handle and track SID.
@@ -38,6 +38,20 @@ export default class IncomingDataTrackManager extends IncomingDataTrackManager_b
      */
     private subscriptionHandles;
     constructor(options?: IncomingDataTrackManagerOptions);
+    /** @internal */
+    updateE2eeManager(e2eeManager: BaseE2EEManager | null): void;
+    /** Allocates a ReadableStream which emits when a new {@link DataTrackFrame} is received from the
+     * SFU. The SFU subscription is initiated lazily when the stream is created.
+     *
+     * @returns A tuple of the ReadableStream and a Promise that resolves once the SFU subscription
+     * is fully established / the stream is ready to receive frames.
+     *
+     * @internal
+     **/
+    openSubscriptionStream(sid: DataTrackSid, signal?: AbortSignal, bufferSize?: number): [
+        ReadableStream<DataTrackFrame>,
+        Promise<Throws<void, DataTrackSubscribeError>>
+    ];
     /** Client requested to subscribe to a data track.
      *
      * This is sent when the user calls {@link RemoteDataTrack.subscribe}.
@@ -46,10 +60,7 @@ export default class IncomingDataTrackManager extends IncomingDataTrackManager_b
      * requests simply attach an additional receiver to the broadcast channel, allowing them to consume
      * frames from the existing subscription pipeline.
      */
-    subscribeRequest(sid: DataTrackSid, signal?: AbortSignal, highWaterMark?: number): Promise<Throws<ReadableStream<DataTrackFrame>, DataTrackSubscribeError>>;
-    /** Allocates a ReadableStream which emits when a new {@link DataTrackFrame} is received from the
-     * SFU. */
-    private createReadableStream;
+    subscribeRequest(sid: DataTrackSid, signal?: AbortSignal): Promise<Throws<void, DataTrackSubscribeError>>;
     /**
      * Get information about all currently subscribed tracks.
      * @internal */
@@ -82,7 +93,7 @@ export default class IncomingDataTrackManager extends IncomingDataTrackManager_b
     mapping: Map<DataTrackHandle, DataTrackSid>): void;
     private registerSubscriberHandle;
     /** Packet has been received over the transport. */
-    packetReceived(bytes: Uint8Array): Throws<void, DataTrackDepacketizerDropError>;
+    packetReceived(bytes: Uint8Array): Promise<Throws<void, DataTrackDepacketizerDropError>>;
     /** Resend all subscription updates.
      *
      * This must be sent after a full reconnect to ensure the SFU knows which

package/dist/ts4.2/room/data-track/incoming/pipeline.d.ts

@@ -1,7 +1,7 @@
 import type { Throws } from '@livekit/throws-transformer/throws';
+import type { BaseE2EEManager } from '../../../e2ee/E2eeManager';
 import { DataTrackDepacketizerDropError } from '../depacketizer';
-import type { DecryptionProvider } from '../e2ee';
-import type { DataTrackFrame } from '../frame';
+import type { DataTrackFrameInternal } from '../frame';
 import { DataTrackPacket } from '../packet';
 import type { DataTrackInfo } from '../types';
 /**
@@ -10,20 +10,21 @@ import type { DataTrackInfo } from '../types';
 type Options = {
     info: DataTrackInfo;
     publisherIdentity: string;
-    decryptionProvider: DecryptionProvider | null;
+    e2eeManager: BaseE2EEManager | null;
 };
 /**
  * Pipeline for an individual data track subscription.
  */
 export default class IncomingDataTrackPipeline {
     private publisherIdentity;
-    private e2eeProvider;
+    private e2eeManager;
     private depacketizer;
     /**
      * Creates a new pipeline with the given options.
      */
     constructor(options: Options);
-    processPacket(packet: DataTrackPacket): Throws<DataTrackFrame | null, DataTrackDepacketizerDropError>;
+    updateE2eeManager(e2eeManager: BaseE2EEManager | null): void;
+    processPacket(packet: DataTrackPacket): Promise<Throws<DataTrackFrameInternal | null, DataTrackDepacketizerDropError>>;
     /**
      * Depacketize the given frame, log if a drop occurs.
      */

package/dist/ts4.2/room/data-track/outgoing/OutgoingDataTrackManager.d.ts

@@ -1,20 +1,22 @@
 import type { Throws } from '@livekit/throws-transformer/throws';
 import type TypedEmitter from 'typed-emitter';
+import type { BaseE2EEManager } from '../../../e2ee/E2eeManager';
 import { Future } from '../../utils';
-import LocalDataTrack from '../LocalDataTrack';
-import type { EncryptionProvider } from '../e2ee';
+import type { DataTrackFrameInternal } from '../frame';
 import { DataTrackHandle } from '../handle';
 import type { DataTrackInfo } from '../types';
-import { DataTrackPublishError, DataTrackPublishErrorReason, DataTrackPushFrameError, DataTrackPushFrameErrorReason } from './errors';
+import { DataTrackPublishError, DataTrackPushFrameError, DataTrackPushFrameErrorReason } from './errors';
 import DataTrackOutgoingPipeline from './pipeline';
-import type { DataTrackOptions, EventPacketsAvailable, EventSfuPublishRequest, EventSfuUnpublishRequest, SfuPublishResponseResult } from './types';
+import type { DataTrackOptions, EventPacketAvailable, EventSfuPublishRequest, EventSfuUnpublishRequest, EventTrackPublished, EventTrackUnpublished, SfuPublishResponseResult } from './types';
 export type PendingDescriptor = {
     type: 'pending';
-    completionFuture: Future<LocalDataTrack, DataTrackPublishError<DataTrackPublishErrorReason.NotAllowed> | DataTrackPublishError<DataTrackPublishErrorReason.DuplicateName> | DataTrackPublishError<DataTrackPublishErrorReason.Timeout> | DataTrackPublishError<DataTrackPublishErrorReason.LimitReached> | DataTrackPublishError<DataTrackPublishErrorReason.Disconnected> | DataTrackPublishError<DataTrackPublishErrorReason.Cancelled>>;
+    /** Resolves when the descriptor is fully published. */
+    completionFuture: Future<void, DataTrackPublishError>;
 };
 export type ActiveDescriptor = {
     type: 'active';
     info: DataTrackInfo;
+    publishState: 'published' | 'republishing' | 'unpublished';
     pipeline: DataTrackOutgoingPipeline;
     /** Resolves when the descriptor is unpublished. */
     unpublishingFuture: Future<void, never>;
@@ -22,55 +24,87 @@ export type ActiveDescriptor = {
 export type Descriptor = PendingDescriptor | ActiveDescriptor;
 export declare const Descriptor: {
     pending(): PendingDescriptor;
-    active(info: DataTrackInfo, encryptionProvider: EncryptionProvider | null): ActiveDescriptor;
+    active(info: DataTrackInfo, e2eeManager: BaseE2EEManager | null): ActiveDescriptor;
 };
 export type DataTrackOutgoingManagerCallbacks = {
     /** Request sent to the SFU to publish a track. */
     sfuPublishRequest: (event: EventSfuPublishRequest) => void;
     /** Request sent to the SFU to unpublish a track. */
     sfuUnpublishRequest: (event: EventSfuUnpublishRequest) => void;
-    /** Serialized packets are ready to be sent over the transport. */
-    packetsAvailable: (event: EventPacketsAvailable) => void;
+    /** A serialized packet is ready to be sent over the transport. */
+    packetAvailable: (event: EventPacketAvailable) => void;
+    /** A new {@link LocalDataTrack} has been published */
+    trackPublished: (event: EventTrackPublished) => void;
+    /** A {@link LocalDataTrack} has been unpublished */
+    trackUnpublished: (event: EventTrackUnpublished) => void;
 };
 type OutgoingDataTrackManagerOptions = {
     /**
      * Provider to use for encrypting outgoing frame payloads.
      *
-     * If none, end-to-end encryption will be disabled for all published tracks.
+     * If null, end-to-end encryption will be disabled for all published tracks.
      */
-    encryptionProvider?: EncryptionProvider;
+    e2eeManager?: BaseE2EEManager;
 };
 declare const OutgoingDataTrackManager_base: new () => TypedEmitter<DataTrackOutgoingManagerCallbacks>;
 export default class OutgoingDataTrackManager extends OutgoingDataTrackManager_base {
-    private encryptionProvider;
+    private e2eeManager;
     private handleAllocator;
     private descriptors;
     constructor(options?: OutgoingDataTrackManagerOptions);
     static withDescriptors(descriptors: Map<DataTrackHandle, Descriptor>): OutgoingDataTrackManager;
+    /** @internal */
+    updateE2eeManager(e2eeManager: BaseE2EEManager | null): void;
     /**
      * Used by attached {@link LocalDataTrack} instances to query their associated descriptor info.
      * @internal
      */
     getDescriptor(handle: DataTrackHandle): Descriptor | null;
-    createLocalDataTrack(handle: DataTrackHandle): LocalDataTrack | null;
     /** Used by attached {@link LocalDataTrack} instances to broadcast data track packets to other
      * subscribers.
      * @internal
      */
-    tryProcessAndSend(handle: DataTrackHandle, payload: Uint8Array): Throws<void, DataTrackPushFrameError<DataTrackPushFrameErrorReason.Dropped> | DataTrackPushFrameError<DataTrackPushFrameErrorReason.TrackUnpublished>>;
-    /** Client requested to publish a track. */
-    publishRequest(options: DataTrackOptions, signal?: AbortSignal): Promise<LocalDataTrack & {
-        readonly __throws?: DataTrackPublishError<DataTrackPublishErrorReason.NotAllowed> | DataTrackPublishError<DataTrackPublishErrorReason.DuplicateName> | DataTrackPublishError<DataTrackPublishErrorReason.Timeout> | DataTrackPublishError<DataTrackPublishErrorReason.LimitReached> | DataTrackPublishError<DataTrackPublishErrorReason.Disconnected> | DataTrackPublishError<DataTrackPublishErrorReason.Cancelled> | undefined;
-    }>;
-    /** Get information about all currently published tracks. */
-    queryPublished(): Promise<DataTrackInfo[]>;
-    /** Client request to unpublish a track. */
+    tryProcessAndSend(handle: DataTrackHandle, frame: DataTrackFrameInternal): Promise<Throws<void, DataTrackPushFrameError<DataTrackPushFrameErrorReason.Dropped> | DataTrackPushFrameError<DataTrackPushFrameErrorReason.TrackUnpublished>>>;
+    /**
+     * Client requested to publish a track.
+     *
+     * If the LiveKit server is too old and doesn't support data tracks, a
+     * {@link DataTrackPublishError#timeout} will be thrown.
+     *
+     * @internal
+     **/
+    publishRequest(options: DataTrackOptions, signal?: AbortSignal): Promise<Throws<DataTrackHandle, DataTrackPublishError>>;
+    /**
+     * Get information about all currently published tracks.
+     * @internal
+     **/
+    queryPublished(): DataTrackInfo[];
+    /**
+     * Client request to unpublish a track.
+     * @internal
+     **/
     unpublishRequest(handle: DataTrackHandle): Promise<void>;
-    /** SFU responded to a request to publish a data track. */
+    /**
+     * SFU responded to a request to publish a data track.
+     * @internal
+     **/
     receivedSfuPublishResponse(handle: DataTrackHandle, result: SfuPublishResponseResult): void;
-    /** SFU notification that a track has been unpublished. */
+    /**
+     * SFU notification that a track has been unpublished.
+     * @internal
+     **/
     receivedSfuUnpublishResponse(handle: DataTrackHandle): void;
-    /** Shuts down the manager and all associated tracks. */
+    /** Republish all tracks.
+     *
+     * This must be sent after a full reconnect in order for existing publications
+     * to be recognized by the SFU. Each republished track will be assigned a new SID.
+     * @internal
+     */
+    sfuWillRepublishTracks(): void;
+    /**
+     * Shuts down the manager and all associated tracks.
+     * @internal
+     **/
     shutdown(): Promise<void>;
 }
 export {};

package/dist/ts4.2/room/data-track/outgoing/errors.d.ts

@@ -15,19 +15,29 @@ export declare enum DataTrackPublishErrorReason {
     LimitReached = 3,
     /** Cannot publish data track when the room is disconnected. */
     Disconnected = 4,
-    Cancelled = 5
+    Cancelled = 5,
+    /** The name requested is not able to be used when creating the data track. */
+    InvalidName = 6,
+    /** There was an error publishing, but it was not something that could be sorted into a known
+     * category. */
+    Unknown = 7
 }
-export declare class DataTrackPublishError<Reason extends DataTrackPublishErrorReason> extends LivekitReasonedError<Reason> {
+export declare class DataTrackPublishError<Reason extends DataTrackPublishErrorReason = DataTrackPublishErrorReason> extends LivekitReasonedError<Reason> {
     readonly name = "DataTrackPublishError";
     reason: Reason;
     reasonName: string;
+    /** Underling message from the SFU, if one was provided */
+    rawMessage?: string;
     constructor(message: string, reason: Reason, options?: {
+        rawMessage?: string;
         cause?: unknown;
     });
-    static notAllowed(): DataTrackPublishError<DataTrackPublishErrorReason.NotAllowed>;
-    static duplicateName(): DataTrackPublishError<DataTrackPublishErrorReason.DuplicateName>;
+    static notAllowed(rawMessage?: string): DataTrackPublishError<DataTrackPublishErrorReason.NotAllowed>;
+    static duplicateName(rawMessage?: string): DataTrackPublishError<DataTrackPublishErrorReason.DuplicateName>;
+    static invalidName(rawMessage?: string): DataTrackPublishError<DataTrackPublishErrorReason.InvalidName>;
     static timeout(): DataTrackPublishError<DataTrackPublishErrorReason.Timeout>;
-    static limitReached(): DataTrackPublishError<DataTrackPublishErrorReason.LimitReached>;
+    static limitReached(rawMessage?: string): DataTrackPublishError<DataTrackPublishErrorReason.LimitReached>;
+    static unknown(reason: number, message: string): DataTrackPublishError<DataTrackPublishErrorReason.Unknown>;
     static disconnected(): DataTrackPublishError<DataTrackPublishErrorReason.Disconnected>;
     static cancelled(): DataTrackPublishError<DataTrackPublishErrorReason.Cancelled>;
 }
@@ -45,7 +55,7 @@ export declare class DataTrackPushFrameError<Reason extends DataTrackPushFrameEr
         cause?: unknown;
     });
     static trackUnpublished(): DataTrackPushFrameError<DataTrackPushFrameErrorReason.TrackUnpublished>;
-    static dropped(cause: unknown): DataTrackPushFrameError<DataTrackPushFrameErrorReason.Dropped>;
+    static dropped(cause?: unknown): DataTrackPushFrameError<DataTrackPushFrameErrorReason.Dropped>;
 }
 export declare enum DataTrackOutgoingPipelineErrorReason {
     Packetizer = 0,