livekit-client 2.17.1 → 2.17.3

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

@@ -0,0 +1,157 @@
+import { LivekitReasonedError } from '../../errors';
+import { DataTrackPacketizerError, DataTrackPacketizerReason } from '../packetizer';
+
+export enum DataTrackPublishErrorReason {
+  /**
+   * Local participant does not have permission to publish data tracks.
+   *
+   * Ensure the participant's token contains the `canPublishData` grant.
+   */
+  NotAllowed = 0,
+
+  /** A track with the same name is already published by the local participant. */
+  DuplicateName = 1,
+
+  /** Request to publish the track took long to complete. */
+  Timeout = 2,
+
+  /** No additional data tracks can be published by the local participant. */
+  LimitReached = 3,
+
+  /** Cannot publish data track when the room is disconnected. */
+  Disconnected = 4,
+
+  // NOTE: this was introduced by web / there isn't a corresponding case in the rust version.
+  Cancelled = 5,
+}
+
+export class DataTrackPublishError<
+  Reason extends DataTrackPublishErrorReason,
+> extends LivekitReasonedError<Reason> {
+  readonly name = 'DataTrackPublishError';
+
+  reason: Reason;
+
+  reasonName: string;
+
+  constructor(message: string, reason: Reason, options?: { cause?: unknown }) {
+    super(21, message, options);
+    this.reason = reason;
+    this.reasonName = DataTrackPublishErrorReason[reason];
+  }
+
+  static notAllowed() {
+    return new DataTrackPublishError(
+      'Data track publishing unauthorized',
+      DataTrackPublishErrorReason.NotAllowed,
+    );
+  }
+
+  static duplicateName() {
+    return new DataTrackPublishError(
+      'Track name already taken',
+      DataTrackPublishErrorReason.DuplicateName,
+    );
+  }
+
+  static timeout() {
+    return new DataTrackPublishError(
+      'Publish data track timed-out',
+      DataTrackPublishErrorReason.Timeout,
+    );
+  }
+
+  static limitReached() {
+    return new DataTrackPublishError(
+      'Data track publication limit reached',
+      DataTrackPublishErrorReason.LimitReached,
+    );
+  }
+
+  static disconnected() {
+    return new DataTrackPublishError('Room disconnected', DataTrackPublishErrorReason.Disconnected);
+  }
+
+  // NOTE: this was introduced by web / there isn't a corresponding case in the rust version.
+  static cancelled() {
+    return new DataTrackPublishError(
+      'Publish data track cancelled by caller',
+      DataTrackPublishErrorReason.Cancelled,
+    );
+  }
+}
+
+export enum DataTrackPushFrameErrorReason {
+  /** Track is no longer published. */
+  TrackUnpublished = 0,
+  /** Frame was dropped. */
+  // NOTE: this should become a web specific error, the rust version of this "dropped" error means
+  // something different and will be renamed to "QueueFull".
+  Dropped = 1,
+}
+
+export class DataTrackPushFrameError<
+  Reason extends DataTrackPushFrameErrorReason,
+> extends LivekitReasonedError<Reason> {
+  readonly name = 'DataTrackPushFrameError';
+
+  reason: Reason;
+
+  reasonName: string;
+
+  constructor(message: string, reason: Reason, options?: { cause?: unknown }) {
+    super(22, message, options);
+    this.reason = reason;
+    this.reasonName = DataTrackPushFrameErrorReason[reason];
+  }
+
+  static trackUnpublished() {
+    return new DataTrackPushFrameError(
+      'Track is no longer published',
+      DataTrackPushFrameErrorReason.TrackUnpublished,
+    );
+  }
+
+  static dropped(cause: unknown) {
+    return new DataTrackPushFrameError('Frame was dropped', DataTrackPushFrameErrorReason.Dropped, {
+      cause,
+    });
+  }
+}
+
+export enum DataTrackOutgoingPipelineErrorReason {
+  Packetizer = 0,
+  Encryption = 1,
+}
+
+export class DataTrackOutgoingPipelineError<
+  Reason extends DataTrackOutgoingPipelineErrorReason,
+> extends LivekitReasonedError<Reason> {
+  readonly name = 'DataTrackOutgoingPipelineError';
+
+  reason: Reason;
+
+  reasonName: string;
+
+  constructor(message: string, reason: Reason, options?: { cause?: unknown }) {
+    super(21, message, options);
+    this.reason = reason;
+    this.reasonName = DataTrackOutgoingPipelineErrorReason[reason];
+  }
+
+  static packetizer(cause: DataTrackPacketizerError<DataTrackPacketizerReason.MtuTooShort>) {
+    return new DataTrackOutgoingPipelineError(
+      'Error packetizing frame',
+      DataTrackOutgoingPipelineErrorReason.Packetizer,
+      { cause },
+    );
+  }
+
+  static encryption(cause: unknown) {
+    return new DataTrackOutgoingPipelineError(
+      'Error encrypting frame',
+      DataTrackOutgoingPipelineErrorReason.Encryption,
+      { cause },
+    );
+  }
+}

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

