livekit-client 2.17.3 → 2.18.0

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

@@ -1,13 +1,13 @@
+import type { Throws } from '@livekit/throws-transformer/throws';
 import type TypedEmitter from 'typed-emitter';
-import type { Throws } from '../../../utils/throws';
 import { Future } from '../../utils';
+import LocalDataTrack from '../LocalDataTrack';
 import type { EncryptionProvider } from '../e2ee';
 import { DataTrackHandle } from '../handle';
-import type { DataTrackInfo } from '../track';
-import { LocalDataTrack } from '../track';
+import type { DataTrackInfo } from '../types';
 import { DataTrackPublishError, DataTrackPublishErrorReason, DataTrackPushFrameError, DataTrackPushFrameErrorReason } from './errors';
 import DataTrackOutgoingPipeline from './pipeline';
-import type { DataTrackOptions, OutputEventPacketsAvailable, OutputEventSfuPublishRequest, OutputEventSfuUnpublishRequest, SfuPublishResponseResult } from './types';
+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>>;
@@ -26,13 +26,13 @@ export declare const Descriptor: {
 };
 export type DataTrackOutgoingManagerCallbacks = {
     /** Request sent to the SFU to publish a track. */
-    sfuPublishRequest: (event: OutputEventSfuPublishRequest) => void;
+    sfuPublishRequest: (event: EventSfuPublishRequest) => void;
     /** Request sent to the SFU to unpublish a track. */
-    sfuUnpublishRequest: (event: OutputEventSfuUnpublishRequest) => void;
+    sfuUnpublishRequest: (event: EventSfuUnpublishRequest) => void;
     /** Serialized packets are ready to be sent over the transport. */
-    packetsAvailable: (event: OutputEventPacketsAvailable) => void;
+    packetsAvailable: (event: EventPacketsAvailable) => void;
 };
