livekit-client 2.17.3 → 2.18.1

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

@@ -0,0 +1,110 @@
+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 } 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;
+    /** 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;
+    /** 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): 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;
+    /** 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,38 @@
+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 } from '../types';
+/**
+ * Options for creating a {@link IncomingDataTrackPipeline}.
+ */
+type Options = {
+    info: DataTrackInfo;
+    publisherIdentity: string;
+    e2eeManager: BaseE2EEManager | null;
+};
+/**
+ * Pipeline for an individual data track subscription.
+ */
+export default class IncomingDataTrackPipeline {
+    private publisherIdentity;
+    private e2eeManager;
+    private depacketizer;
+    /**
+     * Creates a new pipeline with the given options.
+     */
+    constructor(options: Options);
+    updateE2eeManager(e2eeManager: BaseE2EEManager | null): 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

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

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

@@ -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.
@@ -15,19 +15,29 @@ export declare enum DataTrackPublishErrorReason {
     LimitReached = 3,
     /** Cannot publish data track when the room is disconnected. */
     Disconnected = 4,
-    Cancelled = 5
+    Cancelled = 5,
+    /** The name requested is not able to be used when creating the data track. */
+    InvalidName = 6,
+    /** There was an error publishing, but it was not something that could be sorted into a known
+     * category. */
+    Unknown = 7
 }
-export declare class DataTrackPublishError<Reason extends DataTrackPublishErrorReason> extends LivekitReasonedError<Reason> {
+export declare class DataTrackPublishError<Reason extends DataTrackPublishErrorReason = DataTrackPublishErrorReason> extends LivekitReasonedError<Reason> {
     readonly name = "DataTrackPublishError";
     reason: Reason;
     reasonName: string;
+    /** Underling message from the SFU, if one was provided */
+    rawMessage?: string;
     constructor(message: string, reason: Reason, options?: {
+        rawMessage?: string;
         cause?: unknown;
     });
-    static notAllowed(): DataTrackPublishError<DataTrackPublishErrorReason.NotAllowed>;
-    static duplicateName(): DataTrackPublishError<DataTrackPublishErrorReason.DuplicateName>;
+    static notAllowed(rawMessage?: string): DataTrackPublishError<DataTrackPublishErrorReason.NotAllowed>;
+    static duplicateName(rawMessage?: string): DataTrackPublishError<DataTrackPublishErrorReason.DuplicateName>;
+    static invalidName(rawMessage?: string): DataTrackPublishError<DataTrackPublishErrorReason.InvalidName>;
     static timeout(): DataTrackPublishError<DataTrackPublishErrorReason.Timeout>;
-    static limitReached(): DataTrackPublishError<DataTrackPublishErrorReason.LimitReached>;
+    static limitReached(rawMessage?: string): DataTrackPublishError<DataTrackPublishErrorReason.LimitReached>;
+    static unknown(reason: number, message: string): DataTrackPublishError<DataTrackPublishErrorReason.Unknown>;
     static disconnected(): DataTrackPublishError<DataTrackPublishErrorReason.Disconnected>;
     static cancelled(): DataTrackPublishError<DataTrackPublishErrorReason.Cancelled>;
 }
@@ -37,7 +47,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;
@@ -45,20 +55,20 @@ export declare class DataTrackPushFrameError<Reason extends DataTrackPushFrameEr
         cause?: unknown;
     });
     static trackUnpublished(): DataTrackPushFrameError<DataTrackPushFrameErrorReason.TrackUnpublished>;
