livekit-client 2.18.9 → 2.19.0

package/src/e2ee/types.ts

@@ -1,4 +1,6 @@
 import type { LogLevel } from '../logger';
+import type { PacketTrailerFramePayload } from '../packetTrailer/packetTrailer';
+import type { PacketTrailerPublishOptions } from '../packetTrailer/types';
 import type { VideoCodec } from '../room/track/options';
 import type { BaseE2EEManager } from './E2eeManager';
 import type { BaseKeyProvider } from './KeyProvider';
@@ -38,7 +40,7 @@ export interface RTPVideoMapMessage extends BaseMessage {
 export interface SifTrailerMessage extends BaseMessage {
   kind: 'setSifTrailer';
   data: {
-    trailer: Uint8Array;
+    trailer: NonSharedUint8Array;
   };
 }
 
@@ -51,6 +53,16 @@ export interface EncodeMessage extends BaseMessage {
     trackId: string;
     codec?: VideoCodec;
     isReuse: boolean;
+    /**
+     * Whether the published track advertises packet trailer features.
+     * When false, the cryptor skips the per-frame trailer extraction path
+     * entirely on decode.
+     */
+    hasPacketTrailer: boolean;
+    /**
+     * Packet trailer metadata to append on published video frames.
+     */
+    packetTrailer?: PacketTrailerPublishOptions;
   };
 }
 
@@ -68,6 +80,7 @@ export interface UpdateCodecMessage extends BaseMessage {
     participantIdentity: string;
     trackId: string;
     codec: VideoCodec;
+    hasPacketTrailer: boolean;
   };
 }
 
