livekit-client 2.18.8 → 2.18.10

package/dist/ts4.2/e2ee/worker/FrameCryptor.d.ts

@@ -1,4 +1,5 @@
 import type TypedEventEmitter from 'typed-emitter';
+import type { PacketTrailerPublishOptions } from '../../packetTrailer/types';
 import type { VideoCodec } from '../../room/track/options';
 import type { CryptorCallbacks } from '../events';
 import type { KeyProviderOptions } from '../types';
@@ -37,6 +38,14 @@ export declare class FrameCryptor extends BaseFrameCryptor {
     private sifTrailer;
     private detectedCodec?;
     private currentTransform?;
+    /**
+     * Whether the subscribed track advertises packet trailer features.
+     * When false, we skip the per-frame trailer extraction path entirely
+     * on decode to avoid unnecessary work on tracks that don't use it.
+     */
+    private hasPacketTrailer;
+    private packetTrailer?;
+    private packetTrailerFrameId;
     /**
      * Throttling mechanism for decryption errors to prevent memory leaks
      */
@@ -49,7 +58,7 @@ export declare class FrameCryptor extends BaseFrameCryptor {
         keys: ParticipantKeyHandler;
         participantIdentity: string;
         keyProviderOptions: KeyProviderOptions;
-        sifTrailer?: Uint8Array;
+        sifTrailer?: NonSharedUint8Array;
     });
     private get logContext();
     /**
@@ -73,8 +82,15 @@ export declare class FrameCryptor extends BaseFrameCryptor {
      * @param map
      */
     setRtpMap(map: Map<number, VideoCodec>): void;
-    setupTransform(operation: 'encode' | 'decode', readable: ReadableStream<RTCEncodedVideoFrame | RTCEncodedAudioFrame>, writable: WritableStream<RTCEncodedVideoFrame | RTCEncodedAudioFrame>, trackId: string, isReuse: boolean, codec?: VideoCodec): void;
-    setSifTrailer(trailer: Uint8Array): void;
+    /**
+     * Sets whether the track associated with this cryptor carries packet
+     * trailer data. When false, {@link decodeFunction} skips the per-frame
+     * trailer extraction branch entirely.
+     */
+    setHasPacketTrailer(hasPacketTrailer: boolean): void;
+    setPacketTrailer(packetTrailer?: PacketTrailerPublishOptions): void;
+    setupTransform(operation: 'encode' | 'decode', readable: ReadableStream<RTCEncodedVideoFrame | RTCEncodedAudioFrame>, writable: WritableStream<RTCEncodedVideoFrame | RTCEncodedAudioFrame>, trackId: string, isReuse: boolean, codec?: VideoCodec, packetTrailer?: PacketTrailerPublishOptions): void;
+    setSifTrailer(trailer: NonSharedUint8Array): void;
     /**
      * Checks if we should emit an error based on throttling rules to prevent memory leaks
      * @param errorKey - unique key identifying the error context
@@ -109,6 +125,7 @@ export declare class FrameCryptor extends BaseFrameCryptor {
      * 9) Enqueue the encrypted frame for sending.
      */
     protected encodeFunction(encodedFrame: RTCEncodedVideoFrame | RTCEncodedAudioFrame, controller: TransformStreamDefaultController): Promise<void>;
+    private appendPacketTrailer;
     /**
      * Function that will be injected in a stream and will decrypt the given encoded frames.
      *
@@ -152,6 +169,6 @@ export declare class FrameCryptor extends BaseFrameCryptor {
  * by the livekit server and thus to be treated as unencrypted
  * @internal
  */
-export declare function isFrameServerInjected(frameData: ArrayBuffer, trailerBytes: Uint8Array): boolean;
+export declare function isFrameServerInjected(frameData: ArrayBuffer, trailerBytes: NonSharedUint8Array): boolean;
 export {};
 //# sourceMappingURL=FrameCryptor.d.ts.map

package/dist/ts4.2/e2ee/worker/naluUtils.d.ts

