livekit-client 2.22.3 → 2.23.0

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

@@ -1,124 +1,124 @@
-import type { Throws } from '@livekit/throws-transformer/throws';
-import type TypedEmitter from 'typed-emitter';
-import type { BaseE2EEManager } from '../../../e2ee/E2eeManager';
-import type Participant from '../../participant/Participant';
-import type RemoteParticipant from '../../participant/RemoteParticipant';
-import { DataTrackDepacketizerDropError } from '../depacketizer';
-import type { DataTrackFrame } from '../frame';
-import { DataTrackHandle } from '../handle';
-import type { DataTrackInfo, DataTrackSid, RemoteDataTrackPipelineOptions } 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. */
-    trackPublished: (event: EventTrackAvailable) => void;
-    /** A track has been unpublished by a remote participant and can no longer be subscribed to. */
-    trackUnpublished: (event: EventTrackUnavailable) => void;
-};
-type IncomingDataTrackManagerOptions = {
-    /** Provider to use for decrypting incoming frame payloads.
-     * If none, remote tracks using end-to-end encryption will not be available
-     * for subscription.
-     */
-    e2eeManager?: BaseE2EEManager;
-};
-declare const IncomingDataTrackManager_base: new () => TypedEmitter<DataTrackIncomingManagerCallbacks>;
-export default class IncomingDataTrackManager extends IncomingDataTrackManager_base {
-    private e2eeManager;
-    /** 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);
-    /** @internal */
-    updateE2eeManager(e2eeManager: BaseE2EEManager | null): void;
-    /** @internal */
-    setPipelineOptions(sid: DataTrackSid, options: RemoteDataTrackPipelineOptions): void;
-    /** Allocates a ReadableStream which emits when a new {@link DataTrackFrame} is received from the
-     * SFU. The SFU subscription is initiated lazily when the stream is created.
-     *
-     * @returns A tuple of the ReadableStream and a Promise that resolves once the SFU subscription
-     * is fully established / the stream is ready to receive frames.
-     *
-     * @internal
-     **/
-    openSubscriptionStream(sid: DataTrackSid, signal?: AbortSignal, bufferSize?: number): [
-        ReadableStream<DataTrackFrame>,
-        Promise<Throws<void, DataTrackSubscribeError>>
-    ];
-    /** Client requested to subscribe to a data track.
-     *
-     * This is sent when the user calls {@link RemoteDataTrack.subscribe}.
-     *
-     * 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): Promise<Throws<void, DataTrackSubscribeError>>;
-    /**
-     * 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;
-    /** Detach abort-signal listeners and close all downstream stream controllers for an active
-     * subscription. Used when the subscription is being torn down by the manager (unsubscribe,
-     * unpublish, or shutdown). */
-    private closeStreamControllers;
-    /** 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>;
-    /**
-     * Detects and handles SID reassignment, which occurs when the publisher
-     * republishes its tracks after a full reconnect.
-     *
-     * Returns `true` if an SID reassignment occurred, `false` otherwise.
-     */
-    private handleSidReassigned;
-    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): Promise<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;
-    /** Resets the manager, ending any subscriptions, and getting it ready for the next room
-     * connection.  */
-    reset(): void;
-}
-export {};
-//# sourceMappingURL=IncomingDataTrackManager.d.ts.map
+import type { Throws } from '@livekit/throws-transformer/throws';
+import type TypedEmitter from 'typed-emitter';
+import type { BaseE2EEManager } from '../../../e2ee/E2eeManager';
+import type Participant from '../../participant/Participant';
+import type RemoteParticipant from '../../participant/RemoteParticipant';
+import { DataTrackDepacketizerDropError } from '../depacketizer';
+import type { DataTrackFrame } from '../frame';
+import { DataTrackHandle } from '../handle';
+import type { DataTrackInfo, DataTrackSid, RemoteDataTrackPipelineOptions } 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. */
+    trackPublished: (event: EventTrackAvailable) => void;
+    /** A track has been unpublished by a remote participant and can no longer be subscribed to. */
+    trackUnpublished: (event: EventTrackUnavailable) => void;
+};
+type IncomingDataTrackManagerOptions = {
+    /** Provider to use for decrypting incoming frame payloads.
+     * If none, remote tracks using end-to-end encryption will not be available
+     * for subscription.
+     */
+    e2eeManager?: BaseE2EEManager;
+};
+declare const IncomingDataTrackManager_base: new () => TypedEmitter<DataTrackIncomingManagerCallbacks>;
+export default class IncomingDataTrackManager extends IncomingDataTrackManager_base {
+    private e2eeManager;
+    /** 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);
+    /** @internal */
+    updateE2eeManager(e2eeManager: BaseE2EEManager | null): void;
+    /** @internal */
+    setPipelineOptions(sid: DataTrackSid, options: RemoteDataTrackPipelineOptions): void;
+    /** Allocates a ReadableStream which emits when a new {@link DataTrackFrame} is received from the
+     * SFU. The SFU subscription is initiated lazily when the stream is created.
+     *
+     * @returns A tuple of the ReadableStream and a Promise that resolves once the SFU subscription
+     * is fully established / the stream is ready to receive frames.
+     *
+     * @internal
+     **/
+    openSubscriptionStream(sid: DataTrackSid, signal?: AbortSignal, bufferSize?: number): [
+        ReadableStream<DataTrackFrame>,
+        Promise<Throws<void, DataTrackSubscribeError>>
+    ];
+    /** Client requested to subscribe to a data track.
+     *
+     * This is sent when the user calls {@link RemoteDataTrack.subscribe}.
+     *
+     * 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): Promise<Throws<void, DataTrackSubscribeError>>;
+    /**
+     * 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;
+    /** Detach abort-signal listeners and close all downstream stream controllers for an active
+     * subscription. Used when the subscription is being torn down by the manager (unsubscribe,
+     * unpublish, or shutdown). */
+    private closeStreamControllers;
+    /** 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>;
+    /**
+     * Detects and handles SID reassignment, which occurs when the publisher
+     * republishes its tracks after a full reconnect.
+     *
+     * Returns `true` if an SID reassignment occurred, `false` otherwise.
+     */
+    private handleSidReassigned;
+    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): Promise<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;
+    /** Resets the manager, ending any subscriptions, and getting it ready for the next room
+     * connection.  */
+    reset(): void;
+}
+export {};
+//# sourceMappingURL=IncomingDataTrackManager.d.ts.map

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