@@ -116,8 +129,8 @@ export interface DecryptDataRequestMessage extends BaseMessage {
   kind: 'decryptDataRequest';
   data: {
     uuid: string;
-    payload: Uint8Array;
-    iv: Uint8Array;
+    payload: NonSharedUint8Array;
+    iv: NonSharedUint8Array;
     participantIdentity: string;
     keyIndex: number;
   };
@@ -127,7 +140,7 @@ export interface DecryptDataResponseMessage extends BaseMessage {
   kind: 'decryptDataResponse';
   data: {
     uuid: string;
-    payload: Uint8Array;
+    payload: NonSharedUint8Array;
   };
 }
 
@@ -135,7 +148,7 @@ export interface EncryptDataRequestMessage extends BaseMessage {
   kind: 'encryptDataRequest';
   data: {
     uuid: string;
-    payload: Uint8Array;
+    payload: NonSharedUint8Array;
     participantIdentity: string;
   };
 }
@@ -144,12 +157,17 @@ export interface EncryptDataResponseMessage extends BaseMessage {
   kind: 'encryptDataResponse';
   data: {
     uuid: string;
-    payload: Uint8Array;
-    iv: Uint8Array;
+    payload: NonSharedUint8Array;
+    iv: NonSharedUint8Array;
     keyIndex: number;
   };
 }
 
+export interface PTMetadataFromE2EEMessage extends BaseMessage {
+  kind: 'packetTrailerMetadata';
+  data: PacketTrailerFramePayload;
+}
+
 export type E2EEWorkerMessage =
   | InitMessage
   | SetKeyMessage
@@ -166,7 +184,8 @@ export type E2EEWorkerMessage =
   | DecryptDataRequestMessage
   | DecryptDataResponseMessage
   | EncryptDataRequestMessage
-  | EncryptDataResponseMessage;
+  | EncryptDataResponseMessage
+  | PTMetadataFromE2EEMessage;
 
 export type KeySet = { material: CryptoKey; encryptionKey: CryptoKey };
 
@@ -221,4 +240,14 @@ export type ScriptTransformOptions = {
   participantIdentity: string;
   trackId: string;
   codec?: VideoCodec;
+  /**
+   * Whether the published track advertises packet trailer features.
+   * When false, the cryptor skips the per-frame trailer extraction path
+   * entirely on decode.
+   */
+  hasPacketTrailer: boolean;
+  /**
+   * Packet trailer metadata to append on published video frames.
+   */
+  packetTrailer?: PacketTrailerPublishOptions;
 };

package/src/e2ee/utils.ts

@@ -8,11 +8,12 @@ export function isE2EESupported() {
 
 export function isScriptTransformSupported() {
   // @ts-ignore
-  return typeof window.RTCRtpScriptTransform !== 'undefined';
+  return typeof window !== 'undefined' && typeof window.RTCRtpScriptTransform !== 'undefined';
 }
 
 export function isInsertableStreamSupported() {
   return (
+    typeof window !== 'undefined' &&
     typeof window.RTCRtpSender !== 'undefined' &&
     // @ts-ignore
     typeof window.RTCRtpSender.prototype.createEncodedStreams !== 'undefined'
@@ -26,7 +27,7 @@ export function isVideoFrame(
 }
 
 export async function importKey(
-  keyBytes: Uint8Array | ArrayBuffer,
+  keyBytes: NonSharedUint8Array | ArrayBuffer,
   algorithm: string | { name: string } = { name: ENCRYPTION_ALGORITHM },
   usage: 'derive' | 'encrypt' = 'encrypt',
 ) {
@@ -112,7 +113,7 @@ export async function deriveKeys(material: CryptoKey, options: KeyProviderOption
   return { material, encryptionKey };
 }
 
-export function createE2EEKey(): Uint8Array {
+export function createE2EEKey(): NonSharedUint8Array {
   return window.crypto.getRandomValues(new Uint8Array(32));
 }
 
@@ -127,14 +128,14 @@ export async function ratchet(material: CryptoKey, salt: string): Promise<ArrayB
   return crypto.subtle.deriveBits(algorithmOptions, material, 256);
 }
 
-export function needsRbspUnescaping(frameData: Uint8Array) {
+export function needsRbspUnescaping(frameData: NonSharedUint8Array) {
   for (var i = 0; i < frameData.length - 3; i++) {
     if (frameData[i] == 0 && frameData[i + 1] == 0 && frameData[i + 2] == 3) return true;
   }
   return false;
 }
 
-export function parseRbsp(stream: Uint8Array): Uint8Array {
+export function parseRbsp(stream: NonSharedUint8Array): NonSharedUint8Array {
   const dataOut: number[] = [];
   var length = stream.length;
   for (var i = 0; i < stream.length; ) {
@@ -159,7 +160,7 @@ export function parseRbsp(stream: Uint8Array): Uint8Array {
 const kZerosInStartSequence = 2;
 const kEmulationByte = 3;
 
-export function writeRbsp(data_in: Uint8Array): Uint8Array {
+export function writeRbsp(data_in: NonSharedUint8Array): NonSharedUint8Array {
   const dataOut: number[] = [];
   var numConsecutiveZeros = 0;
   for (var i = 0; i < data_in.length; ++i) {

package/src/e2ee/worker/DataCryptor.ts

@@ -21,11 +21,11 @@ export class DataCryptor {
   }
 
   static async encrypt(
-    data: Uint8Array,
+    data: NonSharedUint8Array,
     keys: ParticipantKeyHandler,
   ): Promise<{
-    payload: Uint8Array;
-    iv: Uint8Array;
+    payload: NonSharedUint8Array;
+    iv: NonSharedUint8Array;
     keyIndex: number;
   }> {
     const iv = DataCryptor.makeIV(performance.now());
@@ -51,14 +51,14 @@ export class DataCryptor {
   }
 
   static async decrypt(
-    data: Uint8Array,
-    iv: Uint8Array,
+    data: NonSharedUint8Array,
+    iv: NonSharedUint8Array,
     keys: ParticipantKeyHandler,
     keyIndex: number = 0,
     initialMaterial?: KeySet,
     ratchetOpts: DecodeRatchetOptions = { ratchetCount: 0 },
   ): Promise<{
-    payload: Uint8Array;
+    payload: NonSharedUint8Array;
   }> {
     const keySet = await keys.getKeySet(keyIndex);
     if (!keySet) {

package/src/e2ee/worker/FrameCryptor.test.ts

@@ -1,4 +1,6 @@
 import { afterEach, describe, expect, it, vitest } from 'vitest';
+import { appendPacketTrailer, extractPacketTrailer } from '../../packetTrailer/packetTrailer';
+import type { PacketTrailerPublishOptions } from '../../packetTrailer/types';
 import { IV_LENGTH, KEY_PROVIDER_DEFAULTS } from '../constants';
 import { CryptorEvent } from '../events';
 import type { KeyProviderOptions } from '../types';
@@ -13,7 +15,7 @@ function mockEncryptedRTCEncodedVideoFrame(keyIndex: number): RTCEncodedVideoFra
   return mockRTCEncodedVideoFrame(data);
 }
 
-function mockRTCEncodedVideoFrame(data: Uint8Array): RTCEncodedVideoFrame {
+function mockRTCEncodedVideoFrame(data: NonSharedUint8Array): RTCEncodedVideoFrame {
   return {
     data: data.buffer,
     timestamp: vitest.getMockedSystemTime()?.getTime() ?? 0,
@@ -24,7 +26,7 @@ function mockRTCEncodedVideoFrame(data: Uint8Array): RTCEncodedVideoFrame {
   };
 }
 
-function mockFrameTrailer(keyIndex: number): Uint8Array {
+function mockFrameTrailer(keyIndex: number): NonSharedUint8Array {
   const frameTrailer = new Uint8Array(2);
 
   frameTrailer[0] = IV_LENGTH;
@@ -67,14 +69,21 @@ function prepareParticipantTestDecoder(
 function prepareParticipantTestEncoder(
   participantIdentity: string,
   partialKeyProviderOptions: Partial<KeyProviderOptions>,
+  packetTrailer?: PacketTrailerPublishOptions,
 ) {
-  return prepareParticipantTest('encode', participantIdentity, partialKeyProviderOptions);
+  return prepareParticipantTest(
+    'encode',
+    participantIdentity,
+    partialKeyProviderOptions,
+    packetTrailer,
+  );
 }
 
 function prepareParticipantTest(
   mode: 'encode' | 'decode',
   participantIdentity: string,
   partialKeyProviderOptions: Partial<KeyProviderOptions>,
+  packetTrailer?: PacketTrailerPublishOptions,
 ): {
   keys: ParticipantKeyHandler;
   cryptor: FrameCryptor;
@@ -95,7 +104,15 @@ function prepareParticipantTest(
 
   const input = new TestUnderlyingSource<RTCEncodedVideoFrame>();
   const output = new TestUnderlyingSink<RTCEncodedVideoFrame>();
-  cryptor.setupTransform(mode, new ReadableStream(input), new WritableStream(output), 'testTrack');
+  cryptor.setupTransform(
+    mode,
+    new ReadableStream(input),
+    new WritableStream(output),
+    'testTrack',
+    false,
+    undefined,
+    packetTrailer,
+  );
 
   return { keys, cryptor, input, output };
 }
@@ -215,6 +232,127 @@ describe('FrameCryptor', () => {
         vitest.useRealTimers();
       }
     });
+
+    it('appends packet trailer after encryption', async () => {
+      vitest.useFakeTimers();
+      const now = new Date('2025-04-10T12:00:00.123Z');
+      vitest.setSystemTime(now);
+      try {
+        const { keys, input, output } = prepareParticipantTestEncoder(
+          participantIdentity,
+          {},
+          { timestamp: true, frameId: true },
+        );
+
+        await keys.setKey(await createKeyMaterialFromString('key1'), 1);
+
+        const frame = mockRTCEncodedVideoFrame(
+          new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]),
+        );
+
+        input.write(frame);
+        await vitest.waitFor(() => expect(output.chunks).toHaveLength(1));
+
+        const extracted = extractPacketTrailer(frame.data);
+        expect(extracted.metadata?.userTimestamp).toBeGreaterThanOrEqual(
+          BigInt(now.getTime()) * BigInt(1000),
+        );
+        expect(extracted.metadata?.frameId).toBe(1);
+
+        const frameTrailer = new Uint8Array(
+          extracted.data.buffer.slice(extracted.data.byteLength - 2),
+        );
+        expect(frameTrailer[0]).toEqual(IV_LENGTH);
+        expect(frameTrailer[1]).toEqual(1);
+      } finally {
+        vitest.useRealTimers();
+      }
+    });
+
+    it('does not append packet trailer after encryption when no trailer features are enabled', async () => {
+      vitest.useFakeTimers();
+      try {
+        const { keys, input, output } = prepareParticipantTestEncoder(
+          participantIdentity,
+          {},
+          { timestamp: false, frameId: false },
+        );
+
+        await keys.setKey(await createKeyMaterialFromString('key1'), 1);
+
+        const frame = mockRTCEncodedVideoFrame(
+          new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]),
+        );
+
+        input.write(frame);
+        await vitest.waitFor(() => expect(output.chunks).toHaveLength(1));
+
+        const extracted = extractPacketTrailer(frame.data);
+        expect(extracted.metadata).toBeUndefined();
+        expect(extracted.data.byteLength).toBe(frame.data.byteLength);
+
+        const frameTrailer = new Uint8Array(frame.data.slice(frame.data.byteLength - 2));
+        expect(frameTrailer[0]).toEqual(IV_LENGTH);
+        expect(frameTrailer[1]).toEqual(1);
+      } finally {
+        vitest.useRealTimers();
+      }
+    });
+
+    it('appends only timestamp packet trailer metadata after encryption', async () => {
+      vitest.useFakeTimers();
+      const now = new Date('2025-04-10T12:00:00.123Z');
+      vitest.setSystemTime(now);
+      try {
+        const { keys, input, output } = prepareParticipantTestEncoder(
+          participantIdentity,
+          {},
+          { timestamp: true },
+        );
+
+        await keys.setKey(await createKeyMaterialFromString('key1'), 1);
+
+        const frame = mockRTCEncodedVideoFrame(
+          new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]),
+        );
+
+        input.write(frame);
+        await vitest.waitFor(() => expect(output.chunks).toHaveLength(1));
+
+        const extracted = extractPacketTrailer(frame.data);
+        expect(frame.data.byteLength - extracted.data.byteLength).toBe(15);
+        expect(extracted.metadata?.userTimestamp).toBeGreaterThanOrEqual(
+          BigInt(now.getTime()) * BigInt(1000),
+        );
+        expect(extracted.metadata?.frameId).toBe(0);
+      } finally {
+        vitest.useRealTimers();
+      }
+    });
+
+    it('appends only frame id packet trailer metadata after encryption', async () => {
+      const { keys, input, output } = prepareParticipantTestEncoder(
+        participantIdentity,
+        {},
+        { frameId: true },
+      );
+
+      await keys.setKey(await createKeyMaterialFromString('key1'), 1);
+
+      const frame = mockRTCEncodedVideoFrame(
+        new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]),
+      );
+
+      input.write(frame);
+      await vitest.waitFor(() => expect(output.chunks).toHaveLength(1));
+
+      const extracted = extractPacketTrailer(frame.data);
+      expect(frame.data.byteLength - extracted.data.byteLength).toBe(11);
+      expect(extracted.metadata).toEqual({
+        userTimestamp: BigInt(0),
+        frameId: 1,
+      });
+    });
   });
 
   describe('decode', () => {
@@ -391,6 +529,41 @@ describe('FrameCryptor', () => {
       }
     });
 
+    it('posts packet trailer metadata when the advertised trailer path is active', async () => {
+      vitest.useFakeTimers();
+      try {
+        const { cryptor, input, output } = prepareParticipantTestDecoder(participantIdentity, {});
+        const postMessage = vitest.fn();
+        vitest.stubGlobal('postMessage', postMessage);
+        encryptionEnabledMap.set(participantIdentity, false);
+        cryptor.setHasPacketTrailer(true);
+
+        const payload = Uint8Array.from([1, 2, 3, 4]);
+        const trailer = appendPacketTrailer(payload, 1_744_249_600_123_456n, 0);
+        const frame = mockRTCEncodedVideoFrame(trailer);
+
+        input.write(frame);
+        await vitest.advanceTimersToNextTimerAsync();
+
+        expect(new Uint8Array(output.chunks[0].data)).toEqual(payload);
+        expect(postMessage).toHaveBeenCalledWith({
+          kind: 'packetTrailerMetadata',
+          data: {
+            trackId: 'testTrack',
+            rtpTimestamp: frame.timestamp,
+            ssrc: 0,
+            metadata: {
+              userTimestamp: 1_744_249_600_123_456n,
+              frameId: 0,
+            },
+          },
+        });
+      } finally {
+        vitest.unstubAllGlobals();
+        vitest.useRealTimers();
+      }
+    });
+
     it('recovers from delayed use of rotated key', async () => {
       vitest.useFakeTimers();
       try {

package/src/e2ee/worker/FrameCryptor.ts

@@ -1,13 +1,24 @@
-/* eslint-disable @typescript-eslint/no-unused-vars */
 // TODO code inspired by https://github.com/webrtc/samples/blob/gh-pages/src/content/insertable-streams/endtoend-encryption/js/worker.js
 import { EventEmitter } from 'events';
 import type TypedEventEmitter from 'typed-emitter';
 import { workerLogger } from '../../logger';
+import {
+  appendPacketTrailerToEncodedFrame,
+  processPacketTrailer,
+} from '../../packetTrailer/packetTrailer';
+import type { PacketTrailerPublishOptions } from '../../packetTrailer/types';
+import { hasPacketTrailerPublishOptions } from '../../packetTrailer/utils';
 import type { VideoCodec } from '../../room/track/options';
 import { ENCRYPTION_ALGORITHM, IV_LENGTH, UNENCRYPTED_BYTES } from '../constants';
 import { CryptorError, CryptorErrorReason } from '../errors';
 import { type CryptorCallbacks, CryptorEvent } from '../events';
-import type { DecodeRatchetOptions, KeyProviderOptions, KeySet, RatchetResult } from '../types';
+import type {
+  DecodeRatchetOptions,
+  KeyProviderOptions,
+  KeySet,
+  PTMetadataFromE2EEMessage,
+  RatchetResult,
+} from '../types';
 import { deriveKeys, isVideoFrame, needsRbspUnescaping, parseRbsp, writeRbsp } from '../utils';
 import type { ParticipantKeyHandler } from './ParticipantKeyHandler';
 import { processNALUsForEncryption } from './naluUtils';
@@ -65,12 +76,23 @@ export class FrameCryptor extends BaseFrameCryptor {
   /**
    * used for detecting server injected unencrypted frames
    */
-  private sifTrailer: Uint8Array;
+  private sifTrailer: NonSharedUint8Array;
 
   private detectedCodec?: VideoCodec;
 
   private currentTransform?: TransformerInfo;
 
+  /**
+   * 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: boolean = false;
+
+  private packetTrailer?: PacketTrailerPublishOptions;
+
+  private packetTrailerFrameId = 0;
+
   /**
    * Throttling mechanism for decryption errors to prevent memory leaks
    */
@@ -88,7 +110,7 @@ export class FrameCryptor extends BaseFrameCryptor {
     keys: ParticipantKeyHandler;
     participantIdentity: string;
     keyProviderOptions: KeyProviderOptions;
-    sifTrailer?: Uint8Array;
+    sifTrailer?: NonSharedUint8Array;
   }) {
     super();
     this.sendCounts = new Map();
@@ -178,6 +200,20 @@ export class FrameCryptor extends BaseFrameCryptor {
     this.rtpMap = map;
   }
 
+  /**
+   * 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) {
+    this.hasPacketTrailer = hasPacketTrailer;
+  }
+
+  setPacketTrailer(packetTrailer?: PacketTrailerPublishOptions) {
+    this.packetTrailer = packetTrailer;
+    this.packetTrailerFrameId = 0;
+  }
+
   setupTransform(
     operation: 'encode' | 'decode',
     readable: ReadableStream<RTCEncodedVideoFrame | RTCEncodedAudioFrame>,
@@ -185,11 +221,15 @@ export class FrameCryptor extends BaseFrameCryptor {
     trackId: string,
     isReuse: boolean,
     codec?: VideoCodec,
+    packetTrailer?: PacketTrailerPublishOptions,
   ) {
     if (codec) {
       workerLogger.info('setting codec on cryptor to', { codec });
       this.videoCodec = codec;
     }
+    if (operation === 'encode') {
+      this.setPacketTrailer(packetTrailer);
+    }
 
     workerLogger.debug('Setting up frame cryptor transform', {
       operation,
@@ -262,7 +302,7 @@ export class FrameCryptor extends BaseFrameCryptor {
       });
   }
 
-  setSifTrailer(trailer: Uint8Array) {
+  setSifTrailer(trailer: NonSharedUint8Array) {
     workerLogger.debug('setting SIF trailer', { ...this.logContext, trailer });
     this.sifTrailer = trailer;
   }
@@ -353,11 +393,13 @@ export class FrameCryptor extends BaseFrameCryptor {
     encodedFrame: RTCEncodedVideoFrame | RTCEncodedAudioFrame,
     controller: TransformStreamDefaultController,
   ) {
-    if (
-      !this.isEnabled() ||
-      // skip for encryption for empty dtx frames
-      encodedFrame.data.byteLength === 0
-    ) {
+    // skip for encryption and packet trailer writes for empty dtx frames
+    if (encodedFrame.data.byteLength === 0) {
+      return controller.enqueue(encodedFrame);
+    }
+
+    if (!this.isEnabled()) {
+      this.appendPacketTrailer(encodedFrame);
       return controller.enqueue(encodedFrame);
     }
     const keySet = this.keys.getKeySet();
@@ -410,7 +452,7 @@ export class FrameCryptor extends BaseFrameCryptor {
           new Uint8Array(encodedFrame.data, frameInfo.unencryptedBytes),
         );
 
-        let newDataWithoutHeader = new Uint8Array(
+        let newDataWithoutHeader: NonSharedUint8Array = new Uint8Array(
           cipherText.byteLength + iv.byteLength + frameTrailer.byteLength,
         );
         newDataWithoutHeader.set(new Uint8Array(cipherText)); // add ciphertext.
@@ -426,6 +468,7 @@ export class FrameCryptor extends BaseFrameCryptor {
         newData.set(newDataWithoutHeader, frameHeader.byteLength);
 
         encodedFrame.data = newData.buffer;
+        this.appendPacketTrailer(encodedFrame);
 
         return controller.enqueue(encodedFrame);
       } catch (e: any) {
@@ -444,6 +487,18 @@ export class FrameCryptor extends BaseFrameCryptor {
     }
   }
 
+  private appendPacketTrailer(encodedFrame: RTCEncodedVideoFrame | RTCEncodedAudioFrame) {
+    if (!hasPacketTrailerPublishOptions(this.packetTrailer) || !isVideoFrame(encodedFrame)) {
+      return;
+    }
+
+    if (this.packetTrailer?.frameId) {
+      this.packetTrailerFrameId =
+        this.packetTrailerFrameId === 0xffffffff ? 1 : this.packetTrailerFrameId + 1;
+    }
+    appendPacketTrailerToEncodedFrame(encodedFrame, this.packetTrailer, this.packetTrailerFrameId);
+  }
+
   /**
    * Function that will be injected in a stream and will decrypt the given encoded frames.
    *
@@ -454,6 +509,24 @@ export class FrameCryptor extends BaseFrameCryptor {
     encodedFrame: RTCEncodedVideoFrame | RTCEncodedAudioFrame,
     controller: TransformStreamDefaultController,
   ) {
+    if (this.hasPacketTrailer && isVideoFrame(encodedFrame)) {
+      try {
+        const ptResult = processPacketTrailer(encodedFrame, this.trackId);
+        if (ptResult.data) {
+          encodedFrame.data = ptResult.data;
+        }
+        if (ptResult.payload && this.participantIdentity) {
+          const msg: PTMetadataFromE2EEMessage = {
+            kind: 'packetTrailerMetadata',
+            data: ptResult.payload,
+          };
+          postMessage(msg);
+        }
+      } catch {
+        // best-effort: never break the media pipeline if trailer parsing fails
+      }
+    }
+
     if (
       !this.isEnabled() ||
       // skip for decryption for empty dtx frames
@@ -540,8 +613,12 @@ export class FrameCryptor extends BaseFrameCryptor {
     // ---------+-------------------------+-+---------+----
 
     try {
-      const frameHeader = new Uint8Array(encodedFrame.data, 0, frameInfo.unencryptedBytes);
-      var encryptedData = new Uint8Array(
+      const frameHeader: NonSharedUint8Array = new Uint8Array(
+        encodedFrame.data,
+        0,
+        frameInfo.unencryptedBytes,
+      );
+      var encryptedData: NonSharedUint8Array = new Uint8Array(
         encodedFrame.data,
         frameHeader.length,
         encodedFrame.data.byteLength - frameHeader.length,
@@ -758,7 +835,10 @@ export class FrameCryptor extends BaseFrameCryptor {
  * by the livekit server and thus to be treated as unencrypted
  * @internal
  */
-export function isFrameServerInjected(frameData: ArrayBuffer, trailerBytes: Uint8Array): boolean {
+export function isFrameServerInjected(
+  frameData: ArrayBuffer,
+  trailerBytes: NonSharedUint8Array,
+): boolean {
   if (trailerBytes.byteLength === 0) {
     return false;
   }

package/src/e2ee/worker/ParticipantKeyHandler.test.ts

@@ -261,7 +261,7 @@ describe('ParticipantKeyHandler', () => {
 
       await keyHandler.setKey(originalMaterial);
 
-      const ciphertexts: Uint8Array[] = [];
+      const ciphertexts: NonSharedUint8Array[] = [];
 
       const plaintext = new Uint8Array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]);
 
@@ -354,8 +354,8 @@ describe('ParticipantKeyHandler', () => {
     async function encrypt(
       participantKeyHandler: ParticipantKeyHandler,
       keyIndex: number,
-      iv: Uint8Array,
-      data: Uint8Array,
+      iv: NonSharedUint8Array,
+      data: NonSharedUint8Array,
     ): Promise<ArrayBuffer> {
       return crypto.subtle.encrypt(
         {
@@ -370,7 +370,7 @@ describe('ParticipantKeyHandler', () => {
     async function decrypt(
       participantKeyHandler: ParticipantKeyHandler,
       keyIndex: number,
-      iv: Uint8Array,
+      iv: NonSharedUint8Array,
       cipherText: ArrayBuffer,
     ): Promise<ArrayBuffer> {
       return crypto.subtle.decrypt(