livekit-client 2.17.2 → 2.18.0

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

@@ -1,4 +1,4 @@
-import type { Throws } from '../../utils/throws';
+import type { Throws } from '@livekit/throws-transformer/throws';
 import { LivekitReasonedError } from '../errors';
 export declare enum DataTrackHandleErrorReason {
     Reserved = 0,
@@ -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>;
+};
 /** 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/incoming/IncomingDataTrackManager.d.ts

@@ -0,0 +1,99 @@
+import type { Throws } from '@livekit/throws-transformer/throws';
+import type TypedEmitter from 'typed-emitter';
+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';
+import { DataTrackSubscribeError } from './errors';
+import type { EventSfuUpdateSubscription, EventTrackAvailable, EventTrackUnavailable } from './types';
+export type DataTrackIncomingManagerCallbacks = {
+    /** Request sent to the SFU to update the subscription for a data track. */
+    sfuUpdateSubscription: (event: EventSfuUpdateSubscription) => void;
+    /** A track has been published by a remote participant and is available to be
+     * subscribed to. */
+    trackAvailable: (event: EventTrackAvailable) => void;
+    /** A track has been unpublished by a remote participant and can no longer be subscribed to. */
+    trackUnavailable: (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;
+};
+declare const IncomingDataTrackManager_base: new () => TypedEmitter<DataTrackIncomingManagerCallbacks>;
+export default class IncomingDataTrackManager extends IncomingDataTrackManager_base {
+    private decryptionProvider;
+    /** Mapping between track SID and descriptor. */
+    private descriptors;
+    /** Mapping between subscriber handle and track SID.
+     *
+     * This is an index that allows track descriptors to be looked up
+     * by subscriber handle in O(1) time, to make routing incoming packets
+     * a (hot code path) faster.
+     */
+    private subscriptionHandles;
+    constructor(options?: IncomingDataTrackManagerOptions);
+    /** Client requested to subscribe to a data track.
+     *
+     * This is sent when the user calls {@link RemoteDataTrack.subscribe}.
+     *
+     * Only the first request to subscribe to a given track incurs meaningful overhead; subsequent
+     * 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;
+    /**
+     * Get information about all currently subscribed tracks.
+     * @internal */
+    querySubscribed(): Promise<[
+        info: DataTrackInfo,
+        identity: string
+    ][]>;
+    /** Client requested to unsubscribe from a data track. */
+    unSubscribeRequest(sid: DataTrackSid): void;
+    /** SFU notification that track publications have changed.
+     *
+     * This event is produced from both {@link JoinResponse} and {@link ParticipantUpdate}
+     * to provide a complete view of remote participants' track publications:
+     *
+     * - From a `JoinResponse`, it captures the initial set of tracks published when a participant joins.
+     * - From a `ParticipantUpdate`, it captures subsequent changes (i.e., new tracks being
+     *   published and existing tracks unpublished).
+     */
+    receiveSfuPublicationUpdates(updates: Map<Participant['identity'], Array<DataTrackInfo>>): Promise<void>;
+    /**
+     * Get information about all currently remotely published tracks which could be subscribed to.
+     * @internal */
+    queryPublications(): Promise<DataTrackInfo[]>;
+    handleTrackPublished(publisherIdentity: Participant['identity'], info: DataTrackInfo): Promise<void>;
+    handleTrackUnpublished(sid: DataTrackSid): void;
+    /** SFU notification that handles have been assigned for requested subscriptions. */
+    receivedSfuSubscriberHandles(
+    /** Mapping between track handles attached to incoming packets to the
+     * track SIDs they belong to. */
+    mapping: Map<DataTrackHandle, DataTrackSid>): void;
+    private registerSubscriberHandle;
+    /** Packet has been received over the transport. */
+    packetReceived(bytes: Uint8Array): Throws<void, DataTrackDepacketizerDropError>;
+    /** Resend all subscription updates.
+     *
+     * This must be sent after a full reconnect to ensure the SFU knows which
+     * tracks are subscribed to locally.
+     */
+    resendSubscriptionUpdates(): void;
+    /** Called when a remote participant is disconnected so that any pending data tracks can be
+     * cancelled. */
+    handleRemoteParticipantDisconnected(remoteParticipantIdentity: RemoteParticipant['identity']): void;
+    /** Shutdown the manager, ending any subscriptions. */
+    shutdown(): void;
+}
+export {};
+//# sourceMappingURL=IncomingDataTrackManager.d.ts.map

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