@@ -1,24 +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
+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

@@ -1,41 +1,41 @@
-import type { Throws } from '@livekit/throws-transformer/throws';
-import type { BaseE2EEManager } from '../../../e2ee/E2eeManager';
-import { DataTrackDepacketizerDropError } from '../depacketizer';
-import type { DataTrackFrameInternal } from '../frame';
-import { DataTrackPacket } from '../packet';
-import type { DataTrackInfo, RemoteDataTrackPipelineOptions } from '../types';
-/**
- * Options for creating a {@link IncomingDataTrackPipeline}.
- */
-type Options = {
-    info: DataTrackInfo;
-    publisherIdentity: string;
-    e2eeManager: BaseE2EEManager | null;
-    pipelineOptions?: RemoteDataTrackPipelineOptions;
-};
-/**
- * Pipeline for an individual data track subscription.
- */
-export default class IncomingDataTrackPipeline {
-    private publisherIdentity;
-    private e2eeManager;
-    private depacketizer;
-    private options;
-    /**
-     * Creates a new pipeline with the given options.
-     */
-    constructor(options: Options);
-    updateE2eeManager(e2eeManager: BaseE2EEManager | null): void;
-    setOptions(options: RemoteDataTrackPipelineOptions): void;
-    processPacket(packet: DataTrackPacket): Promise<Throws<DataTrackFrameInternal | 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
+import type { Throws } from '@livekit/throws-transformer/throws';
+import type { BaseE2EEManager } from '../../../e2ee/E2eeManager';
+import { DataTrackDepacketizerDropError } from '../depacketizer';
+import type { DataTrackFrameInternal } from '../frame';
+import { DataTrackPacket } from '../packet';
+import type { DataTrackInfo, RemoteDataTrackPipelineOptions } from '../types';
+/**
+ * Options for creating a {@link IncomingDataTrackPipeline}.
+ */
+type Options = {
+    info: DataTrackInfo;
+    publisherIdentity: string;
+    e2eeManager: BaseE2EEManager | null;
+    pipelineOptions?: RemoteDataTrackPipelineOptions;
+};
+/**
+ * Pipeline for an individual data track subscription.
+ */
+export default class IncomingDataTrackPipeline {
+    private publisherIdentity;
+    private e2eeManager;
+    private depacketizer;
+    private options;
+    /**
+     * Creates a new pipeline with the given options.
+     */
+    constructor(options: Options);
+    updateE2eeManager(e2eeManager: BaseE2EEManager | null): void;
+    setOptions(options: RemoteDataTrackPipelineOptions): void;
+    processPacket(packet: DataTrackPacket): Promise<Throws<DataTrackFrameInternal | 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

@@ -1,20 +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
+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