@@ -0,0 +1,76 @@
+import { type Throws } from '../../../utils/throws';
+import { type EncryptedPayload, type EncryptionProvider } from '../e2ee';
+import { type DataTrackFrame } from '../frame';
+import { DataTrackPacket } from '../packet';
+import { DataTrackE2eeExtension } from '../packet/extensions';
+import DataTrackPacketizer, { DataTrackPacketizerError } from '../packetizer';
+import type { DataTrackInfo } from '../track';
+import { DataTrackOutgoingPipelineError, DataTrackOutgoingPipelineErrorReason } from './errors';
+
+type Options = {
+  info: DataTrackInfo;
+  encryptionProvider: EncryptionProvider | null;
+};
+
+/** Processes outgoing frames into final packets for distribution to the SFU. */
+export default class DataTrackOutgoingPipeline {
+  private encryptionProvider: EncryptionProvider | null;
+
+  private packetizer: DataTrackPacketizer;
+
+  /** Maximum transmission unit (MTU) of the transport. */
+  private static TRANSPORT_MTU_BYTES = 16_000;
+
+  constructor(options: Options) {
+    this.encryptionProvider = options.encryptionProvider;
+    this.packetizer = new DataTrackPacketizer(
+      options.info.pubHandle,
+      DataTrackOutgoingPipeline.TRANSPORT_MTU_BYTES,
+    );
+  }
+
+  *processFrame(
+    frame: DataTrackFrame,
+  ): Throws<
+    Generator<DataTrackPacket>,
+    | DataTrackOutgoingPipelineError<DataTrackOutgoingPipelineErrorReason.Packetizer>
+    | DataTrackOutgoingPipelineError<DataTrackOutgoingPipelineErrorReason.Encryption>
+  > {
+    const encryptedFrame = this.encryptIfNeeded(frame);
+
+    try {
+      yield* this.packetizer.packetize(encryptedFrame);
+    } catch (error) {
+      if (error instanceof DataTrackPacketizerError) {
+        throw DataTrackOutgoingPipelineError.packetizer(error);
+      }
+      throw error;
+    }
+  }
+
+  encryptIfNeeded(
+    frame: DataTrackFrame,
+  ): Throws<
+    DataTrackFrame,
+    DataTrackOutgoingPipelineError<DataTrackOutgoingPipelineErrorReason.Encryption>
+  > {
+    if (!this.encryptionProvider) {
+      return frame;
+    }
+
+    let encryptedResult: EncryptedPayload;
+    try {
+      encryptedResult = this.encryptionProvider.encrypt(frame.payload);
+    } catch (err) {
+      throw DataTrackOutgoingPipelineError.encryption(err);
+    }
+
+    frame.payload = encryptedResult.payload;
+    frame.extensions.e2ee = new DataTrackE2eeExtension(
+      encryptedResult.keyIndex,
+      encryptedResult.iv,
+    );
+
+    return frame;
+  }
+}

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