@@ -0,0 +1,24 @@
+import { LivekitReasonedError } from '../../errors';
+export declare enum DataTrackSubscribeErrorReason {
+    /** The track has been unpublished and is no longer available */
+    Unpublished = 0,
+    /** Request to subscribe to data track timed-out */
+    Timeout = 1,
+    /** Cannot subscribe to data track when disconnected */
+    Disconnected = 2,
+    /** Subscription to data track cancelled by caller */
+    Cancelled = 4
+}
+export declare class DataTrackSubscribeError<Reason extends DataTrackSubscribeErrorReason = DataTrackSubscribeErrorReason> extends LivekitReasonedError<Reason> {
+    readonly name = "DataTrackSubscribeError";
+    reason: Reason;
+    reasonName: string;
+    constructor(message: string, reason: Reason, options?: {
+        cause?: unknown;
+    });
+    static unpublished(): DataTrackSubscribeError<DataTrackSubscribeErrorReason.Unpublished>;
+    static timeout(): DataTrackSubscribeError<DataTrackSubscribeErrorReason.Timeout>;
+    static disconnected(): DataTrackSubscribeError<DataTrackSubscribeErrorReason.Disconnected>;
+    static cancelled(): DataTrackSubscribeError<DataTrackSubscribeErrorReason.Cancelled>;
+}
+//# sourceMappingURL=errors.d.ts.map

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

@@ -0,0 +1,37 @@
+import type { Throws } from '@livekit/throws-transformer/throws';
+import { DataTrackDepacketizerDropError } from '../depacketizer';
+import type { DecryptionProvider } from '../e2ee';
+import type { DataTrackFrame } from '../frame';
+import { DataTrackPacket } from '../packet';
+import type { DataTrackInfo } from '../types';
+/**
+ * Options for creating a {@link IncomingDataTrackPipeline}.
+ */
+type Options = {
+    info: DataTrackInfo;
+    publisherIdentity: string;
+    decryptionProvider: DecryptionProvider | null;
+};
+/**
+ * Pipeline for an individual data track subscription.
+ */
+export default class IncomingDataTrackPipeline {
+    private publisherIdentity;
+    private e2eeProvider;
+    private depacketizer;
+    /**
+     * Creates a new pipeline with the given options.
+     */
+    constructor(options: Options);
+    processPacket(packet: DataTrackPacket): Throws<DataTrackFrame | null, DataTrackDepacketizerDropError>;
+    /**
+     * Depacketize the given frame, log if a drop occurs.
+     */
+    private depacketize;
+    /**
+     * Decrypt the frame's payload if E2EE is enabled for this track.
+     */
+    private decryptIfNeeded;
+}
+export {};
+//# sourceMappingURL=pipeline.d.ts.map

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