@@ -23,5 +23,5 @@ export interface NALUProcessingResult {
  * @param knownCodec Known codec from other sources (optional)
  * @returns NALU processing result
  */
-export declare function processNALUsForEncryption(data: Uint8Array, knownCodec?: 'h264' | 'h265'): NALUProcessingResult;
+export declare function processNALUsForEncryption(data: NonSharedUint8Array, knownCodec?: 'h264' | 'h265'): NALUProcessingResult;
 //# sourceMappingURL=naluUtils.d.ts.map

package/dist/ts4.2/e2ee/worker/sifPayload.d.ts

@@ -1,10 +1,10 @@
 import type { VideoCodec } from '../..';
-export declare const VP8KeyFrame8x8: Uint8Array;
-export declare const H264KeyFrame2x2SPS: Uint8Array;
-export declare const H264KeyFrame2x2PPS: Uint8Array;
-export declare const H264KeyFrame2x2IDR: Uint8Array;
-export declare const H264KeyFrame2x2: Uint8Array[];
-export declare const OpusSilenceFrame: Uint8Array;
+export declare const VP8KeyFrame8x8: NonSharedUint8Array;
+export declare const H264KeyFrame2x2SPS: NonSharedUint8Array;
+export declare const H264KeyFrame2x2PPS: NonSharedUint8Array;
+export declare const H264KeyFrame2x2IDR: NonSharedUint8Array;
+export declare const H264KeyFrame2x2: NonSharedUint8Array[];
+export declare const OpusSilenceFrame: NonSharedUint8Array;
 /**
  * Pre-computed SHA-256 hashes for secure comparison operations
  */
@@ -18,5 +18,5 @@ export declare const CryptoHashes: {
 /**
  * Check if a byte array matches any of the known SIF payload frame types using secure crypto hashes
  */
-export declare function identifySifPayload(data: Uint8Array | ArrayBuffer): Promise<VideoCodec | 'opus' | null>;
+export declare function identifySifPayload(data: NonSharedUint8Array | ArrayBuffer): Promise<VideoCodec | 'opus' | null>;
 //# sourceMappingURL=sifPayload.d.ts.map

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

@@ -8,6 +8,7 @@ import Room, { ConnectionState } from './room/Room';
 import * as attributes from './room/attribute-typings';
 import LocalDataTrack from './room/data-track/LocalDataTrack';
 import type RemoteDataTrack, { DataTrackSubscribeOptions } from './room/data-track/RemoteDataTrack';
+import type { RemoteDataTrackPipelineOptions } from './room/data-track/types';
 import LocalParticipant from './room/participant/LocalParticipant';
 import type Participant, { ParticipantEventCallbacks } from './room/participant/Participant';
 import Participant, { ConnectionQuality, ParticipantKind } from './room/participant/Participant';
@@ -32,6 +33,9 @@ import { compareVersions, createAudioAnalyser, getEmptyAudioStreamTrack, getEmpt
 import { getBrowser } from './utils/browserParser';
 export type { RpcInvocationData, PerformRpcParams } from './room/rpc';
 export { RpcError } from './room/rpc';
+export type { PacketTrailerMetadata, PacketTrailerPublishOptions } from './packetTrailer/types';
+export type { PacketTrailerOptions } from './packetTrailer/PacketTrailerManager';
+export { PacketTrailerManager } from './packetTrailer/PacketTrailerManager';
 export * from './connectionHelper/ConnectionCheck';
 export * from './connectionHelper/checks/Checker';
 export * from './e2ee';
@@ -54,7 +58,7 @@ export * from './version';
 export { 
 /** @internal */
 attributes, ConnectionQuality, ConnectionState, CriticalTimers, DataPacket_Kind, Encryption_Type, DefaultReconnectPolicy, DisconnectReason, LocalAudioTrack, LocalParticipant, LocalTrack, LocalTrackPublication, LocalVideoTrack, LogLevel, LoggerNames, Participant, RemoteAudioTrack, RemoteParticipant, ParticipantKind, RemoteTrack, RemoteTrackPublication, RemoteVideoTrack, Room, SubscriptionError, TrackPublication, TrackType, compareVersions, createAudioAnalyser, getBrowser, getEmptyAudioStreamTrack, getEmptyVideoStreamTrack, getLogger, isBrowserSupported, setLogExtension, setLogLevel, supportsAV1, supportsAdaptiveStream, supportsAudioOutputSelection, supportsDynacast, supportsVP9, Mutex, isAudioCodec, isAudioTrack, isLocalTrack, isRemoteTrack, isVideoCodec, isVideoTrack, isLocalParticipant, isRemoteParticipant, LocalDataTrack, RemoteDataTrack, };
-export type { AudioAnalyserOptions, ElementInfo, LiveKitReactNativeInfo, TextStreamInfo, ParticipantTrackPermission, AudioReceiverStats, AudioSenderStats, VideoReceiverStats, VideoSenderStats, ReconnectContext, ReconnectPolicy, RoomEventCallbacks, ParticipantEventCallbacks, PublicationEventCallbacks, DataTrackSubscribeOptions, };
+export type { AudioAnalyserOptions, ElementInfo, LiveKitReactNativeInfo, TextStreamInfo, ParticipantTrackPermission, AudioReceiverStats, AudioSenderStats, VideoReceiverStats, VideoSenderStats, ReconnectContext, ReconnectPolicy, RoomEventCallbacks, ParticipantEventCallbacks, PublicationEventCallbacks, DataTrackSubscribeOptions, RemoteDataTrackPipelineOptions, };
 export type { DataTrackPacketHeader } from './room/data-track/packet';
 export { DataTrackPacket } from './room/data-track/packet';
 export type { DataTrackExtensions, DataTrackUserTimestampExtension, DataTrackE2eeExtension } from './room/data-track/packet/extensions';

package/dist/ts4.2/options.d.ts

@@ -1,4 +1,5 @@
 import type { E2EEOptions } from './e2ee/types';
+import type { PacketTrailerOptions } from './packetTrailer/PacketTrailerManager';
 import type { ReconnectPolicy } from './room/ReconnectPolicy';
 import type { AudioCaptureOptions, AudioOutputOptions, TrackPublishDefaults, VideoCaptureOptions } from './room/track/options';
 import type { AdaptiveStreamSettings } from './room/track/types';
@@ -78,6 +79,12 @@ export interface InternalRoomOptions {
      */
     encryption?: E2EEOptions;
     loggerName?: string;
+    /**
+     * @experimental
+     * Options for enabling packet trailers on video tracks.
+     * Packet trailers carry frame-level metadata such as user timestamps and frame IDs.
+     */
+    packetTrailer?: PacketTrailerOptions;
     /**
      * will attempt to connect via single peer connection mode.
      * falls back to dual peer connection mode if not available.

package/dist/ts4.2/packetTrailer/PacketTrailerManager.d.ts

@@ -0,0 +1,49 @@
+import type Room from '../room/Room';
+export interface PacketTrailerOptions {
+    /**
+     * Dedicated worker for extracting packet trailers off the main thread.
+     *
+     * Encoded video streams are transferred to the worker for processing, which
+     * avoids per-frame work on the main thread.
+     */
+    worker: Worker;
+}
+/**
+ * Manages packet trailer extraction for received video tracks.
+ *
+ * When a track's TrackInfo indicates packet trailer features, the manager
+ * wires up an encoded frame transform to strip the trailer from encoded frames
+ * and cache the metadata for lookup.
+ *
+ * Packet trailer extraction is worker-only. If no worker is configured, the
+ * SDK does not advertise packet trailer support and skips extraction.
+ *
+ * When E2EE is active, the E2EE FrameCryptor worker handles trailer
+ * extraction directly (before decryption), so this manager only creates
+ * the extractor/metadata cache — no separate pipeline is installed.
+ *
+ * @experimental
+ */
+export declare class PacketTrailerManager {
+    private worker?;
+    private room?;
+    private extractors;
+    /**
+     * Tracks the trackId associated with each receiver that has had its
+     * encoded streams handed off to the worker. Used to detect receiver
+     * reuse (transceiver recycling) so we can remap trackIds instead of
+     * re-transferring already-consumed streams.
+     */
+    private workerPipelines;
+    constructor(options?: PacketTrailerOptions);
+    /** @internal */
+    setup(room: Room): void;
+    private setupReceiver;
+    private setupPassthroughReceiver;
+    private setupWorkerReceiver;
+    private teardownTrack;
+    private cleanup;
+    private onWorkerMessage;
+    private onWorkerError;
+}
+//# sourceMappingURL=PacketTrailerManager.d.ts.map

package/dist/ts4.2/packetTrailer/packetTrailer.d.ts

@@ -0,0 +1,32 @@
+import type { PacketTrailerMetadata, PacketTrailerPublishOptions } from './types';
+export declare const PACKET_TRAILER_MAGIC: Uint8Array<ArrayBuffer>;
+export declare const PACKET_TRAILER_TIMESTAMP_TAG = 1;
+export declare const PACKET_TRAILER_FRAME_ID_TAG = 2;
+export declare const PACKET_TRAILER_ENVELOPE_SIZE = 5;
+export interface ExtractPacketTrailerResult {
+    data: Uint8Array;
+    metadata?: PacketTrailerMetadata;
+}
+export declare function appendPacketTrailer(data: Uint8Array, userTimestamp: bigint, frameId: number): Uint8Array;
+export declare function appendPacketTrailerToEncodedFrame(frame: RTCEncodedVideoFrame, options: PacketTrailerPublishOptions | undefined, frameId: number): boolean;
+export declare function extractPacketTrailer(data: ArrayBuffer | Uint8Array): ExtractPacketTrailerResult;
+export declare function getFrameRtpTimestamp(frame: RTCEncodedVideoFrame | RTCEncodedAudioFrame): number | undefined;
+export declare function getFrameSsrc(frame: RTCEncodedVideoFrame | RTCEncodedAudioFrame): number;
+export interface PacketTrailerFramePayload {
+    trackId: string;
+    rtpTimestamp: number;
+    ssrc: number;
+    metadata: PacketTrailerMetadata;
+}
+export interface ProcessPacketTrailerResult {
+    data?: ArrayBuffer;
+    payload?: PacketTrailerFramePayload;
+}
+/**
+ * Extracts a packet trailer from an encoded frame and returns the stripped
+ * frame data (if any) along with a ready-to-post metadata payload. Returns an
+ * empty object when no trailer is present, an RTP timestamp can't be read, or
+ * a trackId isn't available.
+ */
+export declare function processPacketTrailer(frame: RTCEncodedVideoFrame | RTCEncodedAudioFrame, trackId: string | undefined): ProcessPacketTrailerResult;
+//# sourceMappingURL=packetTrailer.d.ts.map

package/dist/ts4.2/packetTrailer/types.d.ts

@@ -0,0 +1,57 @@
+import type { PacketTrailerFramePayload } from './packetTrailer';
+export interface PacketTrailerMetadata {
+    userTimestamp: bigint;
+    frameId: number;
+}
+export interface PacketTrailerPublishOptions {
+    timestamp?: boolean;
+    frameId?: boolean;
+}
+export interface PTBaseMessage {
+    kind: string;
+    data?: unknown;
+}
+export interface PTInitMessage extends PTBaseMessage {
+    kind: 'init';
+}
+export interface PTInitAck extends PTBaseMessage {
+    kind: 'initAck';
+}
+export interface PTDecodeMessage extends PTBaseMessage {
+    kind: 'decode';
+    data: {
+        readableStream: ReadableStream;
+        writableStream: WritableStream;
+        trackId: string;
+        hasPacketTrailer: boolean;
+    };
+}
+export interface PTEncodeMessage extends PTBaseMessage {
+    kind: 'encode';
+    data: {
+        readableStream: ReadableStream;
+        writableStream: WritableStream;
+        packetTrailer?: PacketTrailerPublishOptions;
+    };
+}
+export type PTScriptTransformOptions = {
+    kind: 'decode';
+    trackId: string;
+} | {
+    kind: 'encode';
+    packetTrailer?: PacketTrailerPublishOptions;
+};
+export interface PTMetadataMessage extends PTBaseMessage {
+    kind: 'metadata';
+    data: PacketTrailerFramePayload;
+}
+export interface PTUpdateTrackIdMessage extends PTBaseMessage {
+    kind: 'updateTrackId';
+    data: {
+        oldTrackId: string;
+        newTrackId: string;
+        hasPacketTrailer: boolean;
+    };
+}
+export type PTWorkerMessage = PTInitMessage | PTInitAck | PTDecodeMessage | PTEncodeMessage | PTUpdateTrackIdMessage | PTMetadataMessage;
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1,9 @@
+import { PacketTrailerFeature } from '@livekit/protocol';
+import type { PacketTrailerOptions } from './PacketTrailerManager';
+import type { PacketTrailerPublishOptions } from './types';
+export declare function shouldUsePacketTrailerScriptTransform(): boolean;
+export declare function isPacketTrailerSupported(options?: PacketTrailerOptions): boolean;
+export declare function hasPacketTrailerPublishOptions(options?: PacketTrailerPublishOptions): boolean;
+export declare function getPacketTrailerFeatures(options?: PacketTrailerPublishOptions): PacketTrailerFeature[];
+export declare function getPacketTrailerPublishOptions(features?: PacketTrailerFeature[]): PacketTrailerPublishOptions | undefined;
+//# sourceMappingURL=utils.d.ts.map

package/dist/ts4.2/packetTrailer/worker/packetTrailer.worker.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=packetTrailer.worker.d.ts.map

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

@@ -130,6 +130,7 @@ export default class RTCEngine extends RTCEngine_base {
     private handleBufferedAmountLow;
     createSender(track: LocalTrack, opts: TrackPublishOptions, encodings?: RTCRtpEncodingParameters[]): Promise<RTCRtpSender>;
     createSimulcastSender(track: LocalVideoTrack, simulcastTrack: SimulcastTrackInfo, opts: TrackPublishOptions, encodings?: RTCRtpEncodingParameters[]): Promise<RTCRtpSender | undefined>;
+    private setupPacketTrailerSender;
     private createTransceiverRTCRtpSender;
     private createSimulcastTransceiverSender;
     private createRTCRtpSender;
@@ -146,7 +147,7 @@ export default class RTCEngine extends RTCEngine_base {
     /** @internal */
     publishRpcAck(destinationIdentity: string, requestId: string): Promise<void>;
     sendDataPacket(packet: DataPacket, kind: DataChannelKind): Promise<void>;
-    sendLossyBytes(bytes: Uint8Array, kind: Exclude<DataChannelKind, DataChannelKind.RELIABLE>, bufferStatusLowBehavior?: 'drop' | 'wait'): Promise<void>;
+    sendLossyBytes(bytes: NonSharedUint8Array, kind: Exclude<DataChannelKind, DataChannelKind.RELIABLE>, bufferStatusLowBehavior?: 'drop' | 'wait'): Promise<void>;
     private resendReliableMessagesForResume;
     private updateAndEmitDCBufferStatus;
     private isBufferStatusLow;

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?;
@@ -133,6 +134,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
@@ -319,7 +321,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/LocalDataTrack.d.ts

@@ -18,10 +18,11 @@ export default class LocalDataTrack implements ILocalTrack, IDataTrack {
     protected log: StructuredLogger;
     /** Resolves once the data track has sent all pending packets the rtc data channel buffer. */
     protected flushedFuture: Future<void, never>;
+    protected isFlushed: boolean;
     /** @internal */
     constructor(options: DataTrackOptions, manager: OutgoingDataTrackManager);
     private handleManagerReset;
-    private handleManagerPacketsFlushed;
+    private handleManagerPacketsFlushedChange;
     /** @internal */
     static withExplicitHandle(options: DataTrackOptions, manager: OutgoingDataTrackManager, handle: DataTrackHandle): LocalDataTrack;
     /** Metrics about the data track publication. */

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/OutgoingDataTrackManager.d.ts

@@ -7,7 +7,7 @@ import { DataTrackHandle } from '../handle';
 import type { DataTrackInfo } from '../types';
 import { DataTrackPublishError, DataTrackPushFrameError, DataTrackPushFrameErrorReason } from './errors';
 import DataTrackOutgoingPipeline from './pipeline';
-import type { DataTrackOptions, EventPacketAvailable, EventPacketsFlushed, EventSfuPublishRequest, EventSfuUnpublishRequest, EventTrackPublished, EventTrackUnpublished, SfuPublishResponseResult } from './types';
+import type { DataTrackOptions, EventPacketAvailable, EventPacketsFlushedChange, EventSfuPublishRequest, EventSfuUnpublishRequest, EventTrackPublished, EventTrackUnpublished, SfuPublishResponseResult } from './types';
 export type PendingDescriptor = {
     type: 'pending';
     /** Resolves when the descriptor is fully published. */
@@ -38,7 +38,7 @@ export type DataTrackOutgoingManagerCallbacks = {
     /** A {@link LocalDataTrack} has been unpublished */
     trackUnpublished: (event: EventTrackUnpublished) => void;
     /** A {@link LocalDataTrack} has had all of its in flight packets sent via the rtc data channel. */
-    packetsFlushed: (event: EventPacketsFlushed) => void;
+    packetsFlushedChange: (event: EventPacketsFlushedChange) => void;
     /** The manager has been reset and all state has been cleared in preparation for the next room
      * connection. */
     reset: () => void;

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. */
@@ -40,7 +40,8 @@ export type EventTrackUnpublished = {
     sid: DataTrackSid;
 };
 /** A track has had all of its in flight packets sent via the rtc data channel. */
-export type EventPacketsFlushed = {
+export type EventPacketsFlushedChange = {
     handle: DataTrackHandle;
+    isFlushed: boolean;
 };
 //# sourceMappingURL=types.d.ts.map

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",
     /**