@@ -0,0 +1,37 @@
+import { type DataTrackHandle } from '../handle';
+import { type DataTrackInfo } from '../track';
+import { type DataTrackPublishError, type DataTrackPublishErrorReason } from './errors';
+
+/** Options for publishing a data track. */
+export type DataTrackOptions = {
+  name: string;
+};
+
+/** Encodes whether a data track publish request to the SFU has been successful or not. */
+export type SfuPublishResponseResult =
+  | { type: 'ok'; data: DataTrackInfo }
+  | {
+      type: 'error';
+      error:
+        | DataTrackPublishError<DataTrackPublishErrorReason.NotAllowed>
+        | DataTrackPublishError<DataTrackPublishErrorReason.DuplicateName>
+        | DataTrackPublishError<DataTrackPublishErrorReason.LimitReached>;
+    };
+
+/** Request sent to the SFU to publish a track. */
+export type OutputEventSfuPublishRequest = {
+  handle: DataTrackHandle;
+  name: string;
+  usesE2ee: boolean;
+};
+
+/** Request sent to the SFU to unpublish a track. */
+export type OutputEventSfuUnpublishRequest = {
+  handle: DataTrackHandle;
+};
+
+/** Serialized packets are ready to be sent over the transport. */
+export type OutputEventPacketsAvailable = {
+  bytes: Uint8Array;
+  signal?: AbortSignal;
+};

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

@@ -24,7 +24,7 @@ describe('DataTrackPacket', () => {
 
       const payloadBytes = new Uint8Array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);
 
-      const packet = new DataTrackPacket(header, payloadBytes.buffer);
+      const packet = new DataTrackPacket(header, payloadBytes);
 
       expect(packet.toBinaryLengthBytes()).toStrictEqual(22);
       expect(packet.toBinary()).toStrictEqual(
@@ -70,7 +70,7 @@ describe('DataTrackPacket', () => {
 
       const payloadBytes = new Uint8Array(32).fill(0xfa);
 
-      const packet = new DataTrackPacket(header, payloadBytes.buffer);
+      const packet = new DataTrackPacket(header, payloadBytes);
 
       expect(packet.toBinaryLengthBytes()).toStrictEqual(78);
       expect(packet.toBinary()).toStrictEqual(
@@ -176,7 +176,7 @@ describe('DataTrackPacket', () => {
 
       const payloadBytes = new Uint8Array(32).fill(0xfa);
 
-      const packet = new DataTrackPacket(header, payloadBytes.buffer);
+      const packet = new DataTrackPacket(header, payloadBytes);
 
       expect(packet.toBinaryLengthBytes()).toStrictEqual(66);
       expect(packet.toBinary()).toStrictEqual(
@@ -264,7 +264,7 @@ describe('DataTrackPacket', () => {
         timestamp: DataTrackTimestamp.fromRtpTicks(104),
       });
       const payloadBytes = new Uint8Array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);
-      const packet = new DataTrackPacket(header, payloadBytes.buffer);
+      const packet = new DataTrackPacket(header, payloadBytes);
 
       const twoByteLongDataView = new DataView(new ArrayBuffer(2));
       expect(() => packet.toBinaryInto(twoByteLongDataView)).toThrow('Buffer cannot fit header');
@@ -278,7 +278,7 @@ describe('DataTrackPacket', () => {
         timestamp: DataTrackTimestamp.fromRtpTicks(104),
       });
       const payloadBytes = new Uint8Array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);
-      const packet = new DataTrackPacket(header, payloadBytes.buffer);
+      const packet = new DataTrackPacket(header, payloadBytes);
 
       const fourteenByteLongDataView = new DataView(
         new ArrayBuffer(14 /* 12 byte header + 2 extra bytes */),
@@ -333,7 +333,7 @@ describe('DataTrackPacket', () => {
             userTimestamp: null,
           },
         },
-        payload: new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8, 9]).buffer,
+        payload: new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8, 9]),
       });
     });
 
@@ -406,7 +406,7 @@ describe('DataTrackPacket', () => {
             userTimestamp: null,
           },
         },
-        payload: new Uint8Array([]).buffer,
+        payload: new Uint8Array([]),
       });
     });
 
@@ -563,7 +563,7 @@ describe('DataTrackPacket', () => {
 
       const payloadBytes = new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8, 9]);
 