@@ -0,0 +1,20 @@
+import type Participant from '../../participant/Participant';
+import type RemoteDataTrack from '../RemoteDataTrack';
+import type { DataTrackSid } from '../types';
+/** Request sent to the SFU to update the subscription for a data track. */
+export type EventSfuUpdateSubscription = {
+    /** Identifier of the affected track. */
+    sid: DataTrackSid;
+    /** Whether to subscribe or unsubscribe. */
+    subscribe: boolean;
+};
+/** A track has been published by a remote participant and is available to be subscribed to. */
+export type EventTrackAvailable = {
+    track: RemoteDataTrack;
+};
+/** A track has been unpublished by a remote participant and can no longer be subscribed to. */
+export type EventTrackUnavailable = {
+    sid: DataTrackSid;
+    publisherIdentity: Participant['identity'];
+};
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1,77 @@
+import type { Throws } from '@livekit/throws-transformer/throws';
+import type TypedEmitter from 'typed-emitter';
+import { Future } from '../../utils';
+import LocalDataTrack from '../LocalDataTrack';
+import type { EncryptionProvider } from '../e2ee';
+import { DataTrackHandle } from '../handle';
+import type { DataTrackInfo } from '../types';
+import { DataTrackPublishError, DataTrackPublishErrorReason, DataTrackPushFrameError, DataTrackPushFrameErrorReason } from './errors';
+import DataTrackOutgoingPipeline from './pipeline';
+import type { DataTrackOptions, EventPacketsAvailable, EventSfuPublishRequest, EventSfuUnpublishRequest, 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: 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;
+};
+type OutgoingDataTrackManagerOptions = {
+    /**
+     * 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?: OutgoingDataTrackManagerOptions);
+    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 } 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 = 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 = DataTrackOutgoingPipelineErrorReason> extends LivekitReasonedError<Reason> {
+    readonly name = "DataTrackOutgoingPipelineError";
+    reason: Reason;
+    reasonName: string;
+    constructor(message: string, reason: Reason, options?: {
+        cause?: unknown;
+    });
+    static packetizer(cause: DataTrackPacketizerError): 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 '@livekit/throws-transformer/throws';
+import type { EncryptionProvider } from '../e2ee';
+import type { DataTrackFrame } from '../frame';
+import { DataTrackPacket } from '../packet';
+import type { DataTrackInfo } from '../types';
+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>;
+    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,30 @@
+import type { DataTrackHandle } from '../handle';
+import type { DataTrackInfo } from '../types';
+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 EventSfuPublishRequest = {
+    handle: DataTrackHandle;
+    name: string;
+    usesE2ee: boolean;
+};
+/** Request sent to the SFU to unpublish a track. */
+export type EventSfuUnpublishRequest = {
+    handle: DataTrackHandle;
+};
+/** Serialized packets are ready to be sent over the transport. */
+export type EventPacketsAvailable = {
+    bytes: Uint8Array;
+};
+//# sourceMappingURL=types.d.ts.map

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

@@ -8,7 +8,7 @@ export declare enum DataTrackDeserializeErrorReason {
     InvalidHandle = 4,
     MalformedExt = 5
 }
-export declare class DataTrackDeserializeError<Reason extends DataTrackDeserializeErrorReason> extends LivekitReasonedError<DataTrackDeserializeErrorReason> {
+export declare class DataTrackDeserializeError<Reason extends DataTrackDeserializeErrorReason = DataTrackDeserializeErrorReason> extends LivekitReasonedError<DataTrackDeserializeErrorReason> {
     readonly name = "DataTrackDeserializeError";
     reason: Reason;
     reasonName: string;
@@ -23,12 +23,11 @@ export declare class DataTrackDeserializeError<Reason extends DataTrackDeseriali
     static invalidHandle(cause: DataTrackHandleError): DataTrackDeserializeError<DataTrackDeserializeErrorReason.InvalidHandle>;
     static malformedExt(tag: number): DataTrackDeserializeError<DataTrackDeserializeErrorReason.MalformedExt>;
 }
-export type DataTrackDeserializeErrorAll = DataTrackDeserializeError<DataTrackDeserializeErrorReason.TooShort> | DataTrackDeserializeError<DataTrackDeserializeErrorReason.HeaderOverrun> | DataTrackDeserializeError<DataTrackDeserializeErrorReason.MissingExtWords> | DataTrackDeserializeError<DataTrackDeserializeErrorReason.UnsupportedVersion> | DataTrackDeserializeError<DataTrackDeserializeErrorReason.InvalidHandle> | DataTrackDeserializeError<DataTrackDeserializeErrorReason.MalformedExt>;
 export declare enum DataTrackSerializeErrorReason {
     TooSmallForHeader = 0,
     TooSmallForPayload = 1
 }
-export declare class DataTrackSerializeError<Reason extends DataTrackSerializeErrorReason> extends LivekitReasonedError<DataTrackSerializeErrorReason> {
+export declare class DataTrackSerializeError<Reason extends DataTrackSerializeErrorReason = DataTrackSerializeErrorReason> extends LivekitReasonedError<DataTrackSerializeErrorReason> {
     readonly name = "DataTrackSerializeError";
     reason: Reason;
     reasonName: string;
@@ -38,5 +37,4 @@ export declare class DataTrackSerializeError<Reason extends DataTrackSerializeEr
     static tooSmallForHeader(): DataTrackSerializeError<DataTrackSerializeErrorReason.TooSmallForHeader>;
     static tooSmallForPayload(): DataTrackSerializeError<DataTrackSerializeErrorReason.TooSmallForPayload>;
 }
-export type DataTrackSerializeErrorAll = DataTrackSerializeError<DataTrackSerializeErrorReason.TooSmallForHeader> | DataTrackSerializeError<DataTrackSerializeErrorReason.TooSmallForPayload>;
 //# sourceMappingURL=errors.d.ts.map

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

@@ -1,4 +1,4 @@
-import type { Throws } from '../../../utils/throws';
+import type { Throws } from '@livekit/throws-transformer/throws';
 import { DataTrackDeserializeError, DataTrackDeserializeErrorReason } from './errors';
 import Serializable from './serializable';
 export declare enum DataTrackExtensionTag {
@@ -12,7 +12,7 @@ declare abstract class DataTrackExtension extends Serializable {
 export declare class DataTrackUserTimestampExtension extends DataTrackExtension {
     static tag: DataTrackExtensionTag;
     static lengthBytes: number;
-    private timestamp;
+    timestamp: bigint;
     constructor(timestamp: bigint);
     toBinaryLengthBytes(): number;
     toBinaryInto(dataView: DataView): Throws<number, never>;
@@ -25,8 +25,8 @@ export declare class DataTrackUserTimestampExtension extends DataTrackExtension
 export declare class DataTrackE2eeExtension extends DataTrackExtension {
     static tag: DataTrackExtensionTag;
     static lengthBytes: number;
-    private keyIndex;
-    private iv;
+    keyIndex: number;
+    iv: Uint8Array;
     constructor(keyIndex: number, iv: Uint8Array);
     toBinaryLengthBytes(): number;
     toBinaryInto(dataView: DataView): Throws<number, never>;

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

@@ -1,8 +1,7 @@
-import type { Throws } from '../../../utils/throws';
+import type { Throws } from '@livekit/throws-transformer/throws';
 import { DataTrackHandle } from '../handle';
 import { DataTrackTimestamp, U16_MAX_SIZE, WrapAroundUnsignedInt } from '../utils';
-import type { DataTrackDeserializeErrorAll, DataTrackSerializeErrorAll } from './errors';
-import { DataTrackSerializeError, DataTrackSerializeErrorReason } from './errors';
+import { DataTrackDeserializeError, DataTrackSerializeError, DataTrackSerializeErrorReason } from './errors';
 import { DataTrackExtensions } from './extensions';
 import Serializable from './serializable';
 /** A class for serializing / deserializing data track packet header sections. */
@@ -27,7 +26,7 @@ export declare class DataTrackPacketHeader extends Serializable {
     static fromBinary<Input extends DataView | ArrayBuffer | Uint8Array>(input: Input): Throws<[
         header: DataTrackPacketHeader,
         byteLength: number
-    ], DataTrackDeserializeErrorAll>;
+    ], DataTrackDeserializeError>;
     toJSON(): {
         marker: FrameMarker;
         trackHandle: number;
@@ -66,11 +65,11 @@ export declare class DataTrackPacket extends Serializable {
     payload: Uint8Array;
     constructor(header: DataTrackPacketHeader, payload: Uint8Array);
     toBinaryLengthBytes(): number;
-    toBinaryInto(dataView: DataView): Throws<number, DataTrackSerializeErrorAll>;
+    toBinaryInto(dataView: DataView): Throws<number, DataTrackSerializeError>;
     static fromBinary<Input extends DataView | ArrayBuffer | Uint8Array>(input: Input): Throws<[
         packet: DataTrackPacket,
         byteLength: number
-    ], DataTrackDeserializeErrorAll>;
+    ], DataTrackDeserializeError>;
     toJSON(): {
         header: {
             marker: FrameMarker;

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

@@ -1,12 +1,12 @@
-import type { Throws } from '../../../utils/throws';
-import type { DataTrackSerializeErrorAll } from './errors';
+import type { Throws } from '@livekit/throws-transformer/throws';
+import { DataTrackSerializeError } from './errors';
 /** An abstract class implementing common behavior related to data track binary serialization. */
 export default abstract class Serializable {
     /** Returns the expected length of the serialized output in bytes */
     abstract toBinaryLengthBytes(): number;
     /** Given a DataView, serialize the instance inside and return the number of bytes written. */
-    abstract toBinaryInto(dataView: DataView): Throws<number, DataTrackSerializeErrorAll>;
+    abstract toBinaryInto(dataView: DataView): Throws<number, DataTrackSerializeError>;
     /** Encodes the instance as binary and returns the data as a Uint8Array. */
-    toBinary(): Throws<Uint8Array, DataTrackSerializeErrorAll>;
+    toBinary(): Throws<Uint8Array, DataTrackSerializeError>;
 }
 //# sourceMappingURL=serializable.d.ts.map

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

@@ -1,4 +1,4 @@
-import type { Throws } from '../../utils/throws';
+import type { Throws } from '@livekit/throws-transformer/throws';
 import { LivekitReasonedError } from '../errors';
 import type { DataTrackFrame } from './frame';
 import { DataTrackHandle } from './handle';
@@ -9,7 +9,7 @@ type PacketizeOptions = {
      * defaults to the return value of {@link DataTrackClock#now}. */
     now?: DataTrackTimestamp<90000>;
 };
-export declare class DataTrackPacketizerError<Reason extends DataTrackPacketizerReason> extends LivekitReasonedError<Reason> {
+export declare class DataTrackPacketizerError<Reason extends DataTrackPacketizerReason = DataTrackPacketizerReason> extends LivekitReasonedError<Reason> {
     readonly name = "DataTrackPacketizerError";
     reason: Reason;
     reasonName: string;
@@ -23,7 +23,7 @@ export declare enum DataTrackPacketizerReason {
 }
 /** A packetizer takes a {@link DataTrackFrame} as input and generates a series
  * of {@link DataTrackPacket}s for transmission to other clients over webrtc. */
-export declare class DataTrackPacketizer {
+export default class DataTrackPacketizer {
     private handle;
     private mtuSizeBytes;
     private sequence;
@@ -37,7 +37,7 @@ export declare class DataTrackPacketizer {
      * 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>>;
+    packetize(frame: DataTrackFrame, options?: PacketizeOptions): Throws<Generator<DataTrackPacket>, DataTrackPacketizerError>;
 }
 export {};
 //# sourceMappingURL=packetizer.d.ts.map

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

@@ -0,0 +1,23 @@
+import type { DataTrackInfo } from './types';
+export declare const TrackSymbol: symbol;
+export interface ITrack {
+    readonly trackSymbol: typeof TrackSymbol;
+}
+/** An interface representing a track (of any type) which is local and sending data to the SFU. */
+export interface ILocalTrack extends ITrack {
+    readonly isLocal: true;
+    isPublished(): boolean;
+}
+export declare const RemoteTrackSymbol: symbol;
+/** An interface representing a track (of any type) which is remote and receiving data from the SFU. */
+export interface IRemoteTrack extends ITrack {
+    readonly isLocal: false;
+}
+export declare const DataTrackSymbol: symbol;
+/** An interface representing a data track, either local or remote. */
+export interface IDataTrack extends ITrack {
+    readonly typeSymbol: typeof DataTrackSymbol;
+    readonly info: DataTrackInfo;
+}
+export declare function isDataTrack(subject: unknown): subject is IDataTrack;
+//# sourceMappingURL=track-interfaces.d.ts.map

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

@@ -0,0 +1,10 @@
+import type { DataTrackHandle } from './handle';
+export type DataTrackSid = string;
+/** Information about a published data track. */
+export type DataTrackInfo = {
+    sid: DataTrackSid;
+    pubHandle: DataTrackHandle;
+    name: String;
+    usesE2ee: boolean;
+};
+//# sourceMappingURL=types.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/participant/RemoteParticipant.d.ts

@@ -17,7 +17,7 @@ export default class RemoteParticipant extends Participant {
     /** @internal */
     static fromParticipantInfo(signalClient: SignalClient, pi: ParticipantInfo, loggerOptions: LoggerOptions): RemoteParticipant;
     protected get logContext(): {
-        rpID: string;
+        remoteParticipantID: string;
         remoteParticipant: string;
     };
     /** @internal */

package/dist/ts4.2/room/token-source/TokenSource.d.ts

@@ -11,7 +11,7 @@ declare abstract class TokenSourceCached extends TokenSourceConfigurable {
     private isSameAsCachedFetchOptions;
     private shouldReturnCachedValueFromFetch;
     getCachedResponseJwtPayload(): import("./types").TokenPayload | null;
-    fetch(options: TokenSourceFetchOptions): Promise<TokenSourceResponseObject>;
+    fetch(options: TokenSourceFetchOptions, force?: boolean): Promise<TokenSourceResponseObject>;
     protected abstract update(options: TokenSourceFetchOptions): Promise<TokenSourceResponse>;
 }
 type LiteralOrFn = TokenSourceResponseObject | (() => TokenSourceResponseObject | Promise<TokenSourceResponseObject>);

package/dist/ts4.2/room/token-source/types.d.ts

@@ -62,6 +62,7 @@ export type TokenSourceFetchOptions = {
  */
 export declare abstract class TokenSourceConfigurable {
     abstract fetch(options: TokenSourceFetchOptions): Promise<TokenSourceResponseObject>;
+    abstract fetch(options: TokenSourceFetchOptions, force?: boolean): Promise<TokenSourceResponseObject>;
 }
 /** A TokenSource is a mechanism for fetching credentials required to connect to a LiveKit Room. */
 export type TokenSourceBase = TokenSourceFixed | TokenSourceConfigurable;