-    static dropped(cause: unknown): DataTrackPushFrameError<DataTrackPushFrameErrorReason.Dropped>;
+    static dropped(cause?: unknown): DataTrackPushFrameError<DataTrackPushFrameErrorReason.Dropped>;
 }
 export declare enum DataTrackOutgoingPipelineErrorReason {
     Packetizer = 0,
     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,22 +1,23 @@
-import type { Throws } from '../../../utils/throws';
-import type { EncryptionProvider } from '../e2ee';
-import type { DataTrackFrame } from '../frame';
+import type { Throws } from '@livekit/throws-transformer/throws';
+import type { BaseE2EEManager } from '../../../e2ee/E2eeManager';
+import type { DataTrackFrameInternal } 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;
-    encryptionProvider: EncryptionProvider | null;
+    e2eeManager: BaseE2EEManager | null;
 };
 /** Processes outgoing frames into final packets for distribution to the SFU. */
 export default class DataTrackOutgoingPipeline {
-    private encryptionProvider;
+    private e2eeManager;
     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>>;
+    updateE2eeManager(e2eeManager: BaseE2EEManager | null): void;
+    processFrame(frame: DataTrackFrameInternal): Throws<AsyncGenerator<DataTrackPacket>, DataTrackOutgoingPipelineError>;
+    encryptIfNeeded(frame: DataTrackFrameInternal): Promise<Throws<DataTrackFrameInternal, DataTrackOutgoingPipelineError<DataTrackOutgoingPipelineErrorReason.Encryption>>>;
 }
 export {};
 //# sourceMappingURL=pipeline.d.ts.map

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

@@ -1,5 +1,6 @@
+import type LocalDataTrack from '../LocalDataTrack';
 import type { DataTrackHandle } from '../handle';
-import type { DataTrackInfo } from '../track';
+import type { DataTrackInfo, DataTrackSid } from '../types';
 import type { DataTrackPublishError, DataTrackPublishErrorReason } from './errors';
 /** Options for publishing a data track. */
 export type DataTrackOptions = {
@@ -11,21 +12,29 @@ export type SfuPublishResponseResult = {
     data: DataTrackInfo;
 } | {
     type: 'error';
-    error: DataTrackPublishError<DataTrackPublishErrorReason.NotAllowed> | DataTrackPublishError<DataTrackPublishErrorReason.DuplicateName> | DataTrackPublishError<DataTrackPublishErrorReason.LimitReached>;
+    error: DataTrackPublishError<DataTrackPublishErrorReason.NotAllowed> | DataTrackPublishError<DataTrackPublishErrorReason.DuplicateName> | DataTrackPublishError<DataTrackPublishErrorReason.InvalidName> | 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 = {
+/** A serialized packet is ready to be sent over the transport. */
+export type EventPacketAvailable = {
     bytes: Uint8Array;
-    signal?: AbortSignal;
+};
+/** A track has been created by a local participant and is available to be
+ * subscribed to. */
+export type EventTrackPublished = {
+    track: LocalDataTrack;
+};
+/** A track has been unpublished by a remote participant and can no longer be subscribed to. */
+export type EventTrackUnpublished = {
+    sid: DataTrackSid;
 };
 //# 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,6 +1,6 @@
-import type { Throws } from '../../utils/throws';
+import type { Throws } from '@livekit/throws-transformer/throws';
 import { LivekitReasonedError } from '../errors';
-import type { DataTrackFrame } from './frame';
+import type { DataTrackFrameInternal } from './frame';
 import { DataTrackHandle } from './handle';
 import { DataTrackPacket, FrameMarker } from './packet';
 import { DataTrackTimestamp } from './utils';
@@ -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;
@@ -21,7 +21,7 @@ export declare class DataTrackPacketizerError<Reason extends DataTrackPacketizer
 export declare enum DataTrackPacketizerReason {
     MtuTooShort = 0
 }
-/** A packetizer takes a {@link DataTrackFrame} as input and generates a series
+/** A packetizer takes a {@link DataTrackFrameInternal} as input and generates a series
  * of {@link DataTrackPacket}s for transmission to other clients over webrtc. */
 export default class DataTrackPacketizer {
     private handle;
@@ -32,12 +32,12 @@ export default class DataTrackPacketizer {
     constructor(trackHandle: DataTrackHandle, mtuSizeBytes: number);
     /** @internal */
     static computeFrameMarker(index: number, packetCount: number): FrameMarker;
-    /** Generates a series of packets for the specified {@link DataTrackPacketizerFrame}.
+    /** Generates a series of packets for the specified {@link DataTrackFrameInternal}.
      *
      * 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: DataTrackFrameInternal, options?: PacketizeOptions): Throws<Generator<DataTrackPacket>, DataTrackPacketizerError>;
 }
 export {};
 //# sourceMappingURL=packetizer.d.ts.map