livekit-client 2.19.2 → 2.20.1

package/dist/src/type-polyfills/non-shared-typed-arrays.d.ts

@@ -0,0 +1,2 @@
+export type NonSharedUint8Array = ReturnType<typeof Uint8Array.from>;
+//# sourceMappingURL=non-shared-typed-arrays.d.ts.map

package/dist/src/type-polyfills/non-shared-typed-arrays.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"non-shared-typed-arrays.d.ts","sourceRoot":"","sources":["../../../src/type-polyfills/non-shared-typed-arrays.ts"],"names":[],"mappings":"AAUA,MAAM,MAAM,mBAAmB,GAAG,UAAU,CAAC,OAAO,UAAU,CAAC,IAAI,CAAC,CAAC"}

package/dist/src/utils/dataPacketBuffer.d.ts

@@ -1,3 +1,4 @@
+import type { NonSharedUint8Array } from '../type-polyfills/non-shared-typed-arrays';
 export interface DataPacketItem {
     data: NonSharedUint8Array;
     sequence: number;

package/dist/src/utils/dataPacketBuffer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dataPacketBuffer.d.ts","sourceRoot":"","sources":["../../../src/utils/dataPacketBuffer.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,mBAAmB,CAAC;IAC1B,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,MAAM,CAAwB;IAEtC,OAAO,CAAC,UAAU,CAAK;IAEvB,IAAI,CAAC,IAAI,EAAE,cAAc;IAKzB,GAAG,IAAI,cAAc,GAAG,SAAS;IAQjC,MAAM,IAAI,cAAc,EAAE;IAI1B,aAAa,CAAC,QAAQ,EAAE,MAAM;IAW9B,mBAAmB,CAAC,cAAc,EAAE,MAAM;IAU1C,IAAI,MAAM,IAAI,MAAM,CAEnB;CACF"}
+{"version":3,"file":"dataPacketBuffer.d.ts","sourceRoot":"","sources":["../../../src/utils/dataPacketBuffer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,2CAA2C,CAAC;AAErF,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,mBAAmB,CAAC;IAC1B,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,MAAM,CAAwB;IAEtC,OAAO,CAAC,UAAU,CAAK;IAEvB,IAAI,CAAC,IAAI,EAAE,cAAc;IAKzB,GAAG,IAAI,cAAc,GAAG,SAAS;IAQjC,MAAM,IAAI,cAAc,EAAE;IAI1B,aAAa,CAAC,QAAQ,EAAE,MAAM;IAW9B,mBAAmB,CAAC,cAAc,EAAE,MAAM;IAU1C,IAAI,MAAM,IAAI,MAAM,CAEnB;CACF"}

package/dist/ts4.2/e2ee/E2eeManager.d.ts

@@ -1,6 +1,7 @@
 import type TypedEventEmitter from 'typed-emitter';
 import type RTCEngine from '../room/RTCEngine';
 import type Room from '../room/Room';
+import type { NonSharedUint8Array } from '../type-polyfills/non-shared-typed-arrays';
 import type { E2EEManagerCallbacks } from './events';
 import type { DecryptDataResponseMessage, E2EEManagerOptions, EncryptDataResponseMessage } from './types';
 export interface BaseE2EEManager {
@@ -43,7 +44,7 @@ export declare class E2EEManager extends E2EEManager_base implements BaseE2EEMan
     setSifTrailer(trailer: NonSharedUint8Array): void;
     private onWorkerMessage;
     private onWorkerError;
-    private handlePacketTrailerMetadata;
+    private handleFrameMetadata;
     setupEngine(engine: RTCEngine): void;
     private setupEventListeners;
     encryptData(data: NonSharedUint8Array): Promise<EncryptDataResponseMessage['data']>;

package/dist/ts4.2/e2ee/types.d.ts

@@ -1,7 +1,8 @@
+import type { FrameMetadataPayload } from '../frameMetadata/frameMetadata';
+import type { FrameMetadataPublishOptions } from '../frameMetadata/types';
 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 { NonSharedUint8Array } from '../type-polyfills/non-shared-typed-arrays';
 import type { BaseE2EEManager } from './E2eeManager';
 import type { BaseKeyProvider } from './KeyProvider';
 export interface BaseMessage {
@@ -56,7 +57,7 @@ export interface EncodeMessage extends BaseMessage {
         /**
          * Packet trailer metadata to append on published video frames.
          */
-        packetTrailer?: PacketTrailerPublishOptions;
+        packetTrailer?: FrameMetadataPublishOptions;
     };
 }
 export interface RemoveTransformMessage extends BaseMessage {
@@ -147,7 +148,7 @@ export interface EncryptDataResponseMessage extends BaseMessage {
 }
 export interface PTMetadataFromE2EEMessage extends BaseMessage {
     kind: 'packetTrailerMetadata';
-    data: PacketTrailerFramePayload;
+    data: FrameMetadataPayload;
 }
 export type E2EEWorkerMessage = InitMessage | SetKeyMessage | EncodeMessage | ErrorMessage | EnableMessage | RemoveTransformMessage | RTPVideoMapMessage | UpdateCodecMessage | RatchetRequestMessage | RatchetMessage | SifTrailerMessage | InitAck | DecryptDataRequestMessage | DecryptDataResponseMessage | EncryptDataRequestMessage | EncryptDataResponseMessage | PTMetadataFromE2EEMessage;
 export type KeySet = {
@@ -204,6 +205,6 @@ export type ScriptTransformOptions = {
     /**
      * Packet trailer metadata to append on published video frames.
      */
-    packetTrailer?: PacketTrailerPublishOptions;
+    packetTrailer?: FrameMetadataPublishOptions;
 };
 //# sourceMappingURL=types.d.ts.map

package/dist/ts4.2/e2ee/utils.d.ts

@@ -1,5 +1,6 @@
 import type { DataPacket } from '@livekit/protocol';
 import { EncryptedPacketPayload } from '@livekit/protocol';
+import type { NonSharedUint8Array } from '../type-polyfills/non-shared-typed-arrays';
 import type { KeyProviderOptions } from './types';
 export declare function isE2EESupported(): boolean;
 export declare function isScriptTransformSupported(): boolean;

package/dist/ts4.2/e2ee/worker/DataCryptor.d.ts

@@ -1,3 +1,4 @@
+import type { NonSharedUint8Array } from '../../type-polyfills/non-shared-typed-arrays';
 import type { DecodeRatchetOptions, KeySet } from '../types';
 import type { ParticipantKeyHandler } from './ParticipantKeyHandler';
 export declare class DataCryptor {

package/dist/ts4.2/e2ee/worker/FrameCryptor.d.ts

@@ -1,6 +1,7 @@
 import type TypedEventEmitter from 'typed-emitter';
-import type { PacketTrailerPublishOptions } from '../../packetTrailer/types';
+import type { FrameMetadataPublishOptions } from '../../frameMetadata/types';
 import type { VideoCodec } from '../../room/track/options';
+import type { NonSharedUint8Array } from '../../type-polyfills/non-shared-typed-arrays';
 import type { CryptorCallbacks } from '../events';
 import type { KeyProviderOptions } from '../types';
 import type { ParticipantKeyHandler } from './ParticipantKeyHandler';
@@ -43,9 +44,9 @@ export declare 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;
-    private packetTrailer?;
-    private packetTrailerFrameId;
+    private hasFrameMetadata;
+    private frameMetadataOpts?;
+    private frameMetadataFrameId;
     /**
      * Throttling mechanism for decryption errors to prevent memory leaks
      */
@@ -92,9 +93,9 @@ export declare class FrameCryptor extends BaseFrameCryptor {
      * trailer data. When false, {@link decodeFunction} skips the per-frame
      * trailer extraction branch entirely.
      */
-    setHasPacketTrailer(hasPacketTrailer: boolean): void;
-    setPacketTrailer(packetTrailer?: PacketTrailerPublishOptions): void;
-    setupTransform(operation: 'encode' | 'decode', readable: ReadableStream<RTCEncodedVideoFrame | RTCEncodedAudioFrame>, writable: WritableStream<RTCEncodedVideoFrame | RTCEncodedAudioFrame>, trackId: string, isReuse: boolean, codec?: VideoCodec, packetTrailer?: PacketTrailerPublishOptions): void;
+    setHasFrameMetadata(hasFrameMetadata: boolean): void;
+    setFrameMetadataOpts(frameMetadata?: FrameMetadataPublishOptions): void;
+    setupTransform(operation: 'encode' | 'decode', readable: ReadableStream<RTCEncodedVideoFrame | RTCEncodedAudioFrame>, writable: WritableStream<RTCEncodedVideoFrame | RTCEncodedAudioFrame>, trackId: string, isReuse: boolean, codec?: VideoCodec, frameMetadata?: FrameMetadataPublishOptions): void;
     setSifTrailer(trailer: NonSharedUint8Array): void;
     /**
      * Checks if we should emit an error based on throttling rules to prevent memory leaks
@@ -130,7 +131,7 @@ export declare class FrameCryptor extends BaseFrameCryptor {
      * 9) Enqueue the encrypted frame for sending.
      */
     protected encodeFunction(encodedFrame: RTCEncodedVideoFrame | RTCEncodedAudioFrame, controller: TransformStreamDefaultController): Promise<void>;
-    private appendPacketTrailer;
+    private appendFrameMetadata;
     /**
      * Function that will be injected in a stream and will decrypt the given encoded frames.
      *

package/dist/ts4.2/e2ee/worker/naluUtils.d.ts

@@ -2,6 +2,7 @@
  * NALU (Network Abstraction Layer Unit) utilities for H.264 and H.265 video processing
  * Contains functions for parsing and working with NALUs in video frames
  */
+import type { NonSharedUint8Array } from '../../type-polyfills/non-shared-typed-arrays';
 /**
  * Detected codec type from NALU analysis
  */

package/dist/ts4.2/e2ee/worker/sifPayload.d.ts

@@ -1,4 +1,5 @@
 import type { VideoCodec } from '../..';
+import type { NonSharedUint8Array } from '../../type-polyfills/non-shared-typed-arrays';
 export declare const VP8KeyFrame8x8: NonSharedUint8Array;
 export declare const H264KeyFrame2x2SPS: NonSharedUint8Array;
 export declare const H264KeyFrame2x2PPS: NonSharedUint8Array;

package/dist/ts4.2/{packetTrailer/PacketTrailerManager.d.ts → frameMetadata/FrameMetadataManager.d.ts}

@@ -1,5 +1,5 @@
 import type Room from '../room/Room';
-export interface PacketTrailerOptions {
+export interface FrameMetadataOptions {
     /**
      * Dedicated worker for extracting packet trailers off the main thread.
      *
@@ -24,7 +24,7 @@ export interface PacketTrailerOptions {
  *
  * @experimental
  */
-export declare class PacketTrailerManager {
+export declare class FrameMetadataManager {
     private worker?;
     private room?;
     private extractors;
@@ -35,7 +35,7 @@ export declare class PacketTrailerManager {
      * re-transferring already-consumed streams.
      */
     private workerPipelines;
-    constructor(options?: PacketTrailerOptions);
+    constructor(options?: FrameMetadataOptions);
     /** @internal */
     setup(room: Room): void;
     private setupReceiver;
@@ -46,4 +46,8 @@ export declare class PacketTrailerManager {
     private onWorkerMessage;
     private onWorkerError;
 }
-//# sourceMappingURL=PacketTrailerManager.d.ts.map
+/** @deprecated Use {@link FrameMetadataManager} instead. */
+export declare const PacketTrailerManager: typeof FrameMetadataManager;
+/** @deprecated Use {@link FrameMetadataOptions} instead. */
+export type PacketTrailerOptions = FrameMetadataOptions;
+//# sourceMappingURL=FrameMetadataManager.d.ts.map

package/dist/ts4.2/{packetTrailer/packetTrailer.d.ts → frameMetadata/frameMetadata.d.ts}

@@ -1,26 +1,27 @@
-import type { PacketTrailerMetadata, PacketTrailerPublishOptions } from './types';
+import type { FrameMetadata, FrameMetadataPublishOptions } from './types';
 export declare const PACKET_TRAILER_MAGIC: Uint8Array<ArrayBuffer>;
 export declare const PACKET_TRAILER_TIMESTAMP_TAG = 1;
 export declare const PACKET_TRAILER_FRAME_ID_TAG = 2;
+export declare const PACKET_TRAILER_USER_DATA_TAG = 3;
 export declare const PACKET_TRAILER_ENVELOPE_SIZE = 5;
 export interface ExtractPacketTrailerResult {
     data: Uint8Array;
-    metadata?: PacketTrailerMetadata;
+    metadata?: FrameMetadata;
 }
 export declare function appendPacketTrailer(data: Uint8Array, userTimestamp: bigint, frameId: number): Uint8Array;
-export declare function appendPacketTrailerToEncodedFrame(frame: RTCEncodedVideoFrame, options: PacketTrailerPublishOptions | undefined, frameId: number): boolean;
+export declare function appendPacketTrailerToEncodedFrame(frame: RTCEncodedVideoFrame, options: FrameMetadataPublishOptions | undefined, frameId: number): boolean;
 export declare function extractPacketTrailer(data: ArrayBuffer | Uint8Array): ExtractPacketTrailerResult;
 export declare function getFrameRtpTimestamp(frame: RTCEncodedVideoFrame | RTCEncodedAudioFrame): number | undefined;
 export declare function getFrameSsrc(frame: RTCEncodedVideoFrame | RTCEncodedAudioFrame): number;
-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;
 }
 /**
  * Extracts a packet trailer from an encoded frame and returns the stripped
@@ -29,4 +30,4 @@ export interface ProcessPacketTrailerResult {
  * a trackId isn't available.
  */
 export declare function processPacketTrailer(frame: RTCEncodedVideoFrame | RTCEncodedAudioFrame, trackId: string | undefined): ProcessPacketTrailerResult;
-//# sourceMappingURL=packetTrailer.d.ts.map
+//# sourceMappingURL=frameMetadata.d.ts.map

package/dist/ts4.2/{packetTrailer → frameMetadata}/types.d.ts

@@ -1,12 +1,17 @@
-import type { PacketTrailerFramePayload } from './packetTrailer';
-export interface PacketTrailerMetadata {
+import type { FrameMetadataPayload } from './frameMetadata';
+export interface FrameMetadata {
     userTimestamp: bigint;
     frameId: number;
+    userData?: Uint8Array;
 }
-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;
@@ -31,7 +36,7 @@ export interface PTEncodeMessage extends PTBaseMessage {
     data: {
         readableStream: ReadableStream;
         writableStream: WritableStream;
-        packetTrailer?: PacketTrailerPublishOptions;
+        packetTrailer?: FrameMetadataPublishOptions;
     };
 }
 export type PTScriptTransformOptions = {
@@ -39,11 +44,11 @@ export type PTScriptTransformOptions = {
     trackId: string;
 } | {
     kind: 'encode';
-    packetTrailer?: PacketTrailerPublishOptions;
+    packetTrailer?: FrameMetadataPublishOptions;
 };
 export interface PTMetadataMessage extends PTBaseMessage {
     kind: 'metadata';
-    data: PacketTrailerFramePayload;
+    data: FrameMetadataPayload;
 }
 export interface PTUpdateTrackIdMessage extends PTBaseMessage {
     kind: 'updateTrackId';

package/dist/ts4.2/frameMetadata/utils.d.ts

@@ -0,0 +1,9 @@
+import { PacketTrailerFeature } from '@livekit/protocol';
+import type { FrameMetadataOptions } from './FrameMetadataManager';
+import type { FrameMetadataPublishOptions } from './types';
+export declare function shouldUseFrameMetadataScriptTransform(): boolean;
+export declare function isFrameMetadataSupported(options?: FrameMetadataOptions): boolean;
+export declare function hasFrameMetadataPublishOptions(options?: FrameMetadataPublishOptions): boolean;
+export declare function getFrameMetadataFeatures(options?: FrameMetadataPublishOptions): PacketTrailerFeature[];
+export declare function getFrameMetadataPublishOptions(features?: PacketTrailerFeature[]): FrameMetadataPublishOptions | undefined;
+//# sourceMappingURL=utils.d.ts.map

package/dist/ts4.2/frameMetadata/worker/frameMetadata.worker.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=frameMetadata.worker.d.ts.map

package/dist/ts4.2/index.d.ts

@@ -33,9 +33,15 @@ import { compareVersions, createAudioAnalyser, getEmptyAudioStreamTrack, getEmpt
 import { getBrowser } from './utils/browserParser';
 export type { RpcInvocationData, PerformRpcParams } from './room/rpc';
 export { RpcError } from './room/rpc';
-export type { PacketTrailerMetadata, PacketTrailerPublishOptions } from './packetTrailer/types';
-export type { PacketTrailerOptions } from './packetTrailer/PacketTrailerManager';
-export { PacketTrailerManager } from './packetTrailer/PacketTrailerManager';
+export type { FrameMetadata, FrameMetadataPublishOptions, 
+/** @deprecated Use {@link FrameMetadata} instead. */
+PacketTrailerMetadata, 
+/** @deprecated Use {@link FrameMetadataPublishOptions} instead. */
+PacketTrailerPublishOptions, } from './frameMetadata/types';
+export type { FrameMetadataOptions, PacketTrailerOptions } from './frameMetadata/FrameMetadataManager';
+export { FrameMetadataManager, 
+/** @deprecated Use {@link FrameMetadataManager} instead. */
+PacketTrailerManager } from './frameMetadata/FrameMetadataManager';
 export * from './connectionHelper/ConnectionCheck';
 export * from './connectionHelper/checks/Checker';
 export * from './e2ee';

package/dist/ts4.2/options.d.ts

@@ -1,5 +1,5 @@
 import type { E2EEOptions } from './e2ee/types';
-import type { PacketTrailerOptions } from './packetTrailer/PacketTrailerManager';
+import type { FrameMetadataOptions } from './frameMetadata/FrameMetadataManager';
 import type { ReconnectPolicy } from './room/ReconnectPolicy';
 import type { AudioCaptureOptions, AudioOutputOptions, TrackPublishDefaults, VideoCaptureOptions } from './room/track/options';
 import type { AdaptiveStreamSettings } from './room/track/types';
@@ -81,10 +81,14 @@ export interface InternalRoomOptions {
     loggerName?: string;
     /**
      * @experimental
-     * Options for enabling packet trailers on video tracks.
-     * Packet trailers carry frame-level metadata such as user timestamps and frame IDs.
+     * Options for enabling frame metadata on video tracks.
+     * Frame metadata carries frame-level information such as user timestamps and frame IDs.
      */
-    packetTrailer?: PacketTrailerOptions;
+    frameMetadata?: FrameMetadataOptions;
+    /**
+     * @deprecated Use {@link InternalRoomOptions.frameMetadata} instead.
+     */
+    packetTrailer?: FrameMetadataOptions;
     /**
      * will attempt to connect via single peer connection mode.
      * falls back to dual peer connection mode if not available.

package/dist/ts4.2/room/PCTransport.d.ts

@@ -1,4 +1,4 @@
-import type { MediaAttributes } from 'sdp-transform';
+import type { MediaAttributes, MediaDescription } from 'sdp-transform';
 import type TypedEmitter from 'typed-emitter';
 import type { LoggerOptions } from './types';
 /** @internal */
@@ -54,6 +54,14 @@ export default class PCTransport extends PCTransport_base {
     } | undefined>;
     createAndSendOffer(options?: RTCOfferOptions): Promise<void>;
     createAndSetAnswer(): Promise<RTCSessionDescriptionInit>;
+    /**
+     * Returns the mids of transceivers that carry no outgoing track on this
+     * (publisher) connection: the pre-populated placeholders added by
+     * `RTCEngine.applyInitialPublisherLayout`, plus any transceiver that was used
+     * for a track and reverted on unpublish. Their codec fmtp is conformed to the
+     * published tracks so a shared payload type stays consistent across the bundle.
+     */
+    private getPlaceholderMids;
     createDataChannel(label: string, dataChannelDict: RTCDataChannelInit): RTCDataChannel;
     addTransceiver(mediaStreamTrack: MediaStreamTrack, transceiverInit: RTCRtpTransceiverInit): RTCRtpTransceiver;
     addTransceiverOfKind(kind: 'audio' | 'video', transceiverInit: RTCRtpTransceiverInit): RTCRtpTransceiver;
@@ -70,11 +78,43 @@ export default class PCTransport extends PCTransport_base {
     getLocalDescription(): RTCSessionDescription | null | undefined;
     getRemoteDescription(): RTCSessionDescription | null;
     getStats(): Promise<RTCStatsReport>;
+    getMaxMessageSize(): number | undefined;
     getConnectedAddress(): Promise<string | undefined>;
     close: () => void;
     private setMungedSDP;
     private ensureVideoDDExtensionForSVC;
 }
+/**
+ * Returns the mids of transceivers that carry no outgoing track: the
+ * pre-populated placeholders added by `RTCEngine.applyInitialPublisherLayout`,
+ * plus any transceiver that was used for a track and reverted on unpublish. The
+ * `sender.track` check is the reliable signal — an unpublished section keeps its
+ * `a=msid` (and its stale send-derived fmtp), so it can't be told apart from a
+ * real send by SDP alone. Transceiver mids are stable across renegotiations, so
+ * this works for every offer/answer after the first.
+ * @internal
+ */
+export declare function placeholderMidsFromTransceivers(transceivers: readonly RTCRtpTransceiver[]): Set<string>;
+/**
+ * Within a BUNDLE group a payload type must map to identical codec parameters
+ * across every m-line. When the same payload type carries different fmtp between
+ * sections — e.g. opus `usedtx=1` on the published microphone but not on the
+ * pre-populated recvonly placeholders, or H.265 with different `level-id` between
+ * a published video track and a placeholder — libwebrtc flags a "bundled payload
+ * type collision".
+ *
+ * Rewrite the placeholder sections so every shared payload type carries the
+ * same fmtp. Real (non-placeholder) sections always win the canonical value, so
+ * a published track's encoder parameters are never altered. When no real
+ * section declares a payload type — e.g. a placeholder that was reused for a
+ * track and then reverted to recvonly keeps its send-derived `level-id` while
+ * fresh placeholders use the default — the placeholders still converge on the
+ * first value seen, so two placeholders can't disagree either. Only placeholder
+ * sections are ever rewritten, and it is codec-agnostic (opus, H.265, ...).
+ * `isPlaceholder` identifies the sections to conform.
+ * @internal
+ */
+export declare function conformBundledCodecFmtp(media: MediaDescription[], isPlaceholder: (media: MediaDescription) => boolean): void;
 type PCTransportEventCallbacks = {
     negotiationStarted: () => void;
     negotiationComplete: () => void;

package/dist/ts4.2/room/PCTransportManager.d.ts

@@ -49,6 +49,7 @@ export declare class PCTransportManager {
     addPublisherTransceiver(track: MediaStreamTrack, transceiverInit: RTCRtpTransceiverInit): RTCRtpTransceiver;
     addPublisherTransceiverOfKind(kind: 'audio' | 'video', transceiverInit: RTCRtpTransceiverInit): RTCRtpTransceiver;
     getMidForReceiver(receiver: RTCRtpReceiver): string | null | undefined;
+    getMaxPublisherMessageSize(): number | undefined;
     addPublisherTrack(track: MediaStreamTrack): RTCRtpSender;
     createPublisherDataChannel(label: string, dataChannelDict: RTCDataChannelInit): RTCDataChannel;
     /**

package/dist/ts4.2/room/RTCEngine.d.ts

@@ -5,6 +5,7 @@ import type { SignalOptions } from '../api/SignalClient';
 import { SignalClient } from '../api/SignalClient';
 import type { BaseE2EEManager } from '../e2ee/E2eeManager';
 import type { InternalRoomOptions } from '../options';
+import type { NonSharedUint8Array } from '../type-polyfills/non-shared-typed-arrays';
 import PCTransport from './PCTransport';
 import { PCTransportManager } from './PCTransportManager';
 import { DataTrackInfo } from './data-track/types';
@@ -133,10 +134,12 @@ export default class RTCEngine extends RTCEngine_base {
     private handleDataMessage;
     private handleDataTrackMessage;
     private handleDataError;
+    private handleDataChannelClose;
     private handleBufferedAmountLow;
     createSender(track: LocalTrack, opts: TrackPublishOptions, encodings?: RTCRtpEncodingParameters[]): Promise<RTCRtpSender>;
     createSimulcastSender(track: LocalVideoTrack, simulcastTrack: SimulcastTrackInfo, opts: TrackPublishOptions, encodings?: RTCRtpEncodingParameters[]): Promise<RTCRtpSender | undefined>;
-    private setupPacketTrailerSender;
+    private get frameMetadataWorker();
+    private setupFrameMetadataSender;
     private createTransceiverRTCRtpSender;
     private createSimulcastTransceiverSender;
     private createRTCRtpSender;

package/dist/ts4.2/room/Room.d.ts

@@ -2,6 +2,7 @@ import { DataPacket_Kind, DisconnectReason, Encryption_Type, MetricsBatch, Parti
 import 'webrtc-adapter';
 import type TypedEmitter from 'typed-emitter';
 import type { InternalRoomOptions, RoomConnectOptions, RoomOptions } from '../options';
+import type { NonSharedUint8Array } from '../type-polyfills/non-shared-typed-arrays';
 import TypedPromise from '../utils/TypedPromise';
 import RTCEngine, { DataChannelKind } from './RTCEngine';
 import type { ByteStreamHandler, TextStreamHandler } from './data-stream/incoming/StreamReader';
@@ -68,7 +69,7 @@ declare class Room extends Room_base {
     private connectFuture?;
     private disconnectLock;
     private e2eeManager;
-    private packetTrailerManager;
+    private frameMetadataManager;
     private e2eeStateMutex;
     private connectionReconcileInterval?;
     private regionUrlProvider?;
@@ -135,7 +136,7 @@ declare class Room extends Room_base {
      */
     setE2EEEnabled(enabled: boolean): Promise<void>;
     private setupE2EE;
-    private setupPacketTrailer;
+    private setupFrameMetadata;
     private get logContext();
     /**
      * if the current room has a participant with `recorder: true` in its JWT grant

package/dist/ts4.2/room/data-track/frame.d.ts

@@ -1,3 +1,4 @@
+import type { NonSharedUint8Array } from '../../type-polyfills/non-shared-typed-arrays';
 import { DataTrackExtensions } from './packet/extensions';
 /** A pair of payload bytes and packet extensions which can be fed into a {@link DataTrackPacketizer}. */
 export type DataTrackFrame = {

package/dist/ts4.2/room/data-track/outgoing/types.d.ts

@@ -1,3 +1,4 @@
+import type { NonSharedUint8Array } from '../../../type-polyfills/non-shared-typed-arrays';
 import type LocalDataTrack from '../LocalDataTrack';
 import type { DataTrackHandle } from '../handle';
 import type { DataTrackInfo, DataTrackSid } from '../types';

package/dist/ts4.2/room/data-track/packet/extensions.d.ts

@@ -1,4 +1,5 @@
 import type { Throws } from '@livekit/throws-transformer/throws';
+import type { NonSharedUint8Array } from '../../../type-polyfills/non-shared-typed-arrays';
 import { DataTrackDeserializeError, DataTrackDeserializeErrorReason } from './errors';
 import Serializable from './serializable';
 export declare enum DataTrackExtensionTag {

package/dist/ts4.2/room/data-track/packet/index.d.ts

@@ -1,4 +1,5 @@
 import type { Throws } from '@livekit/throws-transformer/throws';
+import type { NonSharedUint8Array } from '../../../type-polyfills/non-shared-typed-arrays';
 import { DataTrackHandle } from '../handle';
 import { DataTrackTimestamp, U16_MAX_SIZE, WrapAroundUnsignedInt } from '../utils';
 import { DataTrackDeserializeError, DataTrackSerializeError, DataTrackSerializeErrorReason } from './errors';

package/dist/ts4.2/room/data-track/packet/serializable.d.ts

@@ -1,4 +1,5 @@
 import type { Throws } from '@livekit/throws-transformer/throws';
+import type { NonSharedUint8Array } from '../../../type-polyfills/non-shared-typed-arrays';
 import { DataTrackSerializeError } from './errors';
 /** An abstract class implementing common behavior related to data track binary serialization. */
 export default abstract class Serializable {

package/dist/ts4.2/room/participant/LocalParticipant.d.ts

@@ -1,5 +1,6 @@
 import { Codec, ParticipantInfo } from '@livekit/protocol';
 import type { InternalRoomOptions } from '../../options';
+import type { NonSharedUint8Array } from '../../type-polyfills/non-shared-typed-arrays';
 import TypedPromise from '../../utils/TypedPromise';
 import type RTCEngine from '../RTCEngine';
 import type OutgoingDataStreamManager from '../data-stream/outgoing/OutgoingDataStreamManager';
@@ -146,8 +147,8 @@ export default class LocalParticipant extends Participant {
     private waitUntilEngineConnected;
     private hasPermissionsToPublish;
     private publish;
-    private canPublishPacketTrailer;
-    private normalizeRequestedPacketTrailerOptions;
+    private canPublishFrameMetadata;
+    private normalizeRequestedFrameMetadataOptions;
     get isLocal(): boolean;
     /** @internal
      * publish additional codec to existing track

package/dist/ts4.2/room/participant/Participant.d.ts

@@ -2,6 +2,7 @@ import type { SipDTMF } from '@livekit/protocol';
 import { DataPacket_Kind, Encryption_Type, ParticipantInfo, ParticipantInfo_Kind as ParticipantKind, ParticipantPermission, ConnectionQuality as ProtoQuality, SubscriptionError } from '@livekit/protocol';
 import type TypedEmitter from 'typed-emitter';
 import type { StructuredLogger } from '../../logger';
+import type { NonSharedUint8Array } from '../../type-polyfills/non-shared-typed-arrays';
 import type LocalTrackPublication from '../track/LocalTrackPublication';
 import type LocalVideoTrack from '../track/LocalVideoTrack';
 import type RemoteTrack from '../track/RemoteTrack';

package/dist/ts4.2/room/token-source/types.d.ts

@@ -48,6 +48,7 @@ export type TokenSourceFetchOptions = {
     };
     agentName?: string;
     agentMetadata?: string;
+    deployment?: string;
 };
 /** A Configurable TokenSource is a token source that takes a
  * {@link TokenSourceFetchOptions} object as input and returns a deterministic

package/dist/ts4.2/room/track/FrameMetadataExtractor.d.ts

@@ -0,0 +1,19 @@
+import type { FrameMetadata } from '../../frameMetadata/types';
+/**
+ * Caches frame metadata extracted from received video frames,
+ * keyed by RTP timestamp so it can be looked up when the frame is displayed.
+ *
+ * Metadata is populated either by the frame metadata worker managed by
+ * `FrameMetadataManager` (non-E2EE) or by the E2EE FrameCryptor worker
+ * after decryption (E2EE).
+ *
+ * @experimental
+ */
+export declare class FrameMetadataExtractor {
+    private metadataMap;
+    private activeSsrc;
+    storeMetadata(rtpTimestamp: number, ssrc: number, metadata: FrameMetadata): void;
+    lookupMetadata(rtpTimestamp: number): FrameMetadata | undefined;
+    dispose(): void;
+}
+//# sourceMappingURL=FrameMetadataExtractor.d.ts.map

package/dist/ts4.2/room/track/RemoteVideoTrack.d.ts

@@ -1,7 +1,7 @@
-import type { PacketTrailerMetadata } from '../../packetTrailer/types';
+import type { FrameMetadata } from '../../frameMetadata/types';
 import type { VideoReceiverStats } from '../stats';
 import type { LoggerOptions } from '../types';
-import type { PacketTrailerExtractor } from './PacketTrailerExtractor';
+import type { FrameMetadataExtractor } from './FrameMetadataExtractor';
 import RemoteTrack from './RemoteTrack';
 import { Track } from './Track';
 import type { AdaptiveStreamSettings } from './types';
@@ -12,7 +12,7 @@ export default class RemoteVideoTrack extends RemoteTrack<Track.Kind.Video> {
     private lastVisible?;
     private lastDimensions?;
     /** @internal */
-    packetTrailerExtractor?: PacketTrailerExtractor;
+    frameMetadataExtractor?: FrameMetadataExtractor;
     constructor(mediaTrack: MediaStreamTrack, sid: string, receiver: RTCRtpReceiver, adaptiveStreamSettings?: AdaptiveStreamSettings, loggerOptions?: LoggerOptions);
     get isAdaptiveStream(): boolean;
     /**
@@ -20,13 +20,13 @@ export default class RemoteVideoTrack extends RemoteTrack<Track.Kind.Video> {
      * Use with the `TrackEvent.TimeSyncUpdate` event to correlate displayed frames
      * with their capture-time metadata.
      *
-     * Requires the room to be configured with the `packetTrailer` worker option
-     * and the publishing track to have packet trailer features enabled.
+     * Requires the room to be configured with the `frameMetadata` worker option
+     * and the publishing track to have frame metadata features enabled.
      *
      */
-    lookupFrameMetadata({ rtpTimestamp, }: {
+    lookupFrameMetadata({ rtpTimestamp }: {
         rtpTimestamp: number;
-    }): PacketTrailerMetadata | undefined;
+    }): FrameMetadata | undefined;
     setStreamState(value: Track.StreamState): void;
     /**
      * Note: When using adaptiveStream, you need to use remoteVideoTrack.attach() to add the track to a HTMLVideoElement, otherwise your video tracks might never start

package/dist/ts4.2/room/track/Track.d.ts

@@ -2,6 +2,7 @@ import { AudioTrackFeature, StreamState as ProtoStreamState, TrackSource, TrackT
 import type TypedEventEmitter from 'typed-emitter';
 import type { SignalClient } from '../../api/SignalClient';
 import type { StructuredLogger } from '../../logger';
+import type { NonSharedUint8Array } from '../../type-polyfills/non-shared-typed-arrays';
 import type { LoggerOptions } from '../types';
 import type { TrackProcessor } from './processor/types';
 export declare enum VideoQuality {