livekit-client 2.22.4 → 2.23.0

package/src/api/SignalClient.ts

@@ -63,6 +63,7 @@ import type { LoggerOptions } from '../room/types';
 import { getClientInfo, isCompressionStreamSupported, isReactNative, sleep } from '../room/utils';
 import type { NonSharedUint8Array } from '../type-polyfills/non-shared-typed-arrays';
 import { AsyncQueue } from '../utils/AsyncQueue';
+import { abortSignalTimeout } from '../utils/abort-signal-polyfill';
 import { announceMachine } from '../utils/machineInspector';
 import {
   type SignalLifecycleState,
@@ -434,15 +435,29 @@ export class SignalClient {
   ): Promise<JoinResponse | ReconnectResponse | undefined> {
     const unlock = await this.connectionLock.lock();
 
-    this.connectOptions = opts;
-    this.useV0SignalPath = useV0Path;
+    let rtcUrl: string;
+    let validateUrl: string;
+    try {
+      this.connectOptions = opts;
+      this.useV0SignalPath = useV0Path;
+
+      const clientInfo = getClientInfo(opts.clientInfoCapabilities);
+      const params = useV0Path
+        ? createConnectionParams(token, clientInfo, opts)
+        : await createJoinRequestConnectionParams(token, clientInfo, opts, publisherOffer);
+      rtcUrl = createRtcUrl(url, params, useV0Path).toString();
+      validateUrl = createValidateUrl(rtcUrl).toString();
+    } catch (e) {
+      // the executor below owns the lock from here on
+      unlock();
+      throw e;
+    }
 
-    const clientInfo = getClientInfo(opts.clientInfoCapabilities);
-    const params = useV0Path
-      ? createConnectionParams(token, clientInfo, opts)
-      : await createJoinRequestConnectionParams(token, clientInfo, opts, publisherOffer);
-    const rtcUrl = createRtcUrl(url, params, useV0Path).toString();
-    const validateUrl = createValidateUrl(rtcUrl).toString();
+    if (abortSignal?.aborted) {
+      unlock();
+      this.log.debug('signal connect abandoned before opening a transport');
+      throw ConnectionError.cancelled('Connection aborted');
+    }
 
     return new Promise<JoinResponse | ReconnectResponse | undefined>(async (resolve, reject) => {
       try {
@@ -457,13 +472,13 @@ export class SignalClient {
           // send leave if we have an active stream writer (connection is open)
           if (this.streamWriter && !this.isDisconnected) {
             this.sendLeave()
-              .then(() => this.close(reason))
+              .then(() => this.close(true, reason))
               .catch((e) => {
                 this.log.error(e);
-                this.close();
+                this.close(true, reason);
               });
           } else {
-            this.close();
+            this.close(true, reason);
           }
           cleanupAbortHandlers();
           // The caller may already have classified this failure: the connect timeout hands us a
@@ -498,6 +513,10 @@ export class SignalClient {
           await this.teardownTransport('replaced by a new connection attempt');
           this.log.debug(`closed previous ws connection in ${performance.now() - startClose}ms`);
         }
+        if (alreadyAborted) {
+          this.log.debug('signal connect abandoned after tearing down the previous transport');
+          return;
+        }
 
         // the transport created below belongs to this attempt; events arriving from it after a
         // newer attempt has started are dropped by the machine
@@ -562,6 +581,12 @@ export class SignalClient {
               }
             });
           const connection = await this.ws.opened.catch(async (reason: unknown) => {
+            if (alreadyAborted) {
+              // the abort handler has already rejected this attempt; don't probe the validate
+              // endpoint for a failure nobody is waiting on
+              this.log.debug('signal connect abandoned while the websocket was opening');
+              return;
+            }
             if (this.lifecycleState !== 'connected') {
               // claimed synchronously, before the await below: the socket's close event is already
               // on its way and would otherwise reject first with a less useful error
@@ -638,6 +663,13 @@ export class SignalClient {
             return;
           }
           signalReader.releaseLock();
+          if (alreadyAborted) {
+            // The abort handler has already rejected this attempt and is closing the transport.
+            // Don't act on a join that raced it: `onJoined` would publish an abandoned session's
+            // state to the room.
+            this.log.debug('signal connect abandoned while waiting for the first message');
+            return;
+          }
 
           // Validate the first message
           const validation = this.validateFirstMessage(
@@ -741,14 +773,15 @@ export class SignalClient {
   private async teardownTransport(reason: string) {
     try {
       this.clearPingInterval();
-      if (this.ws) {
-        this.ws.close({ closeCode: 1000, reason });
-
-        // calling `ws.close()` only starts the closing handshake (CLOSING state), prefer to wait until state is actually CLOSED
-        const closePromise = this.ws.closed;
+      const ws = this.ws;
+      if (ws) {
+        // released before closing, so a close that throws cannot leave the transport attached
         this.ws = undefined;
         this.streamWriter = undefined;
-        await Promise.race([closePromise, sleep(MAX_WS_CLOSE_TIME)]);
+        ws.close({ closeCode: 1000, reason });
+
+        // calling `ws.close()` only starts the closing handshake (CLOSING state), prefer to wait until state is actually CLOSED
+        await Promise.race([ws.closed, sleep(MAX_WS_CLOSE_TIME)]);
       }
     } catch (e) {
       this.log.debug('websocket error while closing', { error: e });
@@ -1294,7 +1327,7 @@ export class SignalClient {
     validateUrl: string,
   ): Promise<ConnectionError> {
     try {
-      const resp = await fetch(validateUrl);
+      const resp = await fetch(validateUrl, { signal: abortSignalTimeout(3000) });
 
       switch (resp.status) {
         case 404:
@@ -1323,11 +1356,13 @@ export class SignalClient {
         );
       }
     } catch (e) {
-      return e instanceof ConnectionError
-        ? e
-        : ConnectionError.serverUnreachable(
-            e instanceof Error ? e.message : 'server was not reachable',
-          );
+      if (e instanceof ConnectionError) {
+        return e;
+      } else {
+        return ConnectionError.serverUnreachable(
+          e instanceof Error ? e.message : 'server was not reachable',
+        );
+      }
     }
   }
 }

package/src/api/WebSocketStream.test.ts

@@ -407,6 +407,17 @@ describe('WebSocketStream', () => {
       wsStream.close();
       expect(closeSpy).toHaveBeenCalledWith(undefined, undefined);
     });
+
+    it('truncates a reason longer than WebSocket.close accepts', () => {
+      const wsStream = new WebSocketStream('wss://test.example.com');
+
+      const closeSpy = vi.spyOn(mockWebSocket, 'close');
+
+      // 'é' is two UTF-8 bytes, so the 123-byte limit falls in the middle of a character
+      wsStream.close({ closeCode: 1000, reason: 'é'.repeat(100) });
+
+      expect(closeSpy).toHaveBeenCalledWith(1000, 'é'.repeat(61));
+    });
   });
 
   describe('AbortSignal integration', () => {

package/src/api/WebSocketStream.ts

@@ -55,7 +55,7 @@ export class WebSocketStream<T extends ArrayBuffer | string = ArrayBuffer | stri
     this.ws = ws;
 
     const closeWithInfo = ({ closeCode: code, reason }: WebSocketCloseInfo = {}) =>
-      ws.close(code, reason);
+      ws.close(code, reason === undefined ? undefined : truncateCloseReason(reason));
 
     this.opened = new TypedPromise<WebSocketConnection<T>, WebsocketError>((resolve, reject) => {
       const rejectHandler = () => {
@@ -140,3 +140,24 @@ export class WebSocketStream<T extends ArrayBuffer | string = ArrayBuffer | stri
     this.close = closeWithInfo;
   }
 }
+
+/** `WebSocket.close` throws a `SyntaxError` for a reason longer than this many UTF-8 bytes. */
+const MAX_CLOSE_REASON_BYTES = 123;
+
+export function truncateCloseReason(reason: string): string {
+  const encoder = new TextEncoder();
+  if (encoder.encode(reason).length <= MAX_CLOSE_REASON_BYTES) {
+    return reason;
+  }
+  // cut on code point boundaries, so a multi-byte character is never split
+  let truncated = '';
+  let bytes = 0;
+  for (const char of reason) {
+    bytes += encoder.encode(char).length;
+    if (bytes > MAX_CLOSE_REASON_BYTES) {
+      break;
+    }
+    truncated += char;
+  }
+  return truncated;
+}

package/src/api/utils.ts

@@ -44,7 +44,7 @@ export function parseSignalResponse(value: ArrayBuffer | string) {
 export function getAbortReasonAsString(
   signal: AbortSignal | Error | unknown,
   defaultMessage = 'Unknown reason',
-) {
+): string {
   // the connect timeout hands this an Error rather than a signal, and its message is the only
   // description of what went wrong — without this a timeout reports itself as a generic abort
   if (signal instanceof Error) {

package/src/e2ee/E2eeManager.test.ts

@@ -1,6 +1,9 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 import { LogLevel, getWorkerLogLevelListenerCount, setLogLevel, workerLogger } from '../logger';
 import Room from '../room/Room';
+import { ParticipantEvent } from '../room/events';
+import { Track } from '../room/track/Track';
+import type { VideoCodec } from '../room/track/options';
 import { E2EEManager } from './E2eeManager';
 import { BaseKeyProvider } from './KeyProvider';
 
@@ -194,3 +197,43 @@ describe('E2EEManager GC cleanup', () => {
     },
   );
 });
+
+describe('E2EEManager sender codec seeding', () => {
+  function publishVideo(videoCodec: VideoCodec | undefined) {
+    const { room, worker, manager } = makeManager();
+    room.localParticipant.identity = 'me';
+    manager.setup(room);
+
+    const sender = {
+      createEncodedStreams: () => ({
+        readable: new ReadableStream(),
+        writable: new WritableStream(),
+      }),
+    } as unknown as RTCRtpSender;
+    const track = {
+      isLocal: true,
+      kind: Track.Kind.Video,
+      mediaStreamID: 'ms1',
+      publishOptions: { videoCodec },
+    };
+
+    room.localParticipant.emit(ParticipantEvent.LocalSenderCreated, sender, track as any);
+    manager.dispose();
+
+    return worker.postMessage.mock.calls.map(([m]) => m).find((m: any) => m?.kind === 'encode');
+  }
+
+  it('seeds the publish codec for h264', () => {
+    expect(publishVideo('h264')?.data.codec).toBe('h264');
+  });
+
+  it('seeds the publish codec for h265', () => {
+    expect(publishVideo('h265')?.data.codec).toBe('h265');
+  });
+
+  it('leaves vp8 unseeded so byte detection still decides', () => {
+    const encode = publishVideo('vp8');
+    expect(encode).toBeDefined();
+    expect(encode.data.codec).toBeUndefined();
+  });
+});

package/src/e2ee/E2eeManager.ts

@@ -620,11 +620,15 @@ export class E2EEManager
       if (!sender) this.log.warn('early return because sender is not ready');
       return;
     }
+    const isVideo = isVideoTrack(track);
+    // Safari exposes no per-frame codec info until trackInfo arrives. Seed only h264/h265:
+    // a wrong vp8 seed would skip the NALU path, a wrong NALU seed only costs a logged fallback.
+    const publishedCodec = isVideo ? track.publishOptions?.videoCodec : undefined;
     this.handleSender(
       sender,
       track.mediaStreamID,
-      undefined,
-      isVideoTrack(track)
+      publishedCodec === 'h264' || publishedCodec === 'h265' ? publishedCodec : undefined,
+      isVideo
         ? (track.publishOptions?.frameMetadata ?? track.publishOptions?.packetTrailer)
         : undefined,
     );

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

@@ -1,6 +1,8 @@
 import { afterEach, describe, expect, it, vitest } from 'vitest';
 import { appendPacketTrailer, extractPacketTrailer } from '../../frameMetadata/frameMetadata';
 import type { FrameMetadataPublishOptions } from '../../frameMetadata/types';
+import { workerLogger } from '../../logger';
+import type { VideoCodec } from '../../room/track/options';
 import type { NonSharedUint8Array } from '../../type-polyfills/non-shared-typed-arrays';
 import { IV_LENGTH, KEY_PROVIDER_DEFAULTS } from '../constants';
 import { CryptorEvent } from '../events';
@@ -71,12 +73,14 @@ function prepareParticipantTestEncoder(
   participantIdentity: string,
   partialKeyProviderOptions: Partial<KeyProviderOptions>,
   packetTrailer?: FrameMetadataPublishOptions,
+  codec?: VideoCodec,
 ) {
   return prepareParticipantTest(
     'encode',
     participantIdentity,
     partialKeyProviderOptions,
     packetTrailer,
+    codec,
   );
 }
 
@@ -85,6 +89,7 @@ function prepareParticipantTest(
   participantIdentity: string,
   partialKeyProviderOptions: Partial<KeyProviderOptions>,
   packetTrailer?: FrameMetadataPublishOptions,
+  codec?: VideoCodec,
 ): {
   keys: ParticipantKeyHandler;
   cryptor: FrameCryptor;
@@ -110,7 +115,7 @@ function prepareParticipantTest(
     new ReadableStream(input),
     new WritableStream(output),
     'testTrack',
-    undefined,
+    codec,
     packetTrailer,
   );
 
@@ -233,81 +238,224 @@ describe('FrameCryptor', () => {
       }
     });
 
-    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);
+    describe('H.264 start codes (#2140)', () => {
+      const sps = [0x67, 0x64, 0x00, 0x1f, 0xac, 0xd9];
+      const pps = [0x68, 0xee, 0x3c, 0xb0];
+      const idr = [0x65, 0x88, 0x84, 0x21, 0x43, 0x55, 0x66, 0x77];
+
+      async function encryptAndDecrypt(plainTextData: NonSharedUint8Array) {
+        const encoder = prepareParticipantTestEncoder(participantIdentity, {});
+        await encoder.keys.setKey(await createKeyMaterialFromString('key1'), 1);
+        const encrypted = mockRTCEncodedVideoFrame(plainTextData);
+        encoder.input.write(encrypted);
+        await vitest.waitFor(() => expect(encoder.output.chunks).toHaveLength(1));
+        const encryptedData = new Uint8Array(encrypted.data.slice(0));
+
+        const decoder = prepareParticipantTestDecoder(participantIdentity, {});
+        await decoder.keys.setKey(await createKeyMaterialFromString('key1'), 1);
+        const decrypted = mockRTCEncodedVideoFrame(new Uint8Array(encryptedData));
+        decoder.input.write(decrypted);
+        await vitest.waitFor(() => expect(decoder.output.chunks).toHaveLength(1));
+
+        return { encryptedData, decryptedData: new Uint8Array(decrypted.data) };
+      }
 
-        const frame = mockRTCEncodedVideoFrame(
-          new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]),
+      it('rewrites 3-byte start codes in the unencrypted header to 4-byte start codes', async () => {
+        const { encryptedData, decryptedData } = await encryptAndDecrypt(
+          new Uint8Array([0, 0, 1, ...sps, 0, 0, 1, ...pps, 0, 0, 1, ...idr]),
         );
 
-        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),
+        // The unencrypted header runs through the first 2 bytes of the slice NALU.
+        const expectedHeader = [0, 0, 0, 1, ...sps, 0, 0, 0, 1, ...pps, 0, 0, 0, 1, 0x65, 0x88];
+        expect(Array.from(encryptedData.subarray(0, expectedHeader.length))).toEqual(
+          expectedHeader,
         );
-        expect(extracted.metadata?.frameId).toBe(1);
+        expect(Array.from(decryptedData)).toEqual([
+          0,
+          0,
+          0,
+          1,
+          ...sps,
+          0,
+          0,
+          0,
+          1,
+          ...pps,
+          0,
+          0,
+          0,
+          1,
+          ...idr,
+        ]);
+      });
 
-        const frameTrailer = new Uint8Array(
-          extracted.data.buffer.slice(extracted.data.byteLength - 2),
+      it('rewrites a 3-byte start code on a delta frame', async () => {
+        const pSlice = [0x41, 0x9a, 0x21, 0x43, 0x55, 0x66];
+        const { encryptedData, decryptedData } = await encryptAndDecrypt(
+          new Uint8Array([0, 0, 1, ...pSlice]),
         );
-        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 },
-        );
+        expect(Array.from(encryptedData.subarray(0, 6))).toEqual([0, 0, 0, 1, 0x41, 0x9a]);
+        expect(Array.from(decryptedData)).toEqual([0, 0, 0, 1, ...pSlice]);
+      });
 
-        await keys.setKey(await createKeyMaterialFromString('key1'), 1);
+      it('leaves 4-byte start codes in the unencrypted header unchanged', async () => {
+        const plainTextData = [0, 0, 0, 1, ...sps, 0, 0, 0, 1, ...pps, 0, 0, 0, 1, ...idr];
+        const { encryptedData, decryptedData } = await encryptAndDecrypt(
+          new Uint8Array(plainTextData),
+        );
 
-        const frame = mockRTCEncodedVideoFrame(
-          new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]),
+        const expectedHeader = [0, 0, 0, 1, ...sps, 0, 0, 0, 1, ...pps, 0, 0, 0, 1, 0x65, 0x88];
+        expect(Array.from(encryptedData.subarray(0, expectedHeader.length))).toEqual(
+          expectedHeader,
         );
+        expect(Array.from(decryptedData)).toEqual(plainTextData);
+      });
+      it('logs the frame bytes once when NALU processing fails', async () => {
+        vitest.useFakeTimers();
+        const warn = vitest.spyOn(workerLogger, 'warn');
+        try {
+          const { keys, input, output } = prepareParticipantTestEncoder(
+            participantIdentity,
+            {},
+            undefined,
+            'h264',
+          );
+
+          await keys.setKey(await createKeyMaterialFromString('key1'), 1);
+
+          // No start code at offset 0, so findNALUIndices throws 'byte stream contains
+          // leading data' and the cryptor falls back to VP8 handling.
+          input.write(
+            mockRTCEncodedVideoFrame(new Uint8Array([9, 9, 9, 9, 1, 2, 3, 4, 5, 6, 7, 8])),
+          );
+          await vitest.waitFor(() => expect(output.chunks).toHaveLength(1));
+
+          expect(warn).toHaveBeenCalledWith(
+            'NALU processing failed, falling back to VP8 handling',
+            expect.objectContaining({
+              detectedCodec: 'h264',
+              frameType: 'key',
+              byteLength: 12,
+              firstBytes: expect.stringMatching(/^09 09 09 09 /),
+            }),
+          );
+
+          // same payload type, so the once-per-tuple guard must suppress the second log
+          input.write(
+            mockRTCEncodedVideoFrame(new Uint8Array([8, 8, 8, 8, 1, 2, 3, 4, 5, 6, 7, 8])),
+          );
+          await vitest.waitFor(() => expect(output.chunks).toHaveLength(2));
+
+          expect(warn).toHaveBeenCalledTimes(1);
+        } finally {
+          warn.mockRestore();
+          vitest.useRealTimers();
+        }
+      });
 
-        input.write(frame);
-        await vitest.waitFor(() => expect(output.chunks).toHaveLength(1));
+      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();
+        }
+      });
 
-        const extracted = extractPacketTrailer(frame.data);
-        expect(extracted.metadata).toBeUndefined();
-        expect(extracted.data.byteLength).toBe(frame.data.byteLength);
+      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();
+        }
+      });
 
-        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 timestamp packet trailer metadata after encryption', async () => {
-      vitest.useFakeTimers();
-      const now = new Date('2025-04-10T12:00:00.123Z');
-      vitest.setSystemTime(now);
-      try {
+      it('appends only frame id packet trailer metadata after encryption', async () => {
         const { keys, input, output } = prepareParticipantTestEncoder(
           participantIdentity,
           {},
-          { timestamp: true },
+          { frameId: true },
         );
 
         await keys.setKey(await createKeyMaterialFromString('key1'), 1);
@@ -320,37 +468,11 @@ describe('FrameCryptor', () => {
         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,
+        expect(frame.data.byteLength - extracted.data.byteLength).toBe(11);
+        expect(extracted.metadata).toEqual({
+          userTimestamp: BigInt(0),
+          frameId: 1,
+        });
       });
     });
   });