livekit-client 2.18.9 → 2.18.10

package/src/room/data-track/depacketizer.ts

@@ -9,14 +9,12 @@ import { U16_MAX_SIZE, WrapAroundUnsignedInt } from './utils';
 const log = getLogger(LoggerNames.DataTracks);
 
 type PartialFrame = {
-  /** Frame number from the start packet. */
-  frameNumber: number;
   /** Sequence of the start packet. */
   startSequence: WrapAroundUnsignedInt<typeof U16_MAX_SIZE>;
   /** Extensions from the start packet. */
   extensions: DataTrackExtensions;
   /** Mapping between sequence number and packet payload. */
-  payloads: Map<number, Uint8Array>;
+  payloads: Map<number, NonSharedUint8Array>;
 };
 
 /** An error indicating a frame was dropped. */
@@ -80,16 +78,24 @@ export enum DataTrackDepacketizerDropReason {
 }
 
 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 = 128;
 
-  private partial: PartialFrame | null = null;
+  /** Partial frames currently being assembled, keyed by frame number. `Map` preserves insertion
+   * order, so the oldest entry is the first key. */
+  private partials: Map<number, PartialFrame> = new Map();
 
   /** Should be repeatedly called with received {@link DataTrackPacket}s - intermediate calls
    * aggregate the packet's state internally, and return null.
@@ -112,14 +118,19 @@ export default class DataTrackDepacketizer {
   }
 
   reset() {
-    this.partial = null;
+    this.partials.clear();
+  }
+
+  private peekOldestPartialFrameNumber(): number | null {
+    const first = this.partials.keys().next();
+    return first.done ? null : first.value;
   }
 
   private frameFromSingle(
     packet: DataTrackPacket,
     options?: PushOptions,
   ): Throws<
-    DataTrackFrameInternal | null,
+    DataTrackFrameInternal,
     DataTrackDepacketizerDropError<DataTrackDepacketizerDropReason.Interrupted>
   > {
     if (packet.header.marker !== FrameMarker.Single) {
@@ -129,21 +140,30 @@ export default class DataTrackDepacketizer {
       );
     }
 
-    if (this.partial) {
-      if (options?.errorOnPartialFrames) {
-        const frameNumber = this.partial.frameNumber;
-        this.reset();
+    // A `Single` packet is a self-contained frame and doesn't reserve a partials slot, but if
+    // the partials map is at capacity, treat it as a signal that the oldest in-flight partial
+    // is stale and evict it (matches `main`'s behavior when `maxPartialFrames`
+    // defaults to 1).
+    const maxPartialFrames = options?.maxPartialFrames ?? 1;
+    if (this.partials.size >= maxPartialFrames) {
+      const oldestPartialFrameNumber = this.peekOldestPartialFrameNumber();
+      if (typeof oldestPartialFrameNumber !== 'number') {
+        // @throws-transformer ignore - this should be treated as a "panic" and not be caught
+        throw new Error(
+          `Depacketizer.frameFromSingle: no oldest frame number found, but partials.size is ${this.partials.size}.`,
+        );
+      }
+      this.partials.delete(oldestPartialFrameNumber);
+      if (options?.throwOnInterruption) {
         throw DataTrackDepacketizerDropError.interrupted(
-          frameNumber,
+          oldestPartialFrameNumber,
           packet.header.frameNumber.value,
         );
-      } else {
-        log.warn(
-          `Data track frame ${this.partial.frameNumber} was interrupted by the start of a new frame, dropping.`,
-        );
       }
+      log.warn(
+        `Data track frame ${oldestPartialFrameNumber} was interrupted by single-packet frame ${packet.header.frameNumber.value}, dropping.`,
+      );
     }
-    this.reset();
 
     return { payload: packet.payload, extensions: packet.header.extensions };
   }
@@ -160,31 +180,36 @@ export default class DataTrackDepacketizer {
       );
     }
 
-    if (this.partial) {
-      if (options?.errorOnPartialFrames) {
-        const frameNumber = this.partial.frameNumber;
-        this.reset();
-        throw DataTrackDepacketizerDropError.interrupted(
-          frameNumber,
-          packet.header.frameNumber.value,
-        );
-      } else {
-        log.warn(
-          `Data track frame ${this.partial.frameNumber} was interrupted by the start of a new frame ${packet.header.frameNumber.value}, dropping.`,
-        );
-      }
-    }
-    this.reset();
-
     const startSequence = packet.header.sequence;
-
-    this.partial = {
-      frameNumber: packet.header.frameNumber.value,
+    const frameNumber = packet.header.frameNumber.value;
+    const partial: PartialFrame = {
       startSequence,
       extensions: packet.header.extensions,
       payloads: new Map([[startSequence.value, packet.payload]]),
     };
 
+    // Loop in case `maxPartialFrames` shrunk relative to a previous push call - evict the
+    // oldest partials until there is room for the new one. With `throwOnInterruption` set the
+    // throw inside the loop short-circuits on the first eviction, matching the single-eviction
+    // behavior callers expect when they ask to be told about interruptions.
+    const maxPartialFrames = options?.maxPartialFrames ?? 1;
+    while (this.partials.size >= maxPartialFrames) {
+      const oldestPartialFrameNumber = this.peekOldestPartialFrameNumber();
+      if (typeof oldestPartialFrameNumber !== 'number') {
+        // partials map is empty - nothing more to evict
+        break;
+      }
+      this.partials.delete(oldestPartialFrameNumber);
+
+      if (options?.throwOnInterruption) {
+        throw DataTrackDepacketizerDropError.interrupted(oldestPartialFrameNumber, frameNumber);
+      }
+      log.warn(
+        `Data track partials full (max ${maxPartialFrames}), evicted oldest frame ${oldestPartialFrameNumber} to make room for new frame ${frameNumber}.`,
+      );
+    }
+    this.partials.set(frameNumber, partial);
+
     return null;
   }
 
@@ -199,40 +224,32 @@ export default class DataTrackDepacketizer {
       );
     }
 
-    if (!this.partial) {
-      this.reset();
-      throw DataTrackDepacketizerDropError.unknownFrame(packet.header.frameNumber.value);
-    }
-
-    if (packet.header.frameNumber.value !== this.partial.frameNumber) {
-      const frameNumber = this.partial.frameNumber;
-      this.reset();
-      throw DataTrackDepacketizerDropError.interrupted(
-        frameNumber,
-        packet.header.frameNumber.value,
-      );
+    const packetFrameNumber = packet.header.frameNumber.value;
+    const matchingPartial = this.partials.get(packetFrameNumber);
+    if (!matchingPartial) {
+      this.partials.delete(packetFrameNumber);
+      throw DataTrackDepacketizerDropError.unknownFrame(packetFrameNumber);
     }
 
     // NOTE: this check will block reprocessing packets with duplicate sequence values if the
     // buffer is full already, which could maybe be problematic for very large frames.
-    if (this.partial.payloads.size >= DataTrackDepacketizer.MAX_BUFFER_PACKETS) {
-      const frameNumber = this.partial.frameNumber;
-      this.reset();
-      throw DataTrackDepacketizerDropError.bufferFull(frameNumber);
+    if (matchingPartial.payloads.size >= DataTrackDepacketizer.MAX_BUFFER_PACKETS) {
+      this.partials.delete(packetFrameNumber);
+      throw DataTrackDepacketizerDropError.bufferFull(packetFrameNumber);
     }
 
     // Note: receiving a packet with a duplicate `sequence` value is something that likely won't
     // happen in actual use, but even if it does (maybe a low level network retransmission?) the
     // last packet with a given sequence received should always win.
-    if (this.partial.payloads.has(packet.header.sequence.value)) {
+    if (matchingPartial.payloads.has(packet.header.sequence.value)) {
       log.warn(
-        `Data track frame ${this.partial.frameNumber} received duplicate packet for sequence ${packet.header.sequence.value}, so replacing with newly received packet.`,
+        `Data track frame ${packetFrameNumber} received duplicate packet for sequence ${packet.header.sequence.value}, so replacing with newly received packet.`,
       );
     }
-    this.partial.payloads.set(packet.header.sequence.value, packet.payload);
+    matchingPartial.payloads.set(packet.header.sequence.value, packet.payload);
 
     if (packet.header.marker === FrameMarker.Final) {
-      return this.finalize(this.partial, packet.header.sequence.value);
+      return this.finalize(packetFrameNumber, matchingPartial, packet.header.sequence.value);
     }
 
     return null;
@@ -240,6 +257,7 @@ export default class DataTrackDepacketizer {
 
   /** Try to reassemble the complete frame. */
   private finalize(
+    partialFrameNumber: number,
     partial: PartialFrame,
     endSequence: number,
   ): Throws<