-type DataTrackLocalManagerOptions = {
+type OutgoingDataTrackManagerOptions = {
     /**
      * Provider to use for encrypting outgoing frame payloads.
      *
@@ -45,7 +45,7 @@ export default class OutgoingDataTrackManager extends OutgoingDataTrackManager_b
     private encryptionProvider;
     private handleAllocator;
     private descriptors;
-    constructor(options?: DataTrackLocalManagerOptions);
+    constructor(options?: OutgoingDataTrackManagerOptions);
     static withDescriptors(descriptors: Map<DataTrackHandle, Descriptor>): OutgoingDataTrackManager;
     /**
      * Used by attached {@link LocalDataTrack} instances to query their associated descriptor info.

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

@@ -1,5 +1,5 @@
 import { LivekitReasonedError } from '../../errors';
-import { DataTrackPacketizerError, DataTrackPacketizerReason } from '../packetizer';
+import { DataTrackPacketizerError } from '../packetizer';
 export declare enum DataTrackPublishErrorReason {
     /**
      * Local participant does not have permission to publish data tracks.
@@ -37,7 +37,7 @@ export declare enum DataTrackPushFrameErrorReason {
     /** Frame was dropped. */
     Dropped = 1
 }
-export declare class DataTrackPushFrameError<Reason extends DataTrackPushFrameErrorReason> extends LivekitReasonedError<Reason> {
+export declare class DataTrackPushFrameError<Reason extends DataTrackPushFrameErrorReason = DataTrackPushFrameErrorReason> extends LivekitReasonedError<Reason> {
     readonly name = "DataTrackPushFrameError";
     reason: Reason;
     reasonName: string;
@@ -51,14 +51,14 @@ export declare enum DataTrackOutgoingPipelineErrorReason {
     Packetizer = 0,
     Encryption = 1
 }
-export declare class DataTrackOutgoingPipelineError<Reason extends DataTrackOutgoingPipelineErrorReason> extends LivekitReasonedError<Reason> {
+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<DataTrackPacketizerReason.MtuTooShort>): DataTrackOutgoingPipelineError<DataTrackOutgoingPipelineErrorReason.Packetizer>;
+    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

@@ -1,8 +1,8 @@
-import type { Throws } from '../../../utils/throws';
+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 '../track';
+import type { DataTrackInfo } from '../types';
 import { DataTrackOutgoingPipelineError, DataTrackOutgoingPipelineErrorReason } from './errors';
 type Options = {
     info: DataTrackInfo;
@@ -15,7 +15,7 @@ export default class DataTrackOutgoingPipeline {
     /** 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>>;
+    processFrame(frame: DataTrackFrame): Throws<Generator<DataTrackPacket>, DataTrackOutgoingPipelineError>;
     encryptIfNeeded(frame: DataTrackFrame): Throws<DataTrackFrame, DataTrackOutgoingPipelineError<DataTrackOutgoingPipelineErrorReason.Encryption>>;
 }
 export {};

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

@@ -1,5 +1,5 @@
 import type { DataTrackHandle } from '../handle';
-import type { DataTrackInfo } from '../track';
+import type { DataTrackInfo } from '../types';
 import type { DataTrackPublishError, DataTrackPublishErrorReason } from './errors';
 /** Options for publishing a data track. */
 export type DataTrackOptions = {
@@ -14,18 +14,17 @@ export type SfuPublishResponseResult = {
     error: DataTrackPublishError<DataTrackPublishErrorReason.NotAllowed> | DataTrackPublishError<DataTrackPublishErrorReason.DuplicateName> | DataTrackPublishError<DataTrackPublishErrorReason.LimitReached>;
 };
 /** Request sent to the SFU to publish a track. */
-export type OutputEventSfuPublishRequest = {
+export type EventSfuPublishRequest = {
     handle: DataTrackHandle;
     name: string;
     usesE2ee: boolean;
 };
 /** Request sent to the SFU to unpublish a track. */
-export type OutputEventSfuUnpublishRequest = {
+export type EventSfuUnpublishRequest = {
     handle: DataTrackHandle;
 };
 /** Serialized packets are ready to be sent over the transport. */
-export type OutputEventPacketsAvailable = {
+export type EventPacketsAvailable = {
     bytes: Uint8Array;
-    signal?: AbortSignal;
 };
 //# 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;
@@ -37,7 +37,7 @@ export default 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/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;

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

@@ -1,7 +1,7 @@
 import { ChatMessage as ChatMessageModel, ClientInfo, DisconnectReason, Transcription as TranscriptionModel } from '@livekit/protocol';
+import type { Throws } from '@livekit/throws-transformer/throws';
 import TypedPromise from '../utils/TypedPromise';
 import type { BrowserDetails } from '../utils/browserParser';
-import type { Throws } from '../utils/throws';
 import type { ConnectionError } from './errors';
 import type LocalParticipant from './participant/LocalParticipant';
 import type Participant from './participant/Participant';

package/dist/ts4.2/utils/abort-signal-polyfill.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Implementation of AbortSignal.any
+ * Creates a signal that will be aborted when any of the given signals is aborted.
+ * @link https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal/any
+ */
+export declare function abortSignalAny(signals: Array<AbortSignal>): AbortSignal;
+/**
+ * Implementation of AbortSignal.timeout
+ * Creates a signal that will be aborted after the specified timeout.
+ * @link https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal/timeout
+ */
+export declare function abortSignalTimeout(ms: number): AbortSignal;
+//# sourceMappingURL=abort-signal-polyfill.d.ts.map

package/dist/ts4.2/utils/subscribeToEvents.d.ts

@@ -6,6 +6,9 @@ export declare function subscribeToEvents<Callbacks extends EventMap, EventNames
     /** Listen for the next occurrance of an event to be emitted, or return the last event that was
      * buffered (but hasn't been processed yet). */
     waitFor<EventPayload extends Parameters<Callbacks[EventName]>[0], EventName extends EventNames = EventNames>(eventName: EventName): Promise<EventPayload>;
+    /** Are there events of the given name which are waiting to be processed? Use this to assert
+     * that no unexpected events have been emitted. */
+    areThereBufferedEvents<EventPayload extends Parameters<Callbacks[EventName]>[0], EventName extends EventNames = EventNames>(eventName: EventName): boolean;
     /** Cleanup any lingering subscriptions. */
     unsubscribe: () => void;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "livekit-client",
-  "version": "2.17.3",
+  "version": "2.18.0",
   "description": "JavaScript/TypeScript client SDK for LiveKit",
   "main": "./dist/livekit-client.umd.js",
   "unpkg": "./dist/livekit-client.umd.js",
@@ -56,6 +56,7 @@
     "@changesets/cli": "2.29.8",
     "@eslint/js": "9.39.2",
     "@livekit/changesets-changelog-github": "^0.0.4",
+    "@livekit/throws-transformer": "^0.1.3",
     "@rollup/plugin-babel": "6.1.0",
     "@rollup/plugin-commonjs": "28.0.9",
     "@rollup/plugin-json": "6.1.0",
@@ -86,6 +87,7 @@
     "rollup-plugin-delete": "^2.1.0",
     "rollup-plugin-typescript2": "0.36.0",
     "size-limit": "^11.2.0",
+    "tsx": "^4.21.0",
     "typedoc": "0.28.16",
     "typedoc-plugin-no-inherit": "1.6.1",
     "typescript": "5.8.3",
@@ -107,7 +109,7 @@
     "deploy": "gh-pages -d examples/demo/dist",
     "format": "prettier --write src examples/**/*.ts",
     "format:check": "prettier --check src examples/**/*.ts",
-    "throws:check": "pnpm dlx tsx ./throws-transformer/cli.ts 'src/!(*.test).ts' 'src/**/!(*.test).ts'",
+    "throws:check": "pnpm --package=@livekit/throws-transformer dlx throws-check 'src/!(*.test).ts' 'src/**/!(*.test).ts'",
     "ci:publish": "pnpm build:clean && pnpm compat && changeset publish",
     "downlevel-dts": "downlevel-dts ./dist/src ./dist/ts4.2 --to=4.2",
     "compat": "eslint --config ./eslint.config.dist.mjs --no-inline-config  ./dist/livekit-client.esm.mjs",

package/src/index.ts

@@ -12,7 +12,7 @@ import type { ReconnectContext, ReconnectPolicy } from './room/ReconnectPolicy';
 import Room, { ConnectionState, type RoomEventCallbacks } from './room/Room';
 import * as attributes from './room/attribute-typings';
 // FIXME: remove this import in a follow up data track pull request.
-import './room/data-track/depacketizer';
+import './room/data-track/incoming/IncomingDataTrackManager';
 // FIXME: remove this import in a follow up data track pull request.
 import './room/data-track/outgoing/OutgoingDataTrackManager';
 import LocalParticipant from './room/participant/LocalParticipant';

package/src/room/RTCEngine.ts

@@ -134,6 +134,10 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
     return this._isClosed;
   }
 
+  get isNewlyCreated() {
+    return this._isNewlyCreated;
+  }
+
   get pendingReconnect() {
     return !!this.reconnectTimeout;
   }
@@ -156,6 +160,8 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
 
   private _isClosed: boolean = true;
 
+  private _isNewlyCreated: boolean = true;
+
   private pendingTrackResolvers: {
     [key: string]: { resolve: (info: TrackInfo) => void; reject: () => void };
   } = {};
@@ -257,7 +263,7 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
       room: this.latestJoinResponse?.room?.name,
       roomID: this.latestJoinResponse?.room?.sid,
       participant: this.latestJoinResponse?.participant?.identity,
-      pID: this.participantSid,
+      participantID: this.participantSid,
     };
   }
 
@@ -269,6 +275,7 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
     /** setting this to true results in dual peer connection mode being used */
     useV0Path: boolean = false,
   ): Promise<JoinResponse> {
+    this._isNewlyCreated = false;
     this.url = url;
     this.token = token;
     this.signalOpts = opts;