livekit-client 2.17.1 → 2.17.3

package/dist/ts4.2/e2ee/types.d.ts

@@ -20,6 +20,7 @@ export interface SetKeyMessage extends BaseMessage {
         isPublisher: boolean;
         key: CryptoKey;
         keyIndex?: number;
+        updateCurrentKeyIndex: boolean;
     };
 }
 export interface RTPVideoMapMessage extends BaseMessage {

package/dist/ts4.2/e2ee/worker/ParticipantKeyHandler.d.ts

@@ -62,14 +62,14 @@ export declare class ParticipantKeyHandler extends ParticipantKeyHandler_base {
      * together with the material
      * also resets the valid key property and updates the currentKeyIndex
      */
-    setKey(material: CryptoKey, keyIndex?: number): Promise<void>;
+    setKey(material: CryptoKey, keyIndex?: number, updateCurrentKeyIndex?: boolean): Promise<void>;
     /**
      * takes in a key material with `deriveBits` and `deriveKey` set as key usages
      * and derives encryption keys from the material and sets it on the key ring buffers
      * together with the material
      * also updates the currentKeyIndex
      */
-    setKeyFromMaterial(material: CryptoKey, keyIndex: number, ratchetedResult?: RatchetResult | null): Promise<void>;
+    setKeyFromMaterial(material: CryptoKey, keyIndex: number, ratchetedResult?: RatchetResult | null, updateCurrentKeyIndex?: boolean): Promise<void>;
     setKeySet(keySet: KeySet, keyIndex: number, ratchetedResult?: RatchetResult | null): void;
     setCurrentKeyIndex(index: number): Promise<void>;
     getCurrentKeyIndex(): number;

package/dist/ts4.2/index.d.ts

@@ -3,10 +3,13 @@ import { DataPacket_Kind, DisconnectReason, Encryption_Type, SubscriptionError,
 import { LogLevel, LoggerNames, getLogger, setLogExtension, setLogLevel } from './logger';
 import DefaultReconnectPolicy from './room/DefaultReconnectPolicy';
 import type { ReconnectContext, ReconnectPolicy } from './room/ReconnectPolicy';
+import type Room, { RoomEventCallbacks } from './room/Room';
 import Room, { ConnectionState } from './room/Room';
-import type { RoomEventCallbacks } from './room/Room';
 import * as attributes from './room/attribute-typings';
+import './room/data-track/depacketizer';
+import './room/data-track/outgoing/OutgoingDataTrackManager';
 import LocalParticipant from './room/participant/LocalParticipant';
+import type Participant, { ParticipantEventCallbacks } from './room/participant/Participant';
 import Participant, { ConnectionQuality, ParticipantKind } from './room/participant/Participant';
 import type { ParticipantTrackPermission } from './room/participant/ParticipantTrackPermission';
 import RemoteParticipant from './room/participant/RemoteParticipant';
@@ -21,8 +24,9 @@ import RemoteTrack from './room/track/RemoteTrack';
 import RemoteTrackPublication from './room/track/RemoteTrackPublication';
 import type { ElementInfo } from './room/track/RemoteVideoTrack';
 import RemoteVideoTrack from './room/track/RemoteVideoTrack';
+import type { PublicationEventCallbacks } from './room/track/TrackPublication';
 import { TrackPublication } from './room/track/TrackPublication';
-import type { LiveKitReactNativeInfo } from './room/types';
+import type { LiveKitReactNativeInfo, TextStreamInfo } from './room/types';
 import type { AudioAnalyserOptions } from './room/utils';
 import { compareVersions, createAudioAnalyser, getEmptyAudioStreamTrack, getEmptyVideoStreamTrack, isAudioCodec, isAudioTrack, isBrowserSupported, isLocalParticipant, isLocalTrack, isRemoteParticipant, isRemoteTrack, isVideoCodec, isVideoTrack, supportsAV1, supportsAdaptiveStream, supportsAudioOutputSelection, supportsDynacast, supportsVP9 } from './room/utils';
 import { getBrowser } from './utils/browserParser';
@@ -50,7 +54,7 @@ export * from './version';
 export { 
 /** @internal */
 attributes, ConnectionQuality, ConnectionState, CriticalTimers, DataPacket_Kind, Encryption_Type, DefaultReconnectPolicy, DisconnectReason, LocalAudioTrack, LocalParticipant, LocalTrack, LocalTrackPublication, LocalVideoTrack, LogLevel, LoggerNames, Participant, RemoteAudioTrack, RemoteParticipant, ParticipantKind, RemoteTrack, RemoteTrackPublication, RemoteVideoTrack, Room, SubscriptionError, TrackPublication, TrackType, compareVersions, createAudioAnalyser, getBrowser, getEmptyAudioStreamTrack, getEmptyVideoStreamTrack, getLogger, isBrowserSupported, setLogExtension, setLogLevel, supportsAV1, supportsAdaptiveStream, supportsAudioOutputSelection, supportsDynacast, supportsVP9, Mutex, isAudioCodec, isAudioTrack, isLocalTrack, isRemoteTrack, isVideoCodec, isVideoTrack, isLocalParticipant, isRemoteParticipant, };
-export type { AudioAnalyserOptions, ElementInfo, LiveKitReactNativeInfo, ParticipantTrackPermission, AudioReceiverStats, AudioSenderStats, VideoReceiverStats, VideoSenderStats, ReconnectContext, ReconnectPolicy, RoomEventCallbacks, };
+export type { AudioAnalyserOptions, ElementInfo, LiveKitReactNativeInfo, TextStreamInfo, ParticipantTrackPermission, AudioReceiverStats, AudioSenderStats, VideoReceiverStats, VideoSenderStats, ReconnectContext, ReconnectPolicy, RoomEventCallbacks, ParticipantEventCallbacks, PublicationEventCallbacks, };
 export type { DataTrackPacketHeader } from './room/data-track/packet';
 export { DataTrackPacket } from './room/data-track/packet';
 export type { DataTrackExtensions, DataTrackUserTimestampExtension, DataTrackE2eeExtension } from './room/data-track/packet/extensions';

package/dist/ts4.2/logger.d.ts

@@ -18,7 +18,8 @@ export declare enum LoggerNames {
     Signal = "livekit-signal",
     PCManager = "livekit-pc-manager",
     PCTransport = "livekit-pc-transport",
-    E2EE = "lk-e2ee"
+    E2EE = "lk-e2ee",
+    DataTracks = "livekit-data-tracks"
 }
 type LogLevelString = keyof typeof LogLevel;
 export type StructuredLogger = log.Logger & {

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

@@ -42,12 +42,7 @@ export default class PCTransport extends EventEmitter {
     get isICEConnected(): boolean;
     addIceCandidate(candidate: RTCIceCandidateInit): Promise<void>;
     setRemoteDescription(sd: RTCSessionDescriptionInit, offerId: number): Promise<boolean>;
-    negotiate: {
-        (this: unknown, ...args: [
-            onError?: ((e: Error) => void) | undefined
-        ] & any[]): Promise<Promise<void>>;
-        cancel: (reason?: any) => void;
-    };
+    negotiate: import("./debounce").DebouncedFunction<any[], (onError?: (e: Error) => void) => Promise<void>>;
     createAndSendOffer(options?: RTCOfferOptions): Promise<void>;
     createAndSetAnswer(): Promise<RTCSessionDescriptionInit>;
     createDataChannel(label: string, dataChannelDict: RTCDataChannelInit): RTCDataChannel;

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

@@ -1,6 +1,5 @@
 import type { DataStream_Chunk } from '@livekit/protocol';
 import type { BaseStreamInfo, ByteStreamInfo, TextStreamInfo } from '../../types';
-import { Future } from '../../utils';
 export type BaseStreamReaderReadAllOpts = {
     /** An AbortSignal can be used to terminate reads early. */
     signal?: AbortSignal;
@@ -10,11 +9,10 @@ declare abstract class BaseStreamReader<T extends BaseStreamInfo> {
     protected totalByteSize?: number;
     protected _info: T;
     protected bytesReceived: number;
-    protected outOfBandFailureRejectingFuture?: Future<never, Error>;
     get info(): T;
     /** @internal */
     protected validateBytesReceived(doneReceiving?: boolean): void;
-    constructor(info: T, stream: ReadableStream<DataStream_Chunk>, totalByteSize?: number, outOfBandFailureRejectingFuture?: Future<never, Error>);
+    constructor(info: T, stream: ReadableStream<DataStream_Chunk>, totalByteSize?: number);
     protected abstract handleChunkReceived(chunk: DataStream_Chunk): void;
     onProgress?: (progress: number | undefined) => void;
     abstract readAll(opts?: BaseStreamReaderReadAllOpts): Promise<string | Array<Uint8Array>>;
@@ -47,7 +45,7 @@ export declare class TextStreamReader extends BaseStreamReader<TextStreamInfo> {
      * A TextStreamReader instance can be used as an AsyncIterator that returns the entire string
      * that has been received up to the current point in time.
      */
-    constructor(info: TextStreamInfo, stream: ReadableStream<DataStream_Chunk>, totalChunkCount?: number, outOfBandFailureRejectingFuture?: Future<never, Error>);
+    constructor(info: TextStreamInfo, stream: ReadableStream<DataStream_Chunk>, totalChunkCount?: number);
     protected handleChunkReceived(chunk: DataStream_Chunk): void;
     /**
      * @param progress - progress of the stream between 0 and 1. Undefined for streams of unknown size

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

@@ -0,0 +1,51 @@
+import type { Throws } from '../../utils/throws';
+import { LivekitReasonedError } from '../errors';
+import type { DataTrackFrame } from './frame';
+import { DataTrackPacket } from './packet';
+/** An error indicating a frame was dropped. */
+export declare class DataTrackDepacketizerDropError<Reason extends DataTrackDepacketizerDropReason> extends LivekitReasonedError<Reason> {
+    readonly name = "DataTrackDepacketizerDropError";
+    reason: Reason;
+    reasonName: string;
+    frameNumber: number;
+    constructor(message: string, reason: Reason, frameNumber: number, options?: {
+        cause?: unknown;
+    });
+    static interrupted(frameNumber: 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>;
+}
+/** Reason why a frame was dropped. */
+export declare enum DataTrackDepacketizerDropReason {
+    Interrupted = 0,
+    UnknownFrame = 1,
+    BufferFull = 2,
+    Incomplete = 3
+}
+type PushOptions = {
+    /** If true, throws an error instead of logging a warning when a new frame is encountered half way
+     * through processing a pre-existing frame. */
+    errorOnPartialFrames: boolean;
+};
+export default class DataTrackDepacketizer {
+    /** Maximum number of packets to buffer per frame before dropping. */
+    static MAX_BUFFER_PACKETS: number;
+    private partial;
+    /** 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}
+     * is returned.*/
+    push(packet: DataTrackPacket, options?: PushOptions): Throws<DataTrackFrame | null, DataTrackDepacketizerDropError<DataTrackDepacketizerDropReason.Interrupted> | DataTrackDepacketizerDropError<DataTrackDepacketizerDropReason.BufferFull> | DataTrackDepacketizerDropError<DataTrackDepacketizerDropReason.UnknownFrame> | DataTrackDepacketizerDropError<DataTrackDepacketizerDropReason.Incomplete>>;
+    reset(): void;
+    private frameFromSingle;
+    /** Begin assembling a new packet. */
+    private beginPartial;
+    /** Push to the existing partial frame. */
+    private pushToPartial;
+    /** Try to reassemble the complete frame. */
+    private finalize;
+}
+export {};
+//# sourceMappingURL=depacketizer.d.ts.map

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

@@ -0,0 +1,12 @@
+export type EncryptedPayload = {
+    payload: Uint8Array;
+    iv: Uint8Array;
+    keyIndex: number;
+};
+export type EncryptionProvider = {
+    encrypt(payload: Uint8Array): EncryptedPayload;
+};
+export type DecryptionProvider = {
+    decrypt(payload: Uint8Array, senderIdentity: string): Uint8Array;
+};
+//# sourceMappingURL=e2ee.d.ts.map

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

@@ -0,0 +1,7 @@
+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;
+    extensions: DataTrackExtensions;
+};
+//# sourceMappingURL=frame.d.ts.map

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

@@ -13,15 +13,14 @@ export declare class DataTrackHandleError<Reason extends DataTrackHandleErrorRea
     static tooLarge(): DataTrackHandleError<DataTrackHandleErrorReason.TooLarge>;
     static reserved(value: number): DataTrackHandleError<DataTrackHandleErrorReason.Reserved>;
 }
-export declare class DataTrackHandle {
-    value: number;
-    static fromNumber(raw: number): Throws<DataTrackHandle, DataTrackHandleError<DataTrackHandleErrorReason.TooLarge> | DataTrackHandleError<DataTrackHandleErrorReason.Reserved>>;
-    constructor(raw: number);
-}
+export type DataTrackHandle = number;
+export declare const DataTrackHandle: {
+    fromNumber(raw: number): Throws<DataTrackHandle, DataTrackHandleError<DataTrackHandleErrorReason.TooLarge> | DataTrackHandleError<DataTrackHandleErrorReason.Reserved>>;
+};
 /** Manage allocating new handles which don't conflict over the lifetime of the client. */
 export declare class DataTrackHandleAllocator {
-    static value: number;
+    value: number;
     /** Returns a unique track handle for the next publication, if one can be obtained. */
-    static get(): DataTrackHandle | null;
+    get(): DataTrackHandle | null;
 }
 //# sourceMappingURL=handle.d.ts.map

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

@@ -0,0 +1,77 @@
+import type TypedEmitter from 'typed-emitter';
+import type { Throws } from '../../../utils/throws';
+import { Future } from '../../utils';
+import type { EncryptionProvider } from '../e2ee';
+import { DataTrackHandle } from '../handle';
+import type { DataTrackInfo } from '../track';
+import { LocalDataTrack } from '../track';
+import { DataTrackPublishError, DataTrackPublishErrorReason, DataTrackPushFrameError, DataTrackPushFrameErrorReason } from './errors';
+import DataTrackOutgoingPipeline from './pipeline';
+import type { DataTrackOptions, OutputEventPacketsAvailable, OutputEventSfuPublishRequest, OutputEventSfuUnpublishRequest, 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>>;
+};
+export type ActiveDescriptor = {
+    type: 'active';
+    info: DataTrackInfo;
+    pipeline: DataTrackOutgoingPipeline;
+    /** Resolves when the descriptor is unpublished. */
+    unpublishingFuture: Future<void, never>;
+};
+export type Descriptor = PendingDescriptor | ActiveDescriptor;
+export declare const Descriptor: {
+    pending(): PendingDescriptor;
+    active(info: DataTrackInfo, encryptionProvider: EncryptionProvider | null): ActiveDescriptor;
+};
+export type DataTrackOutgoingManagerCallbacks = {
+    /** Request sent to the SFU to publish a track. */
+    sfuPublishRequest: (event: OutputEventSfuPublishRequest) => void;
+    /** Request sent to the SFU to unpublish a track. */
+    sfuUnpublishRequest: (event: OutputEventSfuUnpublishRequest) => void;
+    /** Serialized packets are ready to be sent over the transport. */
+    packetsAvailable: (event: OutputEventPacketsAvailable) => void;
+};
+type DataTrackLocalManagerOptions = {
+    /**
+     * Provider to use for encrypting outgoing frame payloads.
+     *
+     * If none, end-to-end encryption will be disabled for all published tracks.
+     */
+    encryptionProvider?: EncryptionProvider;
+};
+declare const OutgoingDataTrackManager_base: new () => TypedEmitter<DataTrackOutgoingManagerCallbacks>;
+export default class OutgoingDataTrackManager extends OutgoingDataTrackManager_base {
+    private encryptionProvider;
+    private handleAllocator;
+    private descriptors;
+    constructor(options?: DataTrackLocalManagerOptions);
+    static withDescriptors(descriptors: Map<DataTrackHandle, Descriptor>): OutgoingDataTrackManager;
+    /**
+     * 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. */
+    unpublishRequest(handle: DataTrackHandle): Promise<void>;
+    /** SFU responded to a request to publish a data track. */
+    receivedSfuPublishResponse(handle: DataTrackHandle, result: SfuPublishResponseResult): void;
+    /** SFU notification that a track has been unpublished. */
+    receivedSfuUnpublishResponse(handle: DataTrackHandle): void;
+    /** Shuts down the manager and all associated tracks. */
+    shutdown(): Promise<void>;
+}
+export {};
+//# sourceMappingURL=OutgoingDataTrackManager.d.ts.map

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

@@ -0,0 +1,64 @@
+import { LivekitReasonedError } from '../../errors';
+import { DataTrackPacketizerError, DataTrackPacketizerReason } from '../packetizer';
+export declare enum DataTrackPublishErrorReason {
+    /**
+     * Local participant does not have permission to publish data tracks.
+     *
+     * Ensure the participant's token contains the `canPublishData` grant.
+     */
+    NotAllowed = 0,
+    /** A track with the same name is already published by the local participant. */
+    DuplicateName = 1,
+    /** Request to publish the track took long to complete. */
+    Timeout = 2,
+    /** No additional data tracks can be published by the local participant. */
+    LimitReached = 3,
+    /** Cannot publish data track when the room is disconnected. */
+    Disconnected = 4,
+    Cancelled = 5
+}
+export declare class DataTrackPublishError<Reason extends DataTrackPublishErrorReason> extends LivekitReasonedError<Reason> {
+    readonly name = "DataTrackPublishError";
+    reason: Reason;
+    reasonName: string;
+    constructor(message: string, reason: Reason, options?: {
+        cause?: unknown;
+    });
+    static notAllowed(): DataTrackPublishError<DataTrackPublishErrorReason.NotAllowed>;
+    static duplicateName(): DataTrackPublishError<DataTrackPublishErrorReason.DuplicateName>;
+    static timeout(): DataTrackPublishError<DataTrackPublishErrorReason.Timeout>;
+    static limitReached(): DataTrackPublishError<DataTrackPublishErrorReason.LimitReached>;
+    static disconnected(): DataTrackPublishError<DataTrackPublishErrorReason.Disconnected>;
+    static cancelled(): DataTrackPublishError<DataTrackPublishErrorReason.Cancelled>;
+}
+export declare enum DataTrackPushFrameErrorReason {
+    /** Track is no longer published. */
+    TrackUnpublished = 0,
+    /** Frame was dropped. */
+    Dropped = 1
+}
+export declare class DataTrackPushFrameError<Reason extends DataTrackPushFrameErrorReason> extends LivekitReasonedError<Reason> {
+    readonly name = "DataTrackPushFrameError";
+    reason: Reason;
+    reasonName: string;
+    constructor(message: string, reason: Reason, options?: {
+        cause?: unknown;
+    });
+    static trackUnpublished(): DataTrackPushFrameError<DataTrackPushFrameErrorReason.TrackUnpublished>;
+    static dropped(cause: unknown): DataTrackPushFrameError<DataTrackPushFrameErrorReason.Dropped>;
+}
+export declare enum DataTrackOutgoingPipelineErrorReason {
+    Packetizer = 0,
+    Encryption = 1
+}
+export declare class DataTrackOutgoingPipelineError<Reason extends DataTrackOutgoingPipelineErrorReason> extends LivekitReasonedError<Reason> {
+    readonly name = "DataTrackOutgoingPipelineError";
+    reason: Reason;
+    reasonName: string;
+    constructor(message: string, reason: Reason, options?: {
+        cause?: unknown;
+    });
+    static packetizer(cause: DataTrackPacketizerError<DataTrackPacketizerReason.MtuTooShort>): DataTrackOutgoingPipelineError<DataTrackOutgoingPipelineErrorReason.Packetizer>;
+    static encryption(cause: unknown): DataTrackOutgoingPipelineError<DataTrackOutgoingPipelineErrorReason.Encryption>;
+}
+//# sourceMappingURL=errors.d.ts.map

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

@@ -0,0 +1,22 @@
+import type { Throws } from '../../../utils/throws';
+import type { EncryptionProvider } from '../e2ee';
+import type { DataTrackFrame } from '../frame';
+import { DataTrackPacket } from '../packet';
+import type { DataTrackInfo } from '../track';
+import { DataTrackOutgoingPipelineError, DataTrackOutgoingPipelineErrorReason } from './errors';
+type Options = {
+    info: DataTrackInfo;
+    encryptionProvider: EncryptionProvider | null;
+};
+/** Processes outgoing frames into final packets for distribution to the SFU. */
+export default class DataTrackOutgoingPipeline {
+    private encryptionProvider;
+    private packetizer;
+    /** Maximum transmission unit (MTU) of the transport. */
+    private static TRANSPORT_MTU_BYTES;
+    constructor(options: Options);
+    processFrame(frame: DataTrackFrame): Throws<Generator<DataTrackPacket>, DataTrackOutgoingPipelineError<DataTrackOutgoingPipelineErrorReason.Packetizer> | DataTrackOutgoingPipelineError<DataTrackOutgoingPipelineErrorReason.Encryption>>;
+    encryptIfNeeded(frame: DataTrackFrame): Throws<DataTrackFrame, DataTrackOutgoingPipelineError<DataTrackOutgoingPipelineErrorReason.Encryption>>;
+}
+export {};
+//# sourceMappingURL=pipeline.d.ts.map

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

@@ -0,0 +1,31 @@
+import type { DataTrackHandle } from '../handle';
+import type { DataTrackInfo } from '../track';
+import type { DataTrackPublishError, DataTrackPublishErrorReason } from './errors';
+/** Options for publishing a data track. */
+export type DataTrackOptions = {
+    name: string;
+};
+/** Encodes whether a data track publish request to the SFU has been successful or not. */
+export type SfuPublishResponseResult = {
+    type: 'ok';
+    data: DataTrackInfo;
+} | {
+    type: 'error';
+    error: DataTrackPublishError<DataTrackPublishErrorReason.NotAllowed> | DataTrackPublishError<DataTrackPublishErrorReason.DuplicateName> | DataTrackPublishError<DataTrackPublishErrorReason.LimitReached>;
+};
+/** Request sent to the SFU to publish a track. */
+export type OutputEventSfuPublishRequest = {
+    handle: DataTrackHandle;
+    name: string;
+    usesE2ee: boolean;
+};
+/** Request sent to the SFU to unpublish a track. */
+export type OutputEventSfuUnpublishRequest = {
+    handle: DataTrackHandle;
+};
+/** Serialized packets are ready to be sent over the transport. */
+export type OutputEventPacketsAvailable = {
+    bytes: Uint8Array;
+    signal?: AbortSignal;
+};
+//# sourceMappingURL=types.d.ts.map

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

@@ -63,8 +63,8 @@ export declare enum FrameMarker {
 /** A class for serializing / deserializing data track packets. */
 export declare class DataTrackPacket extends Serializable {
     header: DataTrackPacketHeader;
-    payload: ArrayBuffer;
-    constructor(header: DataTrackPacketHeader, payload: ArrayBuffer);
+    payload: Uint8Array;
+    constructor(header: DataTrackPacketHeader, payload: Uint8Array);
     toBinaryLengthBytes(): number;
     toBinaryInto(dataView: DataView): Throws<number, DataTrackSerializeErrorAll>;
     static fromBinary<Input extends DataView | ArrayBuffer | Uint8Array>(input: Input): Throws<[
@@ -92,7 +92,7 @@ export declare class DataTrackPacket extends Serializable {
                 } | null;
             };
         };
-        payload: ArrayBuffer;
+        payload: Uint8Array<ArrayBufferLike>;
     };
 }
 //# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,43 @@
+import type { Throws } from '../../utils/throws';
+import { LivekitReasonedError } from '../errors';
+import type { DataTrackFrame } from './frame';
+import { DataTrackHandle } from './handle';
+import { DataTrackPacket, FrameMarker } from './packet';
+import { DataTrackTimestamp } from './utils';
+type PacketizeOptions = {
+    /** "now" timestamp to use as a base when generating new packet timestamps. If not specified,
+     * defaults to the return value of {@link DataTrackClock#now}. */
+    now?: DataTrackTimestamp<90000>;
+};
+export declare class DataTrackPacketizerError<Reason extends DataTrackPacketizerReason> extends LivekitReasonedError<Reason> {
+    readonly name = "DataTrackPacketizerError";
+    reason: Reason;
+    reasonName: string;
+    constructor(message: string, reason: Reason, options?: {
+        cause?: unknown;
+    });
+    static mtuTooShort(): DataTrackPacketizerError<DataTrackPacketizerReason>;
+}
+export declare enum DataTrackPacketizerReason {
+    MtuTooShort = 0
+}
+/** A packetizer takes a {@link DataTrackFrame} as input and generates a series
+ * of {@link DataTrackPacket}s for transmission to other clients over webrtc. */
+export default class DataTrackPacketizer {
+    private handle;
+    private mtuSizeBytes;
+    private sequence;
+    private frameNumber;
+    private clock;
+    constructor(trackHandle: DataTrackHandle, mtuSizeBytes: number);
+    /** @internal */
+    static computeFrameMarker(index: number, packetCount: number): FrameMarker;
+    /** Generates a series of packets for the specified {@link DataTrackPacketizerFrame}.
+     *
+     * NOTE: The return value of this function is a generator, so it can be lazily ran if desired,
+     * or converted to an array with {@link Array.from}.
+     */
+    packetize(frame: DataTrackFrame, options?: PacketizeOptions): Throws<Generator<DataTrackPacket>, DataTrackPacketizerError<DataTrackPacketizerReason.MtuTooShort>>;
+}
+export {};
+//# sourceMappingURL=packetizer.d.ts.map

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

@@ -0,0 +1,30 @@
+import type { DataTrackFrame } from './frame';
+import type { DataTrackHandle } from './handle';
+import type OutgoingDataTrackManager from './outgoing/OutgoingDataTrackManager';
+export type DataTrackSid = string;
+/** Information about a published data track. */
+export type DataTrackInfo = {
+    sid: DataTrackSid;
+    pubHandle: DataTrackHandle;
+    name: String;
+    usesE2ee: boolean;
+};
+export declare class LocalDataTrack {
+    info: DataTrackInfo;
+    protected manager: OutgoingDataTrackManager;
+    constructor(info: DataTrackInfo, manager: OutgoingDataTrackManager);
+    /** The raw descriptor from the manager containing the internal state for this local track. */
+    protected get descriptor(): import("./outgoing/OutgoingDataTrackManager").Descriptor | null;
+    isPublished(): boolean;
+    /** Try pushing a frame to subscribers of the track.
+     *
+     * Pushing a frame can fail for several reasons:
+     *
+     * - The track has been unpublished by the local participant or SFU
+     * - The room is no longer connected
+     */
+    tryPush(payload: DataTrackFrame['payload']): void & {
+        readonly __throws?: import("./outgoing/errors").DataTrackPushFrameError<import("./outgoing/errors").DataTrackPushFrameErrorReason.Dropped> | import("./outgoing/errors").DataTrackPushFrameError<import("./outgoing/errors").DataTrackPushFrameErrorReason.TrackUnpublished> | undefined;
+    };
+}
+//# sourceMappingURL=track.d.ts.map

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

@@ -1,4 +1,5 @@
 export declare const U16_MAX_SIZE = 65535;
+export declare const U32_MAX_SIZE = 4294967295;
 /**
  * A number of fields withing the data tracks packet specification assume wrap around behavior when
  * an unsigned type is incremented beyond its max size (ie, the packet `sequence` field). This
@@ -9,20 +10,51 @@ export declare class WrapAroundUnsignedInt<MaxSize extends number> {
     value: number;
     private maxSize;
     static u16(raw: number): WrapAroundUnsignedInt<65535>;
+    static u32(raw: number): WrapAroundUnsignedInt<4294967295>;
     constructor(raw: number, maxSize: MaxSize);
     /** Manually clamp the given containing value according to the wrap around max size bounds. Use
      * this after out of bounds modification to the contained value by external code. */
     clamp(): void;
+    clone(): WrapAroundUnsignedInt<MaxSize>;
     /** When called, maps the containing value to a new containing value. After mapping, the wrap
-     * around external max size bounds are applied. */
+     * around external max size bounds are applied. Note that this is a mutative operation. */
     update(updateFn: (value: number) => number): void;
+    /** Increments the given `n` to the inner value. Note that this is a mutative operation. */
+    increment(n?: number): void;
+    /** Decrements the given `n` from the inner value. Note that this is a mutative operation. */
+    decrement(n?: number): void;
+    getThenIncrement(): WrapAroundUnsignedInt<MaxSize>;
+    /** Returns true if {@link this} is before the passed other {@link WrapAroundUnsignedInt}. */
+    isBefore(other: WrapAroundUnsignedInt<MaxSize>): boolean;
 }
 export declare class DataTrackTimestamp<RateInHz extends number> {
     rateInHz: RateInHz;
-    timestamp: number;
+    timestamp: WrapAroundUnsignedInt<typeof U32_MAX_SIZE>;
     static fromRtpTicks(rtpTicks: number): DataTrackTimestamp<90000>;
+    /** Generates a timestamp initialized to a non cryptographically secure random value, so that
+     * different streams are more difficult to correlate in packet capture. */
+    static rtpRandom(): DataTrackTimestamp<90000>;
+    private constructor();
     asTicks(): number;
+    clone(): DataTrackTimestamp<RateInHz>;
+    wrappingAdd(n: number): void;
+    /** Returns true if {@link this} is before the passed other {@link DataTrackTimestamp}. */
+    isBefore(other: DataTrackTimestamp<RateInHz>): boolean;
+}
+export declare class DataTrackClock<RateInHz extends number> {
+    epoch: Date;
+    base: DataTrackTimestamp<RateInHz>;
+    previous: DataTrackTimestamp<RateInHz>;
+    rateInHz: RateInHz;
     private constructor();
+    static startingNow<RateInHz extends number>(base: DataTrackTimestamp<RateInHz>, rateInHz: RateInHz): DataTrackClock<RateInHz>;
+    static startingAtTime<RateInHz extends number>(epoch: Date, base: DataTrackTimestamp<RateInHz>, rateInHz: RateInHz): DataTrackClock<RateInHz>;
+    static rtpStartingNow(base: DataTrackTimestamp<90000>): DataTrackClock<90000>;
+    static rtpStartingAtTime(epoch: Date, base: DataTrackTimestamp<90000>): DataTrackClock<90000>;
+    now(): DataTrackTimestamp<RateInHz>;
+    at(timestamp: Date): DataTrackTimestamp<RateInHz>;
+    /** Convert a duration since the epoch into clock ticks. */
+    static durationInMsToTicks(durationMilliseconds: number, rateInHz: number): number;
 }
 export declare function coerceToDataView<Input extends DataView | ArrayBuffer | Uint8Array>(input: Input): DataView;
 //# sourceMappingURL=utils.d.ts.map

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

@@ -0,0 +1,11 @@
+export type Options<Result> = {
+    isImmediate?: boolean;
+    maxWait?: number;
+    callback?: (data: Result) => void;
+};
+export interface DebouncedFunction<Args extends any[], F extends (...args: Args) => any> {
+    (this: ThisParameterType<F>, ...args: Args & Parameters<F>): Promise<ReturnType<F>>;
+    cancel: (reason?: any) => void;
+}
+export declare function debounce<Args extends any[], F extends (...args: Args) => any>(func: F, waitMilliseconds?: number, options?: Options<ReturnType<F>>): DebouncedFunction<Args, F>;
+//# sourceMappingURL=debounce.d.ts.map

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

@@ -29,7 +29,7 @@ export declare enum RoomEvent {
     Reconnected = "reconnected",
     /**
      * When disconnected from room. This fires when room.disconnect() is called or
-     * when an unrecoverable connection issue had occured.
+     * when an unrecoverable connection issue had occurred.
      *
      * DisconnectReason can be used to determine why the participant was disconnected. Notable reasons are
      * - DUPLICATE_IDENTITY: another client with the same identity has joined the room

package/dist/ts4.2/room/track/LocalAudioTrack.d.ts

@@ -24,7 +24,7 @@ export default class LocalAudioTrack extends LocalTrack<Track.Kind.Audio> {
     mute(): Promise<typeof this>;
     unmute(): Promise<typeof this>;
     restartTrack(options?: AudioCaptureOptions): Promise<void>;
-    protected restart(constraints?: MediaTrackConstraints): Promise<typeof this>;
+    protected restart(constraints?: MediaTrackConstraints, isUnmuting?: boolean): Promise<typeof this>;
     startMonitor(): void;
     protected monitorSender: () => Promise<void>;
     private handleKrispNoiseFilterEnable;

package/dist/ts4.2/room/track/LocalTrack.d.ts

@@ -27,6 +27,7 @@ export default abstract class LocalTrack<TrackKind extends Track.Kind = Track.Ki
     protected manuallyStopped: boolean;
     protected localTrackRecorder: LocalTrackRecorder<typeof this> | undefined;
     protected trackChangeLock: Mutex;
+    protected pendingDeviceChange: boolean;
     /**
      *
      * @param mediaTrack
@@ -59,7 +60,7 @@ export default abstract class LocalTrack<TrackKind extends Track.Kind = Track.Ki
     unmute(): Promise<this>;
     replaceTrack(track: MediaStreamTrack, options?: ReplaceTrackOptions): Promise<typeof this>;
     replaceTrack(track: MediaStreamTrack, userProvidedTrack?: boolean): Promise<typeof this>;
-    protected restart(constraints?: MediaTrackConstraints): Promise<this>;
+    protected restart(constraints?: MediaTrackConstraints, isUnmuting?: boolean): Promise<this>;
     protected setTrackMuted(muted: boolean): void;
     protected get needsReAcquisition(): boolean;
     protected handleAppVisibilityChanged(): Promise<void>;

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

@@ -1,5 +1,4 @@
 import type { DataStream_Chunk, Encryption_Type } from '@livekit/protocol';
-import type { Future } from './utils';
 export type SimulationOptions = {
     publish?: {
         audio?: boolean;
@@ -91,7 +90,6 @@ export interface StreamController<T extends DataStream_Chunk> {
     startTime: number;
     endTime?: number;
     sendingParticipantIdentity: string;
-    outOfBandFailureRejectingFuture: Future<never, Error>;
 }
 export interface BaseStreamInfo {
     id: string;