@@ -281,13 +299,13 @@ export default class DataTrackDepacketizer {
       }
 
       // The packet is done processing, reset the state so another frame can be processed next.
-      this.reset();
+      this.partials.delete(partialFrameNumber);
       return { payload, extensions: partial.extensions };
     }
 
-    this.reset();
+    this.partials.delete(partialFrameNumber);
     throw DataTrackDepacketizerDropError.incomplete(
-      partial.frameNumber,
+      partialFrameNumber,
       received,
       endSequence - partial.startSequence.value + 1,
     );

package/src/room/data-track/frame.ts

@@ -2,13 +2,13 @@ import { DataTrackExtensions, DataTrackUserTimestampExtension } from './packet/e
 
 /** 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;
 };
 

package/src/room/data-track/incoming/IncomingDataTrackManager.test.ts

@@ -936,5 +936,199 @@ describe('DataTrackIncomingManager', () => {
         process.off('unhandledRejection', onUnhandled);
       }
     });
+
+    it('should depacketize multiple interleaved partial frames when setMaxPartialFrames is called before subscribe', async () => {
+      const manager = new IncomingDataTrackManager();
+      const managerEvents = subscribeToEvents<DataTrackIncomingManagerCallbacks>(manager, [
+        'sfuUpdateSubscription',
+        'trackPublished',
+      ]);
+
+      const senderIdentity = 'identity';
+      const sid = 'data track sid';
+      const handle = DataTrackHandle.fromNumber(5);
+
+      await manager.receiveSfuPublicationUpdates(
+        new Map([[senderIdentity, [{ sid, pubHandle: handle, name: 'test', usesE2ee: false }]]]),
+      );
+      const trackPublishedEvent = await managerEvents.waitFor('trackPublished');
+
+      // Configure the track BEFORE any subscribe.
+      trackPublishedEvent.track.setPipelineOptions({ maxPartialFrames: 3 });
+
+      const [stream, sfuSubscriptionComplete] = manager.openSubscriptionStream(sid);
+      const reader = stream.getReader();
+
+      await managerEvents.waitFor('sfuUpdateSubscription');
+      manager.receivedSfuSubscriberHandles(new Map([[handle, sid]]));
+      await sfuSubscriptionComplete;
+
+      // Two interleaved partial frames: Start(1), Start(2), Final(1), Final(2). With the default
+      // maxPartialFrames=1 frame 1 would be evicted by frame 2; with maxPartialFrames=3 both
+      // frames coexist and emerge.
+      pushInterleavedTwoFramePair(manager, handle, {
+        frameOneNumber: 1,
+        frameOneStartSequence: 0,
+        frameOnePayloads: [new Uint8Array([0xa1]), new Uint8Array([0xa2])],
+        frameTwoNumber: 2,
+        frameTwoStartSequence: 100,
+        frameTwoPayloads: [new Uint8Array([0xb1]), new Uint8Array([0xb2])],
+      });
+
+      const first = await reader.read();
+      expect(first.done).toStrictEqual(false);
+      expect(first.value?.payload).toStrictEqual(new Uint8Array([0xa1, 0xa2]));
+
+      const second = await reader.read();
+      expect(second.done).toStrictEqual(false);
+      expect(second.value?.payload).toStrictEqual(new Uint8Array([0xb1, 0xb2]));
+    });
+
+    it('should pick up setMaxPartialFrames live on an already-active subscription', async () => {
+      const manager = new IncomingDataTrackManager();
+      const managerEvents = subscribeToEvents<DataTrackIncomingManagerCallbacks>(manager, [
+        'sfuUpdateSubscription',
+        'trackPublished',
+      ]);
+
+      const senderIdentity = 'identity';
+      const sid = 'data track sid';
+      const handle = DataTrackHandle.fromNumber(5);
+
+      await manager.receiveSfuPublicationUpdates(
+        new Map([[senderIdentity, [{ sid, pubHandle: handle, name: 'test', usesE2ee: false }]]]),
+      );
+      const trackPublishedEvent = await managerEvents.waitFor('trackPublished');
+
+      const [stream, sfuSubscriptionComplete] = manager.openSubscriptionStream(sid);
+      const reader = stream.getReader();
+
+      await managerEvents.waitFor('sfuUpdateSubscription');
+      manager.receivedSfuSubscriberHandles(new Map([[handle, sid]]));
+      await sfuSubscriptionComplete;
+
+      // Subscription is now active; flip the cap on the live pipeline.
+      trackPublishedEvent.track.setPipelineOptions({ maxPartialFrames: 3 });
+
+      pushInterleavedTwoFramePair(manager, handle, {
+        frameOneNumber: 1,
+        frameOneStartSequence: 0,
+        frameOnePayloads: [new Uint8Array([0xa1]), new Uint8Array([0xa2])],
+        frameTwoNumber: 2,
+        frameTwoStartSequence: 100,
+        frameTwoPayloads: [new Uint8Array([0xb1]), new Uint8Array([0xb2])],
+      });
+
+      const first = await reader.read();
+      expect(first.value?.payload).toStrictEqual(new Uint8Array([0xa1, 0xa2]));
+
+      const second = await reader.read();
+      expect(second.value?.payload).toStrictEqual(new Uint8Array([0xb1, 0xb2]));
+    });
+
+    it('should drop the older partial frame by default (no setMaxPartialFrames call)', async () => {
+      const manager = new IncomingDataTrackManager();
+      const managerEvents = subscribeToEvents<DataTrackIncomingManagerCallbacks>(manager, [
+        'sfuUpdateSubscription',
+        'trackPublished',
+      ]);
+
+      const senderIdentity = 'identity';
+      const sid = 'data track sid';
+      const handle = DataTrackHandle.fromNumber(5);
+
+      await manager.receiveSfuPublicationUpdates(
+        new Map([[senderIdentity, [{ sid, pubHandle: handle, name: 'test', usesE2ee: false }]]]),
+      );
+      await managerEvents.waitFor('trackPublished');
+
+      const [stream, sfuSubscriptionComplete] = manager.openSubscriptionStream(sid);
+      const reader = stream.getReader();
+
+      await managerEvents.waitFor('sfuUpdateSubscription');
+      manager.receivedSfuSubscriberHandles(new Map([[handle, sid]]));
+      await sfuSubscriptionComplete;
+
+      // Default cap of 1: Start(2) evicts Start(1), so Final(1) is unknown and only frame 2
+      // makes it through.
+      pushInterleavedTwoFramePair(manager, handle, {
+        frameOneNumber: 1,
+        frameOneStartSequence: 0,
+        frameOnePayloads: [new Uint8Array([0xa1]), new Uint8Array([0xa2])],
+        frameTwoNumber: 2,
+        frameTwoStartSequence: 100,
+        frameTwoPayloads: [new Uint8Array([0xb1]), new Uint8Array([0xb2])],
+      });
+
+      const onlyFrame = await reader.read();
+      expect(onlyFrame.done).toStrictEqual(false);
+      expect(onlyFrame.value?.payload).toStrictEqual(new Uint8Array([0xb1, 0xb2]));
+    });
   });
 });
+
+/** Pushes Start(frame1), Start(frame2), Final(frame1), Final(frame2) packets through the manager
+ * to exercise the depacketizer's concurrent-partial-frame handling. */
+function pushInterleavedTwoFramePair(
+  manager: IncomingDataTrackManager,
+  trackHandle: DataTrackHandle,
+  args: {
+    frameOneNumber: number;
+    frameOneStartSequence: number;
+    frameOnePayloads: [Uint8Array, Uint8Array];
+    frameTwoNumber: number;
+    frameTwoStartSequence: number;
+    frameTwoPayloads: [Uint8Array, Uint8Array];
+  },
+) {
+  const buildPacket = (
+    frameNumber: number,
+    sequence: number,
+    marker: FrameMarker,
+    payload: Uint8Array,
+  ) =>
+    new DataTrackPacket(
+      new DataTrackPacketHeader({
+        extensions: new DataTrackExtensions(),
+        frameNumber: WrapAroundUnsignedInt.u16(frameNumber),
+        marker,
+        sequence: WrapAroundUnsignedInt.u16(sequence),
+        timestamp: DataTrackTimestamp.fromRtpTicks(0),
+        trackHandle,
+      }),
+      payload,
+    ).toBinary();
+
+  manager.packetReceived(
+    buildPacket(
+      args.frameOneNumber,
+      args.frameOneStartSequence,
+      FrameMarker.Start,
+      args.frameOnePayloads[0],
+    ),
+  );
+  manager.packetReceived(
+    buildPacket(
+      args.frameTwoNumber,
+      args.frameTwoStartSequence,
+      FrameMarker.Start,
+      args.frameTwoPayloads[0],
+    ),
+  );
+  manager.packetReceived(
+    buildPacket(
+      args.frameOneNumber,
+      args.frameOneStartSequence + 1,
+      FrameMarker.Final,
+      args.frameOnePayloads[1],
+    ),
+  );
+  manager.packetReceived(
+    buildPacket(
+      args.frameTwoNumber,
+      args.frameTwoStartSequence + 1,
+      FrameMarker.Final,
+      args.frameTwoPayloads[1],
+    ),
+  );
+}

