livekit-client 2.18.9 → 2.19.0

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

@@ -68,6 +68,7 @@ declare class Room extends Room_base {
     private connectFuture?;
     private disconnectLock;
     private e2eeManager;
+    private packetTrailerManager;
     private e2eeStateMutex;
     private connectionReconcileInterval?;
     private regionUrlProvider?;
@@ -84,7 +85,8 @@ declare class Room extends Room_base {
     private outgoingDataStreamManager;
     private incomingDataTrackManager;
     private outgoingDataTrackManager;
-    private rpcHandlers;
+    private rpcClientManager;
+    private rpcServerManager;
     get hasE2EESetup(): boolean;
     /**
      * Creates a new Room, the primary construct for a LiveKit session.
@@ -133,6 +135,7 @@ declare class Room extends Room_base {
      */
     setE2EEEnabled(enabled: boolean): Promise<void>;
     private setupE2EE;
+    private setupPacketTrailer;
     private get logContext();
     /**
      * if the current room has a participant with `recorder: true` in its JWT grant
@@ -242,7 +245,6 @@ declare class Room extends Room_base {
     private handleChatMessage;
     private handleMetrics;
     private handleDataStream;
-    private handleIncomingRpcRequest;
     bufferedSegments: Map<string, TranscriptionSegmentModel>;
     private handleAudioPlaybackStarted;
     private handleAudioPlaybackFailed;
@@ -265,6 +267,8 @@ declare class Room extends Room_base {
      */
     private updateSubscriptions;
     private getRemoteParticipantBySid;
+    private getRemoteParticipantClientProtocol;
+    private registerRpcDataStreamHandler;
     private registerConnectionReconcile;
     private clearConnectionReconcile;
     private setAndEmitConnectionState;
@@ -319,7 +323,7 @@ export type RoomEventCallbacks = {
     participantAttributesChanged: (changedAttributes: Record<string, string>, participant: RemoteParticipant | LocalParticipant) => void;
     activeSpeakersChanged: (speakers: Array<Participant>) => void;
     roomMetadataChanged: (metadata: string) => void;
-    dataReceived: (payload: Uint8Array, participant?: RemoteParticipant, kind?: DataPacket_Kind, topic?: string, encryptionType?: Encryption_Type) => void;
+    dataReceived: (payload: NonSharedUint8Array, participant?: RemoteParticipant, kind?: DataPacket_Kind, topic?: string, encryptionType?: Encryption_Type) => void;
     sipDTMFReceived: (dtmf: SipDTMF, participant?: RemoteParticipant) => void;
     transcriptionReceived: (transcription: TranscriptionSegment[], participant?: Participant, publication?: TrackPublication) => void;
     connectionQualityChanged: (quality: ConnectionQuality, participant: Participant) => void;

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

@@ -2,7 +2,7 @@ import type Participant from '../participant/Participant';
 import type { DataTrackFrame } from './frame';
 import type IncomingDataTrackManager from './incoming/IncomingDataTrackManager';
 import type { IDataTrack, IRemoteTrack } from './track-interfaces';
-import type { DataTrackInfo } from './types';
+import type { DataTrackInfo, RemoteDataTrackPipelineOptions } from './types';
 type RemoteDataTrackOptions = {
     publisherIdentity: Participant['identity'];
 };
@@ -41,6 +41,10 @@ export default class RemoteDataTrack implements IRemoteTrack, IDataTrack {
      * the initial subscription is established.
      */
     subscribe(options?: DataTrackSubscribeOptions): ReadableStream<DataTrackFrame>;
+    /** Configure how incoming frames for this track are processed before they are handed out to
+     * subscribers (the "pipeline"). These options apply to all current and future subscriptions
+     * of this track, and may be set at any time. */
+    setPipelineOptions(options: RemoteDataTrackPipelineOptions): void;
 }
 export {};
 //# sourceMappingURL=RemoteDataTrack.d.ts.map

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

@@ -24,14 +24,21 @@ export declare enum DataTrackDepacketizerDropReason {
     Incomplete = 3
 }
 type PushOptions = {
-    /** If true, throws an error instead of logging a warning when a new frame is encountered half way
-     * through processing a pre-existing frame. */
-    errorOnPartialFrames: boolean;
+    /** If true, throws `DataTrackDepacketizerDropError.interrupted` instead of logging a warning
+     * when a new frame arrives while the partials map is at capacity. */
+    throwOnInterruption: boolean;
+    /** Maximum number of partial frames the depacketizer will track concurrently. When a new
+     * frame arrives while the partials map is at capacity, the oldest partial is evicted (or
+     * `DataTrackDepacketizerDropError.interrupted` is thrown when `throwOnInterruption` is set).
+     * Defaults to 1. */
+    maxPartialFrames?: number;
 };
 export default class DataTrackDepacketizer {
     /** Maximum number of packets to buffer per frame before dropping. */
     static MAX_BUFFER_PACKETS: number;
-    private partial;
+    /** Partial frames currently being assembled, keyed by frame number. `Map` preserves insertion
+     * order, so the oldest entry is the first key. */
+    private partials;
     /** Should be repeatedly called with received {@link DataTrackPacket}s - intermediate calls
      * aggregate the packet's state internally, and return null.
      *
@@ -39,6 +46,7 @@ export default class DataTrackDepacketizer {
      * is returned.*/
     push(packet: DataTrackPacket, options?: PushOptions): Throws<DataTrackFrameInternal | null, DataTrackDepacketizerDropError>;
     reset(): void;
+    private peekOldestPartialFrameNumber;
     private frameFromSingle;
     /** Begin assembling a new packet. */
     private beginPartial;

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

@@ -1,17 +1,17 @@
 import { DataTrackExtensions } from './packet/extensions';
 /** A pair of payload bytes and packet extensions which can be fed into a {@link DataTrackPacketizer}. */
 export type DataTrackFrame = {
-    payload: Uint8Array;
+    payload: NonSharedUint8Array;
     userTimestamp?: bigint;
 };
 /** An internal representation o data track frame which contains all SFU metadata. */
 export type DataTrackFrameInternal = {
-    payload: Uint8Array;
+    payload: NonSharedUint8Array;
     extensions: DataTrackExtensions;
 };
 export declare const DataTrackFrameInternal: {
     from(frame: DataTrackFrame): {
-        payload: Uint8Array<ArrayBufferLike>;
+        payload: Uint8Array<ArrayBuffer>;
         extensions: DataTrackExtensions;
     };
     /** Converts from a DataTrackFrameInternal -> DataTrackFrame. Some internal information is

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

@@ -6,7 +6,7 @@ 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 type { DataTrackInfo, DataTrackSid, RemoteDataTrackPipelineOptions } from '../types';
 import { DataTrackSubscribeError } from './errors';
 import type { EventSfuUpdateSubscription, EventTrackAvailable, EventTrackUnavailable } from './types';
 export type DataTrackIncomingManagerCallbacks = {
@@ -40,6 +40,8 @@ export default class IncomingDataTrackManager extends IncomingDataTrackManager_b
     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.
      *

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

@@ -3,7 +3,7 @@ import type { BaseE2EEManager } from '../../../e2ee/E2eeManager';
 import { DataTrackDepacketizerDropError } from '../depacketizer';
 import type { DataTrackFrameInternal } from '../frame';
 import { DataTrackPacket } from '../packet';
-import type { DataTrackInfo } from '../types';
+import type { DataTrackInfo, RemoteDataTrackPipelineOptions } from '../types';
 /**
  * Options for creating a {@link IncomingDataTrackPipeline}.
  */
@@ -11,6 +11,7 @@ type Options = {
     info: DataTrackInfo;
     publisherIdentity: string;
     e2eeManager: BaseE2EEManager | null;
+    pipelineOptions?: RemoteDataTrackPipelineOptions;
 };
 /**
  * Pipeline for an individual data track subscription.
@@ -19,11 +20,13 @@ 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.

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

@@ -12,7 +12,7 @@ export type SfuPublishResponseResult = {
     data: DataTrackInfo;
 } | {
     type: 'error';
-    error: DataTrackPublishError<DataTrackPublishErrorReason.NotAllowed> | DataTrackPublishError<DataTrackPublishErrorReason.DuplicateName> | DataTrackPublishError<DataTrackPublishErrorReason.InvalidName> | DataTrackPublishError<DataTrackPublishErrorReason.LimitReached>;
+    error: DataTrackPublishError<DataTrackPublishErrorReason.NotAllowed> | DataTrackPublishError<DataTrackPublishErrorReason.DuplicateName> | DataTrackPublishError<DataTrackPublishErrorReason.InvalidName> | DataTrackPublishError<DataTrackPublishErrorReason.LimitReached> | DataTrackPublishError<DataTrackPublishErrorReason.Unknown>;
 };
 /** Request sent to the SFU to publish a track. */
 export type EventSfuPublishRequest = {
@@ -28,7 +28,7 @@ export type EventSfuUnpublishRequest = {
 export type EventPacketAvailable = {
     /** The handle associated with the data track which this packet bytes belong to. */
     handle: DataTrackHandle;
-    bytes: Uint8Array;
+    bytes: NonSharedUint8Array;
 };
 /** A track has been created by a local participant and is available to be
  * subscribed to. */

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

@@ -26,15 +26,15 @@ export declare class DataTrackE2eeExtension extends DataTrackExtension {
     static tag: DataTrackExtensionTag;
     static lengthBytes: number;
     keyIndex: number;
-    iv: Uint8Array;
-    constructor(keyIndex: number, iv: Uint8Array);
+    iv: NonSharedUint8Array;
+    constructor(keyIndex: number, iv: NonSharedUint8Array);
     toBinaryLengthBytes(): number;
     toBinaryInto(dataView: DataView): Throws<number, never>;
     toJSON(): {
         tag: number;
         lengthBytes: number;
         keyIndex: number;
-        iv: Uint8Array<ArrayBufferLike>;
+        iv: Uint8Array<ArrayBuffer>;
     };
 }
 export declare class DataTrackExtensions extends Serializable {
@@ -60,7 +60,7 @@ export declare class DataTrackExtensions extends Serializable {
             tag: number;
             lengthBytes: number;
             keyIndex: number;
-            iv: Uint8Array<ArrayBufferLike>;
+            iv: Uint8Array<ArrayBuffer>;
         } | null;
     };
 }

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

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

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

@@ -7,6 +7,6 @@ export default abstract class Serializable {
     /** Given a DataView, serialize the instance inside and return the number of bytes written. */
     abstract toBinaryInto(dataView: DataView): Throws<number, DataTrackSerializeError>;
     /** Encodes the instance as binary and returns the data as a Uint8Array. */
-    toBinary(): Throws<Uint8Array, DataTrackSerializeError>;
+    toBinary(): Throws<NonSharedUint8Array, DataTrackSerializeError>;
 }
 //# sourceMappingURL=serializable.d.ts.map

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

@@ -8,6 +8,13 @@ export type DataTrackInfo = {
     name: string;
     usesE2ee: boolean;
 };
+export type RemoteDataTrackPipelineOptions = {
+    /** Set the maximum number of in-flight partial frames the depacketizer will track
+     * concurrently for this track. Higher values give more out-of-order tolerance for
+     * high-frequency senders. Defaults to 1.
+     */
+    maxPartialFrames?: number;
+};
 export declare const DataTrackInfo: {
     from(protocolInfo: ProtocolDataTrackInfo): DataTrackInfo;
     toProtobuf(info: DataTrackInfo): ProtocolDataTrackInfo;

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

@@ -198,7 +198,7 @@ export declare enum RoomEvent {
      * Data packets provides the ability to use LiveKit to send/receive arbitrary payloads.
      * All participants in the room will receive the messages sent to the room.
      *
-     * args: (payload: Uint8Array, participant: [[Participant]], kind: [[DataPacket_Kind]], topic?: string)
+     * args: (payload: NonSharedUint8Array, participant: [[Participant]], kind: [[DataPacket_Kind]], topic?: string)
      */
     DataReceived = "dataReceived",
     /**
@@ -427,7 +427,7 @@ export declare enum ParticipantEvent {
      * Data packets provides the ability to use LiveKit to send/receive arbitrary payloads.
      * All participants in the room will receive the messages sent to the room.
      *
-     * args: (payload: Uint8Array, kind: [[DataPacket_Kind]])
+     * args: (payload: NonSharedUint8Array, kind: [[DataPacket_Kind]])
      */
     DataReceived = "dataReceived",
     /**

package/dist/ts4.2/room/participant/LocalParticipant.d.ts

@@ -8,7 +8,7 @@ import LocalDataTrack from '../data-track/LocalDataTrack';
 import type OutgoingDataTrackManager from '../data-track/outgoing/OutgoingDataTrackManager';
 import type { DataTrackOptions } from '../data-track/outgoing/types';
 import type { PerformRpcParams, RpcInvocationData } from '../rpc';
-import { RpcError } from '../rpc';
+import { RpcClientManager, RpcError, RpcServerManager } from '../rpc';
 import LocalTrack from '../track/LocalTrack';
 import LocalTrackPublication from '../track/LocalTrackPublication';
 import { Track } from '../track/Track';
@@ -40,15 +40,14 @@ export default class LocalParticipant extends Participant {
     private signalConnectedFuture?;
     private activeAgentFuture?;
     private firstActiveAgent?;
-    private rpcHandlers;
     private roomOutgoingDataStreamManager;
     private roomOutgoingDataTrackManager;
+    private rpcClientManager;
+    private rpcServerManager;
     private pendingSignalRequests;
     private enabledPublishVideoCodecs;
-    private pendingAcks;
-    private pendingResponses;
     /** @internal */
-    constructor(sid: string, identity: string, engine: RTCEngine, options: InternalRoomOptions, roomRpcHandlers: Map<string, (data: RpcInvocationData) => Promise<string>>, roomOutgoingDataStreamManager: OutgoingDataStreamManager, roomOutgoingDataTrackManager: OutgoingDataTrackManager);
+    constructor(sid: string, identity: string, engine: RTCEngine, options: InternalRoomOptions, roomOutgoingDataStreamManager: OutgoingDataStreamManager, roomOutgoingDataTrackManager: OutgoingDataTrackManager, rpcClientManager: RpcClientManager, rpcServerManager: RpcServerManager);
     get lastCameraError(): Error | undefined;
     get lastMicrophoneError(): Error | undefined;
     get isE2EEEnabled(): boolean;
@@ -63,7 +62,6 @@ export default class LocalParticipant extends Participant {
     private handleClosing;
     private handleSignalConnected;
     private handleSignalRequestResponse;
-    private handleDataPacket;
     /**
      * Sets and updates the metadata of the local participant.
      * Note: this requires `canUpdateOwnMetadata` permission.
@@ -148,6 +146,8 @@ export default class LocalParticipant extends Participant {
     private waitUntilEngineConnected;
     private hasPermissionsToPublish;
     private publish;
+    private canPublishPacketTrailer;
+    private normalizeRequestedPacketTrailerOptions;
     get isLocal(): boolean;
     /** @internal
      * publish additional codec to existing track
@@ -163,7 +163,7 @@ export default class LocalParticipant extends Participant {
      * @param data Uint8Array of the payload. To send string data, use TextEncoder.encode
      * @param options optionally specify a `reliable`, `topic` and `destination`
      */
-    publishData(data: Uint8Array, options?: DataPublishOptions): Promise<void>;
+    publishData(data: NonSharedUint8Array, options?: DataPublishOptions): Promise<void>;
     /**
      * Publish SIP DTMF message to the room.
      *
@@ -220,7 +220,7 @@ export default class LocalParticipant extends Participant {
      * @returns A promise that resolves with the response payload or rejects with an error.
      * @throws Error on failure. Details in `message`.
      */
-    performRpc({ destinationIdentity, method, payload, responseTimeout, }: PerformRpcParams): TypedPromise<string, RpcError>;
+    performRpc(params: PerformRpcParams): TypedPromise<string, RpcError>;
     /**
      * @deprecated use `room.registerRpcMethod` instead
      */
@@ -247,12 +247,6 @@ export default class LocalParticipant extends Participant {
      *  participant/track. Any omitted participants will not receive any permissions.
      */
     setTrackSubscriptionPermissions(allParticipantsAllowed: boolean, participantTrackPermissions?: ParticipantTrackPermission[]): void;
-    private handleIncomingRpcAck;
-    private handleIncomingRpcResponse;
-    /** @internal */
-    private publishRpcRequest;
-    /** @internal */
-    handleParticipantDisconnected(participantIdentity: string): void;
     /** @internal */
     setEnabledPublishCodecs(codecs: Codec[]): void;
     /** @internal */

package/dist/ts4.2/room/participant/Participant.d.ts

@@ -124,7 +124,7 @@ export type ParticipantEventCallbacks = {
     localSenderCreated: (sender: RTCRtpSender, track: Track) => void;
     participantMetadataChanged: (prevMetadata: string | undefined, participant?: any) => void;
     participantNameChanged: (name: string) => void;
-    dataReceived: (payload: Uint8Array, kind: DataPacket_Kind, encryptionType?: Encryption_Type) => void;
+    dataReceived: (payload: NonSharedUint8Array, kind: DataPacket_Kind, encryptionType?: Encryption_Type) => void;
     sipDTMFReceived: (dtmf: SipDTMF) => void;
     transcriptionReceived: (transcription: TranscriptionSegment[], publication?: TrackPublication) => void;
     isSpeakingChanged: (speaking: boolean) => void;

package/dist/ts4.2/room/participant/RemoteParticipant.d.ts

@@ -22,6 +22,10 @@ export default class RemoteParticipant extends Participant {
      * const track = await remoteParticipant.dataTracks.getDeferred("data track name"); */
     dataTracks: DeferrableMap<RemoteDataTrack['info']['name'], RemoteDataTrack>;
     signalClient: SignalClient;
+    /** A version number indicating the set of features that the report participant's client supports.
+     * @internal
+     **/
+    clientProtocol: number;
     private volumeMap;
     private audioOutput?;
     /** @internal */
@@ -31,7 +35,7 @@ export default class RemoteParticipant extends Participant {
         remoteParticipant: string;
     };
     /** @internal */
-    constructor(signalClient: SignalClient, sid: string, identity?: string, name?: string, metadata?: string, attributes?: Record<string, string>, loggerOptions?: LoggerOptions, kind?: ParticipantKind, remoteDataTracks?: Array<RemoteDataTrack>);
+    constructor(signalClient: SignalClient, sid: string, identity?: string, name?: string, metadata?: string, attributes?: Record<string, string>, loggerOptions?: LoggerOptions, kind?: ParticipantKind, remoteDataTracks?: Array<RemoteDataTrack>, clientProtocol?: number);
     protected addTrackPublication(publication: RemoteTrackPublication): void;
     getTrackPublication(source: Track.Source): RemoteTrackPublication | undefined;
     getTrackPublicationByName(name: string): RemoteTrackPublication | undefined;

package/dist/ts4.2/room/rpc/client/RpcClientManager.d.ts

@@ -0,0 +1,43 @@
+import type TypedEmitter from 'typed-emitter';
+import type { StructuredLogger } from '../../../logger';
+import type { TextStreamReader } from '../../data-stream/incoming/StreamReader';
+import type OutgoingDataStreamManager from '../../data-stream/outgoing/OutgoingDataStreamManager';
+import type Participant from '../../participant/Participant';
+import type { PerformRpcParams } from '../utils';
+import { RpcError } from '../utils';
+import type { RpcClientManagerCallbacks } from './events';
+declare const RpcClientManager_base: new () => TypedEmitter<RpcClientManagerCallbacks>;
+/**
+ * Manages the client (caller) side of RPC: sending requests, tracking pending
+ * ack/response state, and handling incoming ack/response packets.
+ * @internal
+ */
+export default class RpcClientManager extends RpcClientManager_base {
+    private log;
+    private outgoingDataStreamManager;
+    private getRemoteParticipantClientProtocol;
+    private getServerVersion;
+    private pendingAcks;
+    private pendingResponses;
+    constructor(log: StructuredLogger, outgoingDataStreamManager: OutgoingDataStreamManager, getRemoteParticipantClientProtocol: (identity: Participant['identity']) => number, getServerVersion: () => string | undefined);
+    performRpc({ destinationIdentity, method, payload, responseTimeout: responseTimeoutMs, }: PerformRpcParams): Promise<[
+        id: string,
+        completionPromise: Promise<string>
+    ]>;
+    private publishRpcRequest;
+    /**
+     * Handle an incoming data stream containing an RPC response payload.
+     * @internal
+     */
+    handleIncomingDataStream(reader: TextStreamReader, senderIdentity: Participant['identity'], attributes: Record<string, string>): Promise<void>;
+    /** @internal */
+    handleIncomingRpcResponseSuccess(requestId: string, payload: string): void;
+    /** @internal */
+    handleIncomingRpcResponseFailure(requestId: string, error: RpcError): void;
+    /** @internal */
+    handleIncomingRpcAck(requestId: string): void;
+    /** @internal */
+    handleParticipantDisconnected(participantIdentity: string): void;
+}
+export {};
+//# sourceMappingURL=RpcClientManager.d.ts.map

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

@@ -0,0 +1,8 @@
+import type { DataPacket } from '@livekit/protocol';
+export type EventSendDataPacket = {
+    packet: DataPacket;
+};
+export type RpcClientManagerCallbacks = {
+    sendDataPacket: (event: EventSendDataPacket) => void;
+};
+//# sourceMappingURL=events.d.ts.map

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

@@ -0,0 +1,7 @@
+export { default as RpcClientManager } from './client/RpcClientManager';
+export type { RpcClientManagerCallbacks } from './client/events';
+export { default as RpcServerManager } from './server/RpcServerManager';
+export type { RpcServerManagerCallbacks } from './server/events';
+export type { PerformRpcParams, RpcInvocationData } from './utils';
+export { RPC_REQUEST_DATA_STREAM_TOPIC, RPC_RESPONSE_DATA_STREAM_TOPIC, RpcRequestAttrs, RpcError, byteLength, truncateBytes } from './utils';
+//# sourceMappingURL=index.d.ts.map

package/dist/ts4.2/room/rpc/server/RpcServerManager.d.ts

@@ -0,0 +1,44 @@
+import { RpcRequest } from '@livekit/protocol';
+import type TypedEmitter from 'typed-emitter';
+import type { StructuredLogger } from '../../../logger';
+import type { TextStreamReader } from '../../data-stream/incoming/StreamReader';
+import type OutgoingDataStreamManager from '../../data-stream/outgoing/OutgoingDataStreamManager';
+import type Participant from '../../participant/Participant';
+import type { RpcInvocationData } from '../utils';
+import type { RpcServerManagerCallbacks } from './events';
+declare const RpcServerManager_base: new () => TypedEmitter<RpcServerManagerCallbacks>;
+/**
+ * Manages the server (handler) side of RPC: processing incoming requests,
+ * managing registered method handlers, and sending responses.
+ * @internal
+ */
+export default class RpcServerManager extends RpcServerManager_base {
+    private log;
+    private outgoingDataStreamManager;
+    private getRemoteParticipantClientProtocol;
+    private rpcHandlers;
+    constructor(log: StructuredLogger, outgoingDataStreamManager: OutgoingDataStreamManager, getRemoteParticipantClientProtocol: (identity: Participant['identity']) => number);
+    registerRpcMethod(method: string, handler: (data: RpcInvocationData) => Promise<string>): void;
+    unregisterRpcMethod(method: string): void;
+    /**
+     * Handle an incoming RPCRequest message containing a payload.
+     * This handles "version 1" of rpc requests.
+     * @internal
+     */
+    handleIncomingRpcRequest(callerIdentity: string, rpcRequest: RpcRequest): Promise<void>;
+    /**
+     * Handle an incoming data stream containing a RPC request payload.
+     * This handles "version 2" of rpc requests.
+     * @internal
+     */
+    handleIncomingDataStream(reader: TextStreamReader, callerIdentity: Participant['identity'], dataStreamAttrs: Record<string, string>): Promise<void>;
+    private publishRpcAck;
+    private publishRpcResponsePacket;
+    /**
+     * Send a successful RPC response payload, choosing the transport based on
+     * the caller's client protocol version.
+     */
+    private publishRpcResponse;
+}
+export {};
+//# sourceMappingURL=RpcServerManager.d.ts.map

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

@@ -0,0 +1,8 @@
+import type { DataPacket } from '@livekit/protocol';
+export type EventSendDataPacket = {
+    packet: DataPacket;
+};
+export type RpcServerManagerCallbacks = {
+    sendDataPacket: (event: EventSendDataPacket) => void;
+};
+//# sourceMappingURL=events.d.ts.map

package/dist/ts4.2/room/{rpc.d.ts → rpc/utils.d.ts}

@@ -49,6 +49,7 @@ export declare class RpcError extends Error {
     static MAX_DATA_BYTES: number;
     code: number;
     data?: string;
+    cause?: unknown;
     /**
      * Creates an error object with the given code and message, plus an optional data payload.
      *
@@ -56,7 +57,9 @@ export declare class RpcError extends Error {
      *
      * Error codes 1001-1999 are reserved for built-in errors (see RpcError.ErrorCode for their meanings).
      */
-    constructor(code: number, message: string, data?: string);
+    constructor(code: number, message: string, data?: string, options?: {
+        cause?: unknown;
+    });
     /**
      * @internal
      */
@@ -87,9 +90,36 @@ export declare class RpcError extends Error {
      *
      * @internal
      */
-    static builtIn(key: keyof typeof RpcError.ErrorCode, data?: string): RpcError;
+    static builtIn(key: keyof typeof RpcError.ErrorCode, data?: string, options?: {
+        cause?: unknown;
+    }): RpcError;
 }
-export declare const MAX_PAYLOAD_BYTES = 15360;
+export declare const MAX_V1_PAYLOAD_BYTES = 15360;
+/**
+ * Topic used for v2 RPC request data streams.
+ * @internal
+ */
+export declare const RPC_REQUEST_DATA_STREAM_TOPIC = "lk.rpc_request";
+/**
+ * Topic used for v2 RPC response data streams.
+ * @internal
+ */
+export declare const RPC_RESPONSE_DATA_STREAM_TOPIC = "lk.rpc_response";
+/** @internal */
+export declare enum RpcRequestAttrs {
+    RPC_REQUEST_ID = "lk.rpc_request_id",
+    RPC_REQUEST_METHOD = "lk.rpc_request_method",
+    RPC_REQUEST_RESPONSE_TIMEOUT_MS = "lk.rpc_request_response_timeout_ms",
+    RPC_REQUEST_VERSION = "lk.rpc_request_version"
+}
+/** Initial version of rpc which uses RpcRequest / RpcResponse messages.
+ * @internal
+ **/
+export declare const RPC_VERSION_V1 = 1;
+/** Rpc version backed by data streams instead of RpcRequest / RpcResponse.
+ * @internal
+ **/
+export declare const RPC_VERSION_V2 = 2;
 /**
  * @internal
  */
@@ -98,4 +128,4 @@ export declare function byteLength(str: string): number;
  * @internal
  */
 export declare function truncateBytes(str: string, maxBytes: number): string;
-//# sourceMappingURL=rpc.d.ts.map
+//# sourceMappingURL=utils.d.ts.map

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

@@ -0,0 +1,19 @@
+import type { PacketTrailerMetadata } from '../../packetTrailer/types';
+/**
+ * Caches packet trailer metadata extracted from received video frames,
+ * keyed by RTP timestamp so it can be looked up when the frame is displayed.
+ *
+ * Metadata is populated either by the packet trailer worker managed by
+ * `PacketTrailerManager` (non-E2EE) or by the E2EE FrameCryptor worker
+ * after decryption (E2EE).
+ *
+ * @experimental
+ */
+export declare class PacketTrailerExtractor {
+    private metadataMap;
+    private activeSsrc;
+    storeMetadata(rtpTimestamp: number, ssrc: number, metadata: PacketTrailerMetadata): void;
+    lookupMetadata(rtpTimestamp: number): PacketTrailerMetadata | undefined;
+    dispose(): void;
+}
+//# sourceMappingURL=PacketTrailerExtractor.d.ts.map

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

@@ -1,5 +1,7 @@
+import type { PacketTrailerMetadata } from '../../packetTrailer/types';
 import type { VideoReceiverStats } from '../stats';
 import type { LoggerOptions } from '../types';
+import type { PacketTrailerExtractor } from './PacketTrailerExtractor';
 import RemoteTrack from './RemoteTrack';
 import { Track } from './Track';
 import type { AdaptiveStreamSettings } from './types';
@@ -9,8 +11,22 @@ export default class RemoteVideoTrack extends RemoteTrack<Track.Kind.Video> {
     private adaptiveStreamSettings?;
     private lastVisible?;
     private lastDimensions?;
+    /** @internal */
+    packetTrailerExtractor?: PacketTrailerExtractor;
     constructor(mediaTrack: MediaStreamTrack, sid: string, receiver: RTCRtpReceiver, adaptiveStreamSettings?: AdaptiveStreamSettings, loggerOptions?: LoggerOptions);
     get isAdaptiveStream(): boolean;
+    /**
+     * Look up frame-level metadata for a given RTP timestamp.
+     * Use with the `TrackEvent.TimeSyncUpdate` event to correlate displayed frames
+     * with their capture-time metadata.
+     *
+     * Requires the room to be configured with the `packetTrailer` worker option
+     * and the publishing track to have packet trailer features enabled.
+     *
+     */
+    lookupFrameMetadata({ rtpTimestamp, }: {
+        rtpTimestamp: number;
+    }): PacketTrailerMetadata | undefined;
     setStreamState(value: Track.StreamState): void;
     /**
      * Note: When using adaptiveStream, you need to use remoteVideoTrack.attach() to add the track to a HTMLVideoElement, otherwise your video tracks might never start