livekit-client 2.19.1 → 2.20.0

package/src/e2ee/worker/FrameCryptor.ts

@@ -1,14 +1,15 @@
 // 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';
+} from '../../frameMetadata/frameMetadata';
+import type { FrameMetadataPublishOptions } from '../../frameMetadata/types';
+import { hasFrameMetadataPublishOptions } from '../../frameMetadata/utils';
+import { workerLogger } from '../../logger';
+import { type VideoCodec, videoCodecs } from '../../room/track/options';
+import { mimeTypeToVideoCodecString } from '../../room/track/utils';
 import { ENCRYPTION_ALGORITHM, IV_LENGTH, UNENCRYPTED_BYTES } from '../constants';
 import { CryptorError, CryptorErrorReason } from '../errors';
 import { type CryptorCallbacks, CryptorEvent } from '../events';
@@ -87,11 +88,11 @@ export class FrameCryptor extends BaseFrameCryptor {
    * 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 hasFrameMetadata: boolean = false;
 
-  private packetTrailer?: PacketTrailerPublishOptions;
+  private frameMetadataOpts?: FrameMetadataPublishOptions;
 
-  private packetTrailerFrameId = 0;
+  private frameMetadataFrameId = 0;
 
   /**
    * Throttling mechanism for decryption errors to prevent memory leaks
@@ -106,6 +107,12 @@ export class FrameCryptor extends BaseFrameCryptor {
 
   private readonly ERROR_WINDOW_MS = 60000; // 1 minute window
 
+  /**
+   * Tracks (participant, trackId, payloadType) tuples for which we've already logged a NALU
+   * fallback, so a persistent bad state doesn't flood the console (Firefox doesn't filter debug).
+   */
+  private loggedNALUFallbacks: Set<string> = new Set();
+
   constructor(opts: {
     keys: ParticipantKeyHandler;
     participantIdentity: string;
@@ -205,13 +212,13 @@ export class FrameCryptor extends BaseFrameCryptor {
    * trailer data. When false, {@link decodeFunction} skips the per-frame
    * trailer extraction branch entirely.
    */
-  setHasPacketTrailer(hasPacketTrailer: boolean) {
-    this.hasPacketTrailer = hasPacketTrailer;
+  setHasFrameMetadata(hasFrameMetadata: boolean) {
+    this.hasFrameMetadata = hasFrameMetadata;
   }
 
-  setPacketTrailer(packetTrailer?: PacketTrailerPublishOptions) {
-    this.packetTrailer = packetTrailer;
-    this.packetTrailerFrameId = 0;
+  setFrameMetadataOpts(frameMetadata?: FrameMetadataPublishOptions) {
+    this.frameMetadataOpts = frameMetadata;
+    this.frameMetadataFrameId = 0;
   }
 
   setupTransform(
@@ -221,14 +228,14 @@ export class FrameCryptor extends BaseFrameCryptor {
     trackId: string,
     isReuse: boolean,
     codec?: VideoCodec,
-    packetTrailer?: PacketTrailerPublishOptions,
+    frameMetadata?: FrameMetadataPublishOptions,
   ) {
     if (codec) {
       workerLogger.info('setting codec on cryptor to', { codec });
       this.videoCodec = codec;
     }
     if (operation === 'encode') {
-      this.setPacketTrailer(packetTrailer);
+      this.setFrameMetadataOpts(frameMetadata);
     }
 
     workerLogger.debug('Setting up frame cryptor transform', {
@@ -399,7 +406,7 @@ export class FrameCryptor extends BaseFrameCryptor {
     }
 
     if (!this.isEnabled()) {
-      this.appendPacketTrailer(encodedFrame);
+      this.appendFrameMetadata(encodedFrame);
       return controller.enqueue(encodedFrame);
     }
     const keySet = this.keys.getKeySet();
@@ -468,7 +475,7 @@ export class FrameCryptor extends BaseFrameCryptor {
         newData.set(newDataWithoutHeader, frameHeader.byteLength);
 
         encodedFrame.data = newData.buffer;
-        this.appendPacketTrailer(encodedFrame);
+        this.appendFrameMetadata(encodedFrame);
 
         return controller.enqueue(encodedFrame);
       } catch (e: any) {
@@ -487,16 +494,20 @@ export class FrameCryptor extends BaseFrameCryptor {
     }
   }
 
-  private appendPacketTrailer(encodedFrame: RTCEncodedVideoFrame | RTCEncodedAudioFrame) {
-    if (!hasPacketTrailerPublishOptions(this.packetTrailer) || !isVideoFrame(encodedFrame)) {
+  private appendFrameMetadata(encodedFrame: RTCEncodedVideoFrame | RTCEncodedAudioFrame) {
+    if (!hasFrameMetadataPublishOptions(this.frameMetadataOpts) || !isVideoFrame(encodedFrame)) {
       return;
     }
 
-    if (this.packetTrailer?.frameId) {
-      this.packetTrailerFrameId =
-        this.packetTrailerFrameId === 0xffffffff ? 1 : this.packetTrailerFrameId + 1;
+    if (this.frameMetadataOpts?.frameId) {
+      this.frameMetadataFrameId =
+        this.frameMetadataFrameId === 0xffffffff ? 1 : this.frameMetadataFrameId + 1;
     }
-    appendPacketTrailerToEncodedFrame(encodedFrame, this.packetTrailer, this.packetTrailerFrameId);
+    appendPacketTrailerToEncodedFrame(
+      encodedFrame,
+      this.frameMetadataOpts,
+      this.frameMetadataFrameId,
+    );
   }
 
   /**
@@ -509,7 +520,7 @@ export class FrameCryptor extends BaseFrameCryptor {
     encodedFrame: RTCEncodedVideoFrame | RTCEncodedAudioFrame,
     controller: TransformStreamDefaultController,
   ) {
-    if (this.hasPacketTrailer && isVideoFrame(encodedFrame)) {
+    if (this.hasFrameMetadata && isVideoFrame(encodedFrame)) {
       try {
         const ptResult = processPacketTrailer(encodedFrame, this.trackId);
         if (ptResult.data) {
@@ -795,22 +806,23 @@ export class FrameCryptor extends BaseFrameCryptor {
     }
 
     // Try NALU processing for H.264/H.265 codecs
+    const payloadType = frame.getMetadata().payloadType;
+    const fallbackKey = `${this.participantIdentity}-${this.trackId}-${payloadType}`;
     try {
       const knownCodec =
         detectedCodec === 'h264' || detectedCodec === 'h265' ? detectedCodec : undefined;
       const naluResult = processNALUsForEncryption(new Uint8Array(frame.data), knownCodec);
 
       if (naluResult.requiresNALUProcessing) {
+        // Recovered for this tuple, allow a future failure to log again.
+        this.loggedNALUFallbacks.delete(fallbackKey);
         return {
           unencryptedBytes: naluResult.unencryptedBytes,
           requiresNALUProcessing: true,
         };
       }
     } catch (e) {
-      workerLogger.debug('NALU processing failed, falling back to VP8 handling', {
-        error: e,
-        ...this.logContext,
-      });
+      this.logNALUFallbackOnce(fallbackKey, payloadType, e);
     }
 
     // Fallback to VP8 handling
@@ -818,13 +830,40 @@ export class FrameCryptor extends BaseFrameCryptor {
   }
 
   /**
-   * inspects frame payloadtype if available and maps it to the codec specified in rtpMap
+   * Logs a NALU processing fallback at most once per (participant, trackId, payloadType) tuple,
+   * so a persistent bad state doesn't flood the console (Firefox doesn't filter debug).
+   */
+  private logNALUFallbackOnce(
+    fallbackKey: string,
+    payloadType: number | undefined,
+    error: unknown,
+  ) {
+    if (this.loggedNALUFallbacks.has(fallbackKey)) {
+      return;
+    }
+    this.loggedNALUFallbacks.add(fallbackKey);
+    workerLogger.warn('NALU processing failed, falling back to VP8 handling', {
+      error,
+      payloadType,
+      ...this.logContext,
+    });
+  }
+
+  /**
+   * inspects frame mimetype if available. falls back to payloadtype and maps it to the codec specified in rtpMap
    */
   private getVideoCodec(frame: RTCEncodedVideoFrame): VideoCodec | undefined {
+    const metadata = frame.getMetadata();
+    if (metadata.mimeType) {
+      const maybeKnownCodec = mimeTypeToVideoCodecString(metadata.mimeType);
+      if (videoCodecs.includes(maybeKnownCodec)) {
+        return maybeKnownCodec;
+      }
+    }
     if (this.rtpMap.size === 0) {
       return undefined;
     }
-    const payloadType = frame.getMetadata().payloadType;
+    const payloadType = metadata.payloadType;
     const codec = payloadType ? this.rtpMap.get(payloadType) : undefined;
     return codec;
   }

package/src/e2ee/worker/e2ee.worker.ts

@@ -64,7 +64,7 @@ onmessage = (ev) => {
         break;
       case 'decode':
         let cryptor = getTrackCryptor(data.participantIdentity, data.trackId);
-        cryptor.setHasPacketTrailer(data.hasPacketTrailer);
+        cryptor.setHasFrameMetadata(data.hasPacketTrailer);
         cryptor.setupTransform(
           kind,
           data.readableStream,
@@ -76,7 +76,7 @@ onmessage = (ev) => {
         break;
       case 'encode':
         let pubCryptor = getTrackCryptor(data.participantIdentity, data.trackId);
-        pubCryptor.setHasPacketTrailer(data.hasPacketTrailer);
+        pubCryptor.setHasFrameMetadata(data.hasPacketTrailer);
         pubCryptor.setupTransform(
           kind,
           data.readableStream,
@@ -84,7 +84,7 @@ onmessage = (ev) => {
           data.trackId,
           data.isReuse,
           data.codec,
-          data.packetTrailer,
+          data.packetTrailer, // wire format still uses 'packetTrailer' field name
         );
         break;
 
@@ -164,7 +164,7 @@ onmessage = (ev) => {
       case 'updateCodec':
         const trackCryptor = getTrackCryptor(data.participantIdentity, data.trackId);
         trackCryptor.setVideoCodec(data.codec);
-        trackCryptor.setHasPacketTrailer(data.hasPacketTrailer);
+        trackCryptor.setHasFrameMetadata(data.hasPacketTrailer);
         workerLogger.info('updated codec', {
           participantIdentity: data.participantIdentity,
           trackId: data.trackId,
@@ -343,7 +343,7 @@ if (self.RTCTransformEvent) {
     const { kind, participantIdentity, trackId, codec, hasPacketTrailer } = options;
     messageQueue.run(async () => {
       const cryptor = getTrackCryptor(participantIdentity, trackId);
-      cryptor.setHasPacketTrailer(hasPacketTrailer);
+      cryptor.setHasFrameMetadata(hasPacketTrailer);
       workerLogger.debug('onrtctransform setup', { participantIdentity, trackId, codec });
       cryptor.setupTransform(
         kind,

package/src/e2ee/worker/tsconfig.json

@@ -8,7 +8,10 @@
       "ES2018.Promise",
       "WebWorker",
       "ES2021.WeakRef",
-      "DOM.AsyncIterable"
+      "DOM.AsyncIterable",
+      "ES2020.BigInt",
+      "ES2018.AsyncIterable",
+      "ES2018.AsyncGenerator"
     ]
   }
 }

package/src/{packetTrailer/PacketTrailerManager.test.ts → frameMetadata/FrameMetadataManager.test.ts}

@@ -1,8 +1,8 @@
 import { afterEach, describe, expect, it, vi } from 'vitest';
 import type { TrackInfo } from '@livekit/protocol';
-import { PacketTrailerManager } from './PacketTrailerManager';
+import { FrameMetadataManager } from './FrameMetadataManager';
 
-describe('PacketTrailerManager', () => {
+describe('FrameMetadataManager', () => {
   const originalRTCRtpSender = window.RTCRtpSender;
   const originalUserAgent = navigator.userAgent;
   const originalRTCRtpScriptTransform = (window as unknown as { RTCRtpScriptTransform?: unknown })
@@ -63,7 +63,7 @@ describe('PacketTrailerManager', () => {
     });
   }
 
-  function setupWorkerReceiver(manager: PacketTrailerManager, receiver: RTCRtpReceiver) {
+  function setupWorkerReceiver(manager: FrameMetadataManager, receiver: RTCRtpReceiver) {
     (
       manager as unknown as {
         setupWorkerReceiver: (receiver: RTCRtpReceiver, newTrackId: string) => void;
@@ -72,7 +72,7 @@ describe('PacketTrailerManager', () => {
   }
 
   function setupReceiver(
-    manager: PacketTrailerManager,
+    manager: FrameMetadataManager,
     receiver: RTCRtpReceiver,
     trackId: string,
     trackInfo?: TrackInfo,
@@ -103,11 +103,13 @@ describe('PacketTrailerManager', () => {
   it('uses RTCRtpScriptTransform for packet trailer extraction when supported', () => {
     useSafariUserAgent();
     const transform = {};
-    const RTCRtpScriptTransform = vi.fn(() => transform);
+    const RTCRtpScriptTransform = vi.fn(function () {
+      return transform;
+    });
     setScriptTransform(RTCRtpScriptTransform);
 
     const worker = {} as Worker;
-    const manager = new PacketTrailerManager({ worker });
+    const manager = new FrameMetadataManager({ worker });
     const receiver = {
       createEncodedStreams: vi.fn(),
     } as unknown as RTCRtpReceiver;
@@ -129,7 +131,7 @@ describe('PacketTrailerManager', () => {
     stubInsertableStreamsSupport();
 
     const worker = { postMessage: vi.fn() } as unknown as Worker;
-    const manager = new PacketTrailerManager({ worker });
+    const manager = new FrameMetadataManager({ worker });
     const { receiver, readable, writable, createEncodedStreams } = makeReceiver();
 
     setupReceiver(manager, receiver, 'track-without-trailer');
@@ -153,7 +155,7 @@ describe('PacketTrailerManager', () => {
     stubInsertableStreamsSupport();
 
     const worker = { postMessage: vi.fn() } as unknown as Worker;
-    const manager = new PacketTrailerManager({ worker });
+    const manager = new FrameMetadataManager({ worker });
     const { receiver } = makeReceiver();
     const trackInfo = { packetTrailerFeatures: [1] } as unknown as TrackInfo;
 

package/src/{packetTrailer/PacketTrailerManager.ts → frameMetadata/FrameMetadataManager.ts}

@@ -2,13 +2,13 @@ import type { TrackInfo } from '@livekit/protocol';
 import log from '../logger';
 import type Room from '../room/Room';
 import { RoomEvent } from '../room/events';
-import { PacketTrailerExtractor } from '../room/track/PacketTrailerExtractor';
+import { FrameMetadataExtractor } from '../room/track/FrameMetadataExtractor';
 import type RemoteTrack from '../room/track/RemoteTrack';
 import RemoteVideoTrack from '../room/track/RemoteVideoTrack';
 import type { PTDecodeMessage, PTUpdateTrackIdMessage, PTWorkerMessage } from './types';
-import { isPacketTrailerSupported, shouldUsePacketTrailerScriptTransform } from './utils';
+import { isFrameMetadataSupported, shouldUseFrameMetadataScriptTransform } from './utils';
 
-export interface PacketTrailerOptions {
+export interface FrameMetadataOptions {
   /**
    * Dedicated worker for extracting packet trailers off the main thread.
    *
@@ -34,12 +34,12 @@ export interface PacketTrailerOptions {
  *
  * @experimental
  */
-export class PacketTrailerManager {
+export class FrameMetadataManager {
   private worker?: Worker;
 
   private room?: Room;
 
-  private extractors = new Map<string, PacketTrailerExtractor>();
+  private extractors = new Map<string, FrameMetadataExtractor>();
 
   /**
    * Tracks the trackId associated with each receiver that has had its
@@ -49,7 +49,7 @@ export class PacketTrailerManager {
    */
   private workerPipelines = new Map<RTCRtpReceiver, string>();
 
-  constructor(options?: PacketTrailerOptions) {
+  constructor(options?: FrameMetadataOptions) {
     this.worker = options?.worker;
   }
 
@@ -100,18 +100,18 @@ export class PacketTrailerManager {
     }
 
     if (
-      !isPacketTrailerSupported(this.worker ? { worker: this.worker } : undefined) &&
+      !isFrameMetadataSupported(this.worker ? { worker: this.worker } : undefined) &&
       !this.room?.hasE2EESetup
     ) {
-      log.warn('packet trailer transform not supported; skipping extraction');
+      log.warn('frame metadata transform not supported; skipping extraction');
       return;
     }
 
-    const extractor = new PacketTrailerExtractor();
+    const extractor = new FrameMetadataExtractor();
     const trackId = track.mediaStreamID;
 
     this.extractors.set(trackId, extractor);
-    track.packetTrailerExtractor = extractor;
+    track.frameMetadataExtractor = extractor;
 
     if (this.room?.hasE2EESetup) {
       // E2EE worker strips the trailer and injects metadata directly into
@@ -123,7 +123,7 @@ export class PacketTrailerManager {
   }
 
   private setupPassthroughReceiver(receiver: RTCRtpReceiver, trackId: string) {
-    if (shouldUsePacketTrailerScriptTransform()) {
+    if (shouldUseFrameMetadataScriptTransform()) {
       if ('transform' in receiver) {
         // @ts-ignore
         receiver.transform = null;
@@ -133,7 +133,7 @@ export class PacketTrailerManager {
 
     if (
       this.worker &&
-      isPacketTrailerSupported({ worker: this.worker }) &&
+      isFrameMetadataSupported({ worker: this.worker }) &&
       !this.workerPipelines.has(receiver)
     ) {
       this.setupWorkerReceiver(receiver, trackId, false);
@@ -155,7 +155,7 @@ export class PacketTrailerManager {
       return;
     }
 
-    if (shouldUsePacketTrailerScriptTransform()) {
+    if (shouldUseFrameMetadataScriptTransform()) {
       // @ts-ignore
       receiver.transform = new RTCRtpScriptTransform(worker, {
         kind: 'decode',
@@ -215,7 +215,7 @@ export class PacketTrailerManager {
     }
 
     if (track instanceof RemoteVideoTrack) {
-      track.packetTrailerExtractor = undefined;
+      track.frameMetadataExtractor = undefined;
     }
 
     // The receiver pipeline is intentionally left running. If the receiver is
@@ -245,6 +245,12 @@ export class PacketTrailerManager {
   };
 
   private onWorkerError = (ev: ErrorEvent) => {
-    log.error('packet trailer worker encountered an error:', { error: ev.error });
+    log.error('frame metadata worker encountered an error:', { error: ev.error });
   };
 }
+
+/** @deprecated Use {@link FrameMetadataManager} instead. */
+export const PacketTrailerManager = FrameMetadataManager;
+
+/** @deprecated Use {@link FrameMetadataOptions} instead. */
+export type PacketTrailerOptions = FrameMetadataOptions;

package/src/{packetTrailer/packetTrailer.test.ts → frameMetadata/frameMetadata.test.ts}

@@ -4,7 +4,7 @@ import {
   appendPacketTrailerToEncodedFrame,
   extractPacketTrailer,
   processPacketTrailer,
-} from './packetTrailer';
+} from './frameMetadata';
 
 describe('packetTrailer', () => {
   afterEach(() => {

package/src/{packetTrailer/packetTrailer.ts → frameMetadata/frameMetadata.ts}

@@ -1,5 +1,5 @@
-import type { PacketTrailerMetadata, PacketTrailerPublishOptions } from './types';
-import { hasPacketTrailerPublishOptions } from './utils';
+import type { FrameMetadata, FrameMetadataPublishOptions } from './types';
+import { hasFrameMetadataPublishOptions } from './utils';
 
 export const PACKET_TRAILER_MAGIC = Uint8Array.from([
   'L'.charCodeAt(0),
@@ -17,7 +17,7 @@ const FRAME_ID_TLV_SIZE = 6;
 
 export interface ExtractPacketTrailerResult {
   data: Uint8Array;
-  metadata?: PacketTrailerMetadata;
+  metadata?: FrameMetadata;
 }
 
 export function appendPacketTrailer(
@@ -64,10 +64,10 @@ export function appendPacketTrailer(
 
 export function appendPacketTrailerToEncodedFrame(
   frame: RTCEncodedVideoFrame,
-  options: PacketTrailerPublishOptions | undefined,
+  options: FrameMetadataPublishOptions | undefined,
   frameId: number,
 ): boolean {
-  if (!hasPacketTrailerPublishOptions(options) || frame.data.byteLength === 0) {
+  if (!hasFrameMetadataPublishOptions(options) || frame.data.byteLength === 0) {
     return false;
   }
 
@@ -108,7 +108,7 @@ export function extractPacketTrailer(data: ArrayBuffer | Uint8Array): ExtractPac
   const strippedData = bytes.subarray(0, trailerStart);
   let offset = trailerStart;
   let foundAny = false;
-  const metadata: PacketTrailerMetadata = {
+  const metadata: FrameMetadata = {
     userTimestamp: BigInt(0),
     frameId: 0,
   };
@@ -223,16 +223,16 @@ export function getFrameSsrc(frame: RTCEncodedVideoFrame | RTCEncodedAudioFrame)
   return 0;
 }
 
-export interface PacketTrailerFramePayload {
+export interface FrameMetadataPayload {
   trackId: string;
   rtpTimestamp: number;
   ssrc: number;
-  metadata: PacketTrailerMetadata;
+  metadata: FrameMetadata;
 }
 
 export interface ProcessPacketTrailerResult {
   data?: ArrayBuffer;
-  payload?: PacketTrailerFramePayload;
+  payload?: FrameMetadataPayload;
 }
 
 /**

package/src/{packetTrailer → frameMetadata}/types.ts

@@ -1,15 +1,21 @@
-import type { PacketTrailerFramePayload } from './packetTrailer';
+import type { FrameMetadataPayload } from './frameMetadata';
 
-export interface PacketTrailerMetadata {
+export interface FrameMetadata {
   userTimestamp: bigint;
   frameId: number;
 }
 
-export interface PacketTrailerPublishOptions {
+/** @deprecated Use {@link FrameMetadata} instead. */
+export type PacketTrailerMetadata = FrameMetadata;
+
+export interface FrameMetadataPublishOptions {
   timestamp?: boolean;
   frameId?: boolean;
 }
 
+/** @deprecated Use {@link FrameMetadataPublishOptions} instead. */
+export type PacketTrailerPublishOptions = FrameMetadataPublishOptions;
+
 export interface PTBaseMessage {
   kind: string;
   data?: unknown;
@@ -38,7 +44,7 @@ export interface PTEncodeMessage extends PTBaseMessage {
   data: {
     readableStream: ReadableStream;
     writableStream: WritableStream;
-    packetTrailer?: PacketTrailerPublishOptions;
+    packetTrailer?: FrameMetadataPublishOptions;
   };
 }
 
@@ -49,12 +55,12 @@ export type PTScriptTransformOptions =
     }
   | {
       kind: 'encode';
-      packetTrailer?: PacketTrailerPublishOptions;
+      packetTrailer?: FrameMetadataPublishOptions;
     };
 
 export interface PTMetadataMessage extends PTBaseMessage {
   kind: 'metadata';
-  data: PacketTrailerFramePayload;
+  data: FrameMetadataPayload;
 }
 
 export interface PTUpdateTrackIdMessage extends PTBaseMessage {

package/src/{packetTrailer → frameMetadata}/utils.test.ts

@@ -1,12 +1,12 @@
 import { PacketTrailerFeature } from '@livekit/protocol';
 import { afterEach, describe, expect, it } from 'vitest';
 import {
-  getPacketTrailerFeatures,
-  getPacketTrailerPublishOptions,
-  isPacketTrailerSupported,
+  getFrameMetadataFeatures,
+  getFrameMetadataPublishOptions,
+  isFrameMetadataSupported,
 } from './utils';
 
-describe('packet trailer support', () => {
+describe('frame metadata support', () => {
   const originalRTCRtpSender = window.RTCRtpSender;
   const originalRTCRtpScriptTransform = (window as unknown as { RTCRtpScriptTransform?: unknown })
     .RTCRtpScriptTransform;
@@ -46,20 +46,20 @@ describe('packet trailer support', () => {
     });
   }
 
-  it('supports packet trailers with RTCRtpScriptTransform on Safari', () => {
+  it('supports frame metadata with RTCRtpScriptTransform on Safari', () => {
     stubScriptTransformSupport(
       'Mozilla/5.0 (Macintosh; Intel Mac OS X 14_0) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.0 Safari/605.1.15',
     );
 
-    expect(isPacketTrailerSupported({ worker: {} as Worker })).toBe(true);
+    expect(isFrameMetadataSupported({ worker: {} as Worker })).toBe(true);
   });
 
-  it('supports packet trailers with RTCRtpScriptTransform on Firefox', () => {
+  it('supports frame metadata with RTCRtpScriptTransform on Firefox', () => {
     stubScriptTransformSupport(
       'Mozilla/5.0 (Macintosh; Intel Mac OS X 14.0; rv:144.0) Gecko/20100101 Firefox/144.0',
     );
 
-    expect(isPacketTrailerSupported({ worker: {} as Worker })).toBe(true);
+    expect(isFrameMetadataSupported({ worker: {} as Worker })).toBe(true);
   });
 
   it('does not use RTCRtpScriptTransform support on Chromium-based browsers', () => {
@@ -67,39 +67,39 @@ describe('packet trailer support', () => {
       'Mozilla/5.0 (Macintosh; Intel Mac OS X 14_0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/141.0.0.0 Safari/537.36',
     );
 
-    expect(isPacketTrailerSupported({ worker: {} as Worker })).toBe(false);
+    expect(isFrameMetadataSupported({ worker: {} as Worker })).toBe(false);
   });
 });
 
-describe('packet trailer publish features', () => {
+describe('frame metadata publish features', () => {
   it('maps publish options to protocol features', () => {
-    expect(getPacketTrailerFeatures({ timestamp: true, frameId: true })).toEqual([
+    expect(getFrameMetadataFeatures({ timestamp: true, frameId: true })).toEqual([
       PacketTrailerFeature.PTF_USER_TIMESTAMP,
       PacketTrailerFeature.PTF_FRAME_ID,
     ]);
-    expect(getPacketTrailerFeatures({ timestamp: true })).toEqual([
+    expect(getFrameMetadataFeatures({ timestamp: true })).toEqual([
       PacketTrailerFeature.PTF_USER_TIMESTAMP,
     ]);
-    expect(getPacketTrailerFeatures({ frameId: true })).toEqual([
+    expect(getFrameMetadataFeatures({ frameId: true })).toEqual([
       PacketTrailerFeature.PTF_FRAME_ID,
     ]);
-    expect(getPacketTrailerFeatures()).toEqual([]);
+    expect(getFrameMetadataFeatures()).toEqual([]);
   });
 
   it('maps protocol features to publish options', () => {
     expect(
-      getPacketTrailerPublishOptions([
+      getFrameMetadataPublishOptions([
         PacketTrailerFeature.PTF_USER_TIMESTAMP,
         PacketTrailerFeature.PTF_FRAME_ID,
       ]),
     ).toEqual({ timestamp: true, frameId: true });
-    expect(getPacketTrailerPublishOptions([PacketTrailerFeature.PTF_USER_TIMESTAMP])).toEqual({
+    expect(getFrameMetadataPublishOptions([PacketTrailerFeature.PTF_USER_TIMESTAMP])).toEqual({
       timestamp: true,
     });
-    expect(getPacketTrailerPublishOptions([PacketTrailerFeature.PTF_FRAME_ID])).toEqual({
+    expect(getFrameMetadataPublishOptions([PacketTrailerFeature.PTF_FRAME_ID])).toEqual({
       frameId: true,
     });
-    expect(getPacketTrailerPublishOptions()).toBeUndefined();
-    expect(getPacketTrailerPublishOptions([])).toBeUndefined();
+    expect(getFrameMetadataPublishOptions()).toBeUndefined();
+    expect(getFrameMetadataPublishOptions([])).toBeUndefined();
   });
 });