package/src/room/data-track/incoming/IncomingDataTrackManager.ts

@@ -13,7 +13,11 @@ import { DataTrackDepacketizerDropError } from '../depacketizer';
 import { type DataTrackFrame, DataTrackFrameInternal } from '../frame';
 import { DataTrackHandle } from '../handle';
 import { DataTrackPacket } from '../packet';
-import { type DataTrackInfo, type DataTrackSid } from '../types';
+import {
+  type DataTrackInfo,
+  type DataTrackSid,
+  type RemoteDataTrackPipelineOptions,
+} from '../types';
 import { DataTrackSubscribeError } from './errors';
 import IncomingDataTrackPipeline from './pipeline';
 import {
@@ -65,6 +69,7 @@ type Descriptor<S extends SubscriptionState> = {
   info: DataTrackInfo;
   publisherIdentity: Participant['identity'];
   subscription: S;
+  pipelineOptions: RemoteDataTrackPipelineOptions;
 };
 
 type IncomingDataTrackManagerOptions = {
@@ -113,6 +118,19 @@ export default class IncomingDataTrackManager extends (EventEmitter as new () =>
     }
   }
 
+  /** @internal */
+  setPipelineOptions(sid: DataTrackSid, options: RemoteDataTrackPipelineOptions): void {
+    const descriptor = this.descriptors.get(sid);
+    if (!descriptor) {
+      log.warn(`Unknown track ${sid}, cannot set pipeline options.`);
+      return;
+    }
+    descriptor.pipelineOptions = options;
+    if (descriptor.subscription.type === 'active') {
+      descriptor.subscription.pipeline.setOptions(options);
+    }
+  }
+
   /** 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.
    *
@@ -473,6 +491,7 @@ export default class IncomingDataTrackManager extends (EventEmitter as new () =>
       info,
       publisherIdentity,
       subscription: { type: 'none' },
+      pipelineOptions: {},
     };
     this.descriptors.set(descriptor.info.sid, descriptor);
 
@@ -530,6 +549,7 @@ export default class IncomingDataTrackManager extends (EventEmitter as new () =>
           info: descriptor.info,
           publisherIdentity: descriptor.publisherIdentity,
           e2eeManager: this.e2eeManager,
+          pipelineOptions: descriptor.pipelineOptions,
         });
 
         const previousDescriptorSubscription = descriptor.subscription;

package/src/room/data-track/incoming/pipeline.ts

@@ -4,7 +4,7 @@ import { LoggerNames, getLogger } from '../../../logger';
 import DataTrackDepacketizer, { DataTrackDepacketizerDropError } from '../depacketizer';
 import type { DataTrackFrameInternal } from '../frame';
 import { DataTrackPacket } from '../packet';
-import { type DataTrackInfo } from '../types';
+import { type DataTrackInfo, type RemoteDataTrackPipelineOptions } from '../types';
 
 const log = getLogger(LoggerNames.DataTracks);
 
@@ -15,6 +15,7 @@ type Options = {
   info: DataTrackInfo;
   publisherIdentity: string;
   e2eeManager: BaseE2EEManager | null;
+  pipelineOptions?: RemoteDataTrackPipelineOptions;
 };
 
 /**
@@ -27,6 +28,8 @@ export default class IncomingDataTrackPipeline {
 
   private depacketizer: DataTrackDepacketizer;
 
+  private options: RemoteDataTrackPipelineOptions;
+
   /**
    * Creates a new pipeline with the given options.
    */
@@ -44,12 +47,17 @@ export default class IncomingDataTrackPipeline {
     this.publisherIdentity = options.publisherIdentity;
     this.e2eeManager = options.e2eeManager ?? null;
     this.depacketizer = depacketizer;
+    this.options = options.pipelineOptions ?? {};
   }
 
   updateE2eeManager(e2eeManager: BaseE2EEManager | null) {
     this.e2eeManager = e2eeManager;
   }
 
+  setOptions(options: RemoteDataTrackPipelineOptions): void {
+    this.options = options;
+  }
+
   async processPacket(
     packet: DataTrackPacket,
   ): Promise<Throws<DataTrackFrameInternal | null, DataTrackDepacketizerDropError>> {
@@ -74,7 +82,10 @@ export default class IncomingDataTrackPipeline {
   ): Throws<DataTrackFrameInternal | null, DataTrackDepacketizerDropError> {
     let frame: DataTrackFrameInternal | null;
     try {
-      frame = this.depacketizer.push(packet);
+      frame = this.depacketizer.push(packet, {
+        throwOnInterruption: false,
+        maxPartialFrames: this.options.maxPartialFrames,
+      });
     } catch (err) {
       // In a future version, use this to maintain drop statistics.
       // FIXME: is this a good idea?

package/src/room/data-track/outgoing/types.ts

@@ -17,7 +17,8 @@ export type SfuPublishResponseResult =
         | DataTrackPublishError<DataTrackPublishErrorReason.NotAllowed>
         | DataTrackPublishError<DataTrackPublishErrorReason.DuplicateName>
         | DataTrackPublishError<DataTrackPublishErrorReason.InvalidName>
-        | DataTrackPublishError<DataTrackPublishErrorReason.LimitReached>;
+        | DataTrackPublishError<DataTrackPublishErrorReason.LimitReached>
+        | DataTrackPublishError<DataTrackPublishErrorReason.Unknown>;
     };
 
 /** Request sent to the SFU to publish a track. */
@@ -36,7 +37,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

package/src/room/data-track/packet/extensions.ts

@@ -75,9 +75,9 @@ export class DataTrackE2eeExtension extends DataTrackExtension {
 
   keyIndex: number;
 
-  iv: Uint8Array; /* NOTE: According to the rust implementation, this should be 12 bytes long. */
+  iv: NonSharedUint8Array; /* NOTE: According to the rust implementation, this should be 12 bytes long. */
 
-  constructor(keyIndex: number, iv: Uint8Array) {
+  constructor(keyIndex: number, iv: NonSharedUint8Array) {
     super();
     this.keyIndex = keyIndex;
     this.iv = iv;

package/src/room/data-track/packet/index.ts

@@ -300,9 +300,9 @@ export enum FrameMarker {
 export class DataTrackPacket extends Serializable {
   header: DataTrackPacketHeader;
 
-  payload: Uint8Array;
+  payload: NonSharedUint8Array;
 
-  constructor(header: DataTrackPacketHeader, payload: Uint8Array) {
+  constructor(header: DataTrackPacketHeader, payload: NonSharedUint8Array) {
     super();
     this.header = header;
     this.payload = payload;
@@ -349,10 +349,10 @@ export class DataTrackPacket extends Serializable {
       dataView.byteOffset + dataView.byteLength,
     );
 
-    return [new DataTrackPacket(header, new Uint8Array(payload)), dataView.byteLength] as [
-      DataTrackPacket,
-      number,
-    ];
+    return [
+      new DataTrackPacket(header, new Uint8Array(payload) as NonSharedUint8Array),
+      dataView.byteLength,
+    ] as [DataTrackPacket, number];
   }
 
   toJSON() {

package/src/room/data-track/packet/serializable.ts

@@ -10,7 +10,7 @@ export default abstract class Serializable {
   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> {
     const lengthBytes = this.toBinaryLengthBytes();
     const output = new ArrayBuffer(lengthBytes);
     const view = new DataView(output);

package/src/room/data-track/types.ts

@@ -11,6 +11,14 @@ export type DataTrackInfo = {
   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 const DataTrackInfo = {
   from(protocolInfo: ProtocolDataTrackInfo): DataTrackInfo {
     return {

package/src/room/events.ts

@@ -225,7 +225,7 @@ export 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',
 
@@ -489,7 +489,7 @@ export 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',