-      const encodedPacket = new DataTrackPacket(header, payloadBytes.buffer);
+      const encodedPacket = new DataTrackPacket(header, payloadBytes);
 
       expect(encodedPacket.toBinaryLengthBytes()).toStrictEqual(21);
       expect(encodedPacket.toBinary()).toStrictEqual(
@@ -608,7 +608,7 @@ describe('DataTrackPacket', () => {
             userTimestamp: null,
           },
         },
-        payload: new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8, 9]).buffer,
+        payload: new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8, 9]),
       });
     });
   });

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

@@ -126,7 +126,7 @@ export class DataTrackPacketHeader extends Serializable {
     dataView.setUint8(byteIndex, 0); // Reserved
     byteIndex += U8_LENGTH_BYTES;
 
-    dataView.setUint16(byteIndex, this.trackHandle.value);
+    dataView.setUint16(byteIndex, this.trackHandle);
     byteIndex += U16_LENGTH_BYTES;
     dataView.setUint16(byteIndex, this.sequence.value);
     byteIndex += U16_LENGTH_BYTES;
@@ -277,10 +277,10 @@ export class DataTrackPacketHeader extends Serializable {
   toJSON() {
     return {
       marker: this.marker,
-      trackHandle: this.trackHandle.value,
+      trackHandle: this.trackHandle,
       sequence: this.sequence.value,
       frameNumber: this.frameNumber.value,
-      timestamp: this.timestamp.timestamp,
+      timestamp: this.timestamp.asTicks(),
       extensions: this.extensions.toJSON(),
     };
   }
@@ -302,9 +302,9 @@ export enum FrameMarker {
 export class DataTrackPacket extends Serializable {
   header: DataTrackPacketHeader;
 
-  payload: ArrayBuffer;
+  payload: Uint8Array;
 
-  constructor(header: DataTrackPacketHeader, payload: ArrayBuffer) {
+  constructor(header: DataTrackPacketHeader, payload: Uint8Array) {
     super();
     this.header = header;
     this.payload = payload;
@@ -323,9 +323,8 @@ export class DataTrackPacket extends Serializable {
       throw DataTrackSerializeError.tooSmallForPayload();
     }
 
-    const payloadBytes = new Uint8Array(this.payload);
-    for (let index = 0; index < payloadBytes.length; index += 1) {
-      dataView.setUint8(byteIndex, payloadBytes[index]);
+    for (let index = 0; index < this.payload.length; index += 1) {
+      dataView.setUint8(byteIndex, this.payload[index]);
       byteIndex += U8_LENGTH_BYTES;
     }
 
@@ -352,7 +351,10 @@ export class DataTrackPacket extends Serializable {
       dataView.byteOffset + dataView.byteLength,
     );
 
-    return [new DataTrackPacket(header, payload), dataView.byteLength] as [DataTrackPacket, number];
+    return [new DataTrackPacket(header, new Uint8Array(payload)), dataView.byteLength] as [
+      DataTrackPacket,
+      number,
+    ];
   }
 
   toJSON() {

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

@@ -24,6 +24,6 @@ export default abstract class Serializable {
       );
     }
 
-    return new Uint8Array(output); // FIXME: return uint8array here? Or the arraybuffer?
+    return new Uint8Array(output);
   }
 }

package/src/room/data-track/packetizer.test.ts

@@ -0,0 +1,131 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { DataTrackFrame } from './frame';
+import { DataTrackHandle } from './handle';
+import { FrameMarker } from './packet';
+import { DataTrackExtensions } from './packet/extensions';
+import DataTrackPacketizer from './packetizer';
+import { DataTrackTimestamp } from './utils';
+
+describe('DataTrackPacketizer', () => {
+  it('should packetize a large payload properly', () => {
+    const packetizer = new DataTrackPacketizer(DataTrackHandle.fromNumber(1), 100);
+    const packets = Array.from(
+      packetizer.packetize(
+        {
+          payload: new Uint8Array(300).fill(0xbe),
+          extensions: new DataTrackExtensions(),
+        },
+        { now: DataTrackTimestamp.fromRtpTicks(1804548298) },
+      ),
+    );
+
+    expect(packets.map((packet) => packet.toJSON())).toStrictEqual([
+      {
+        header: {
+          extensions: {
+            e2ee: null,
+            userTimestamp: null,
+          },
+          frameNumber: 0,
+          marker: FrameMarker.Start,
+          sequence: 0,
+          timestamp: 1804548298,
+          trackHandle: 1,
+        },
+        payload: new Uint8Array(88).fill(0xbe),
+      },
+      {
+        header: {
+          extensions: {
+            e2ee: null,
+            userTimestamp: null,
+          },
+          frameNumber: 0,
+          marker: FrameMarker.Inter,
+          sequence: 1,
+          timestamp: 1804548298,
+          trackHandle: 1,
+        },
+        payload: new Uint8Array(88).fill(0xbe),
+      },
+      {
+        header: {
+          extensions: {
+            e2ee: null,
+            userTimestamp: null,
+          },
+          frameNumber: 0,
+          marker: FrameMarker.Inter,
+          sequence: 2,
+          timestamp: 1804548298,
+          trackHandle: 1,
+        },
+        payload: new Uint8Array(88).fill(0xbe),
+      },
+      {
+        header: {
+          extensions: {
+            e2ee: null,
+            userTimestamp: null,
+          },
+          frameNumber: 0,
+          marker: FrameMarker.Final,
+          sequence: 3,
+          timestamp: 1804548298,
+          trackHandle: 1,
+        },
+        payload: new Uint8Array(36 /* 300 total bytes - (88 bytes * 3 full length packets) */).fill(
+          0xbe,
+        ),
+      },
+    ]);
+  });
+
+  it.each([
+    [0, 1_024, 'zero payload'],
+    [128, 1_024, 'single packet'],
+    [20_480, 1_024, 'multi packet'],
+    [40_960, 16_000, 'multi packet mtu 16000'],
+  ])('should test packetizer edge cases', (payloadSizeBytes, mtuSizeBytes, label) => {
+    const packetizer = new DataTrackPacketizer(DataTrackHandle.fromNumber(1), mtuSizeBytes);
+
+    const frame: DataTrackFrame = {
+      payload: new Uint8Array(payloadSizeBytes).fill(0xab),
+      extensions: new DataTrackExtensions(),
+    };
+    const packets = Array.from(
+      packetizer.packetize(frame, {
+        now: DataTrackTimestamp.fromRtpTicks(0),
+      }),
+    );
+
+    if (packets.length === 0) {
+      expect(payloadSizeBytes, `${label}: Should be no packets for zero payload`).toStrictEqual(0);
+    }
+
+    let index = 0;
+    for (const packet of packets) {
+      const packetHeaderJson = packet.header.toJSON();
+      expect(packetHeaderJson.marker).toStrictEqual(
+        DataTrackPacketizer.computeFrameMarker(index, packets.length),
+      );
+      expect(packetHeaderJson.frameNumber).toStrictEqual(0);
+      expect(packetHeaderJson.trackHandle).toStrictEqual(1);
+      expect(packetHeaderJson.sequence).toStrictEqual(index);
+      expect(packetHeaderJson.extensions).toStrictEqual(frame.extensions.toJSON());
+      index += 1;
+    }
+  });
+
+  it.each([
+    [0, 1, FrameMarker.Single],
+    [0, 10, FrameMarker.Start],
+    [4, 10, FrameMarker.Inter],
+    [9, 10, FrameMarker.Final],
+  ])('should test frame marker utility function', (index, packetCount, expectedMarker) => {
+    expect(DataTrackPacketizer.computeFrameMarker(index, packetCount)).toStrictEqual(
+      expectedMarker,
+    );
+  });
+});

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

@@ -0,0 +1,132 @@
+import type { Throws } from '../../utils/throws';
+import { LivekitReasonedError } from '../errors';
+import { type DataTrackFrame } from './frame';
+import { DataTrackHandle } from './handle';
+import { DataTrackPacket, DataTrackPacketHeader, FrameMarker } from './packet';
+import { DataTrackClock, DataTrackTimestamp, WrapAroundUnsignedInt } from './utils';
+
+type PacketizeOptions = {
+  /** "now" timestamp to use as a base when generating new packet timestamps. If not specified,
+   * defaults to the return value of {@link DataTrackClock#now}. */
+  now?: DataTrackTimestamp<90_000>;
+};
+
+export class DataTrackPacketizerError<
+  Reason extends DataTrackPacketizerReason,
+> extends LivekitReasonedError<Reason> {
+  readonly name = 'DataTrackPacketizerError';
+
+  reason: Reason;
+
+  reasonName: string;
+
+  constructor(message: string, reason: Reason, options?: { cause?: unknown }) {
+    super(19, message, options);
+    this.reason = reason;
+    this.reasonName = DataTrackPacketizerReason[reason];
+  }
+
+  static mtuTooShort() {
+    return new DataTrackPacketizerError(
+      'MTU is too short to send frame',
+      DataTrackPacketizerReason.MtuTooShort,
+    );
+  }
+}
+
+export enum DataTrackPacketizerReason {
+  MtuTooShort = 0,
+}
+
+/** A packetizer takes a {@link DataTrackFrame} as input and generates a series
+ * of {@link DataTrackPacket}s for transmission to other clients over webrtc. */
+export default class DataTrackPacketizer {
+  private handle: DataTrackHandle;
+
+  private mtuSizeBytes: number;
+
+  private sequence = WrapAroundUnsignedInt.u16(0);
+
+  private frameNumber = WrapAroundUnsignedInt.u16(0);
+
+  private clock = DataTrackClock.rtpStartingNow(DataTrackTimestamp.rtpRandom());
+
+  constructor(trackHandle: DataTrackHandle, mtuSizeBytes: number) {
+    this.handle = trackHandle;
+    this.mtuSizeBytes = mtuSizeBytes;
+  }
+
+  /** @internal */
+  static computeFrameMarker(index: number, packetCount: number) {
+    if (packetCount <= 1) {
+      return FrameMarker.Single;
+    }
+    if (index === 0) {
+      return FrameMarker.Start;
+    } else if (index === packetCount - 1) {
+      return FrameMarker.Final;
+    } else {
+      return FrameMarker.Inter;
+    }
+  }
+
+  /** Generates a series of packets for the specified {@link DataTrackPacketizerFrame}.
+   *
+   * NOTE: The return value of this function is a generator, so it can be lazily ran if desired,
+   * or converted to an array with {@link Array.from}.
+   */
+  *packetize(
+    frame: DataTrackFrame,
+    options?: PacketizeOptions,
+  ): Throws<
+    Generator<DataTrackPacket>,
+    DataTrackPacketizerError<DataTrackPacketizerReason.MtuTooShort>
+  > {
+    const frameNumber = this.frameNumber.getThenIncrement();
+    const headerParams = {
+      marker: FrameMarker.Inter,
+      trackHandle: this.handle,
+      sequence: WrapAroundUnsignedInt.u16(0),
+      frameNumber,
+      timestamp: options?.now ?? this.clock.now(),
+      extensions: frame.extensions,
+    };
+    const headerSerializedLengthBytes = new DataTrackPacketHeader(
+      headerParams,
+    ).toBinaryLengthBytes();
+    if (headerSerializedLengthBytes >= this.mtuSizeBytes) {
+      throw DataTrackPacketizerError.mtuTooShort();
+    }
+
+    const maxPayloadSizeBytes = this.mtuSizeBytes - headerSerializedLengthBytes;
+
+    const packetCount = Math.ceil(frame.payload.byteLength / maxPayloadSizeBytes);
+
+    for (
+      let index = 0, indexBytes = 0;
+      indexBytes < frame.payload.byteLength;
+      [index, indexBytes] = [index + 1, indexBytes + maxPayloadSizeBytes]
+    ) {
+      const sequence = this.sequence.getThenIncrement();
+      const packetHeader = new DataTrackPacketHeader({
+        ...headerParams,
+        marker: DataTrackPacketizer.computeFrameMarker(index, packetCount),
+        sequence,
+      });
+
+      const packetPayloadLengthBytes = Math.min(
+        // All but the last packet will be max length ...
+        maxPayloadSizeBytes,
+        // ... and the last packet will be as long as it needs to be to finish out the buffer.
+        frame.payload.byteLength - indexBytes,
+      );
+      const packetPayload = new Uint8Array(
+        frame.payload.buffer,
+        frame.payload.byteOffset + indexBytes,
+        packetPayloadLengthBytes,
+      );
+
+      yield new DataTrackPacket(packetHeader, packetPayload);
+    }
+  }
+}