livekit-client 1.13.0 → 1.13.2

package/dist/ts4.2/src/e2ee/KeyProvider.d.ts

@@ -1,5 +1,6 @@
 import type TypedEventEmitter from 'typed-emitter';
-import type { KeyInfo, KeyProviderCallbacks, KeyProviderOptions } from './types';
+import type { KeyProviderCallbacks } from './events';
+import type { KeyInfo, KeyProviderOptions } from './types';
 declare const BaseKeyProvider_base: new () => TypedEventEmitter<KeyProviderCallbacks>;
 /**
  * @experimental
@@ -11,12 +12,12 @@ export declare class BaseKeyProvider extends BaseKeyProvider_base {
     /**
      * callback to invoke once a key has been set for a participant
      * @param key
-     * @param participantId
+     * @param participantIdentity
      * @param keyIndex
      */
-    protected onSetEncryptionKey(key: CryptoKey, participantId?: string, keyIndex?: number): void;
+    protected onSetEncryptionKey(key: CryptoKey, participantIdentity?: string, keyIndex?: number): void;
     /**
-     * callback being invoked after a ratchet request has been performed on the local participant
+     * callback being invoked after a ratchet request has been performed on a participant
      * that surfaces the new key material.
      * @param material
      * @param keyIndex
@@ -24,7 +25,7 @@ export declare class BaseKeyProvider extends BaseKeyProvider_base {
     protected onKeyRatcheted: (material: CryptoKey, keyIndex?: number) => void;
     getKeys(): KeyInfo[];
     getOptions(): KeyProviderOptions;
-    ratchetKey(participantId?: string, keyIndex?: number): void;
+    ratchetKey(participantIdentity?: string, keyIndex?: number): void;
 }
 /**
  * A basic KeyProvider implementation intended for a single shared
@@ -37,7 +38,7 @@ export declare class ExternalE2EEKeyProvider extends BaseKeyProvider {
     /**
      * Accepts a passphrase that's used to create the crypto keys.
      * When passing in a string, PBKDF2 is used.
-     * Also accepts an Array buffer of cryptographically random numbers that uses HKDF.
+     * When passing in an Array buffer of cryptographically random numbers, HKDF is being used. (recommended)
      * @param key
      */
     setKey(key: string | ArrayBuffer): Promise<void>;

package/dist/ts4.2/src/e2ee/events.d.ts

@@ -0,0 +1,34 @@
+import type Participant from '../room/participant/Participant';
+import type { CryptorError } from './errors';
+import type { KeyInfo } from './types';
+export declare enum KeyProviderEvent {
+    SetKey = "setKey",
+    RatchetRequest = "ratchetRequest",
+    KeyRatcheted = "keyRatcheted"
+}
+export type KeyProviderCallbacks = {
+    [KeyProviderEvent.SetKey]: (keyInfo: KeyInfo) => void;
+    [KeyProviderEvent.RatchetRequest]: (participantIdentity?: string, keyIndex?: number) => void;
+    [KeyProviderEvent.KeyRatcheted]: (material: CryptoKey, keyIndex?: number) => void;
+};
+export declare enum KeyHandlerEvent {
+    KeyRatcheted = "keyRatcheted"
+}
+export type ParticipantKeyHandlerCallbacks = {
+    [KeyHandlerEvent.KeyRatcheted]: (material: CryptoKey, participantIdentity: string, keyIndex?: number) => void;
+};
+export declare enum EncryptionEvent {
+    ParticipantEncryptionStatusChanged = "participantEncryptionStatusChanged",
+    EncryptionError = "encryptionError"
+}
+export type E2EEManagerCallbacks = {
+    [EncryptionEvent.ParticipantEncryptionStatusChanged]: (enabled: boolean, participant: Participant) => void;
+    [EncryptionEvent.EncryptionError]: (error: Error) => void;
+};
+export type CryptorCallbacks = {
+    [CryptorEvent.Error]: (error: CryptorError) => void;
+};
+export declare enum CryptorEvent {
+    Error = "cryptorError"
+}
+//# sourceMappingURL=events.d.ts.map

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

@@ -1,4 +1,5 @@
 export * from './KeyProvider';
 export * from './utils';
 export * from './types';
+export * from './events';
 //# sourceMappingURL=index.d.ts.map

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

@@ -1,7 +1,5 @@
-import type Participant from '../room/participant/Participant';
 import type { VideoCodec } from '../room/track/options';
 import type { BaseKeyProvider } from './KeyProvider';
-import type { CryptorError } from './errors';
 export interface BaseMessage {
     kind: string;
     data?: unknown;
@@ -15,7 +13,8 @@ export interface InitMessage extends BaseMessage {
 export interface SetKeyMessage extends BaseMessage {
     kind: 'setKey';
     data: {
-        participantId?: string;
+        participantIdentity?: string;
+        isPublisher: boolean;
         key: CryptoKey;
         keyIndex?: number;
     };
@@ -24,6 +23,7 @@ export interface RTPVideoMapMessage extends BaseMessage {
     kind: 'setRTPMap';
     data: {
         map: Map<number, VideoCodec>;
+        participantIdentity: string;
     };
 }
 export interface SifTrailerMessage extends BaseMessage {
@@ -35,7 +35,7 @@ export interface SifTrailerMessage extends BaseMessage {
 export interface EncodeMessage extends BaseMessage {
     kind: 'decode' | 'encode';
     data: {
-        participantId: string;
+        participantIdentity: string;
         readableStream: ReadableStream;
         writableStream: WritableStream;
         trackId: string;
@@ -45,14 +45,14 @@ export interface EncodeMessage extends BaseMessage {
 export interface RemoveTransformMessage extends BaseMessage {
     kind: 'removeTransform';
     data: {
-        participantId: string;
+        participantIdentity: string;
         trackId: string;
     };
 }
 export interface UpdateCodecMessage extends BaseMessage {
     kind: 'updateCodec';
     data: {
-        participantId: string;
+        participantIdentity: string;
         trackId: string;
         codec: VideoCodec;
     };
@@ -60,13 +60,14 @@ export interface UpdateCodecMessage extends BaseMessage {
 export interface RatchetRequestMessage extends BaseMessage {
     kind: 'ratchetRequest';
     data: {
-        participantId: string | undefined;
+        participantIdentity?: string;
         keyIndex?: number;
     };
 }
 export interface RatchetMessage extends BaseMessage {
     kind: 'ratchetKey';
     data: {
+        participantIdentity: string;
         keyIndex?: number;
         material: CryptoKey;
     };
@@ -80,11 +81,17 @@ export interface ErrorMessage extends BaseMessage {
 export interface EnableMessage extends BaseMessage {
     kind: 'enable';
     data: {
-        participantId?: string;
+        participantIdentity: string;
         enabled: boolean;
     };
 }
-export type E2EEWorkerMessage = InitMessage | SetKeyMessage | EncodeMessage | ErrorMessage | EnableMessage | RemoveTransformMessage | RTPVideoMapMessage | UpdateCodecMessage | RatchetRequestMessage | RatchetMessage | SifTrailerMessage;
+export interface InitAck extends BaseMessage {
+    kind: 'initAck';
+    data: {
+        enabled: boolean;
+    };
+}
+export type E2EEWorkerMessage = InitMessage | SetKeyMessage | EncodeMessage | ErrorMessage | EnableMessage | RemoveTransformMessage | RTPVideoMapMessage | UpdateCodecMessage | RatchetRequestMessage | RatchetMessage | SifTrailerMessage | InitAck;
 export type KeySet = {
     material: CryptoKey;
     encryptionKey: CryptoKey;
@@ -95,32 +102,9 @@ export type KeyProviderOptions = {
     ratchetWindowSize: number;
     failureTolerance: number;
 };
-export type KeyProviderCallbacks = {
-    setKey: (keyInfo: KeyInfo) => void;
-    ratchetRequest: (participantId?: string, keyIndex?: number) => void;
-    /** currently only emitted for local participant */
-    keyRatcheted: (material: CryptoKey, keyIndex?: number) => void;
-};
-export type ParticipantKeyHandlerCallbacks = {
-    keyRatcheted: (material: CryptoKey, keyIndex?: number, participantId?: string) => void;
-};
-export type E2EEManagerCallbacks = {
-    participantEncryptionStatusChanged: (enabled: boolean, participant?: Participant) => void;
-    encryptionError: (error: Error) => void;
-};
-export declare const EncryptionEvent: {
-    readonly ParticipantEncryptionStatusChanged: "participantEncryptionStatusChanged";
-    readonly Error: "encryptionError";
-};
-export type CryptorCallbacks = {
-    cryptorError: (error: CryptorError) => void;
-};
-export declare const CryptorEvent: {
-    readonly Error: "cryptorError";
-};
 export type KeyInfo = {
     key: CryptoKey;
-    participantId?: string;
+    participantIdentity?: string;
     keyIndex?: number;
 };
 export type E2EEOptions = {

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

@@ -1,7 +1,9 @@
 import type TypedEventEmitter from 'typed-emitter';
 import type { VideoCodec } from '../../room/track/options';
-import { CryptorCallbacks, DecodeRatchetOptions, KeyProviderOptions, KeySet } from '../types';
+import { CryptorCallbacks } from '../events';
+import type { KeyProviderOptions } from '../types';
 import type { ParticipantKeyHandler } from './ParticipantKeyHandler';
+export declare const encryptionEnabledMap: Map<string, boolean>;
 export interface FrameCryptorConstructor {
     new (opts?: unknown): BaseFrameCryptor;
 }
@@ -13,8 +15,8 @@ export interface TransformerInfo {
 }
 declare const BaseFrameCryptor_base: new () => TypedEventEmitter<CryptorCallbacks>;
 export declare class BaseFrameCryptor extends BaseFrameCryptor_base {
-    encodeFunction(encodedFrame: RTCEncodedVideoFrame | RTCEncodedAudioFrame, controller: TransformStreamDefaultController): Promise<any>;
-    decodeFunction(encodedFrame: RTCEncodedVideoFrame | RTCEncodedAudioFrame, controller: TransformStreamDefaultController): Promise<any>;
+    protected encodeFunction(encodedFrame: RTCEncodedVideoFrame | RTCEncodedAudioFrame, controller: TransformStreamDefaultController): Promise<any>;
+    protected decodeFunction(encodedFrame: RTCEncodedVideoFrame | RTCEncodedAudioFrame, controller: TransformStreamDefaultController): Promise<any>;
 }
 /**
  * Cryptor is responsible for en-/decrypting media frames.
@@ -22,7 +24,7 @@ export declare class BaseFrameCryptor extends BaseFrameCryptor_base {
  */
 export declare class FrameCryptor extends BaseFrameCryptor {
     private sendCounts;
-    private participantId;
+    private participantIdentity;
     private trackId;
     private keys;
     private videoCodec?;
@@ -35,7 +37,7 @@ export declare class FrameCryptor extends BaseFrameCryptor {
     private sifGuard;
     constructor(opts: {
         keys: ParticipantKeyHandler;
-        participantId: string;
+        participantIdentity: string;
         keyProviderOptions: KeyProviderOptions;
         sifTrailer?: Uint8Array;
     });
@@ -47,7 +49,8 @@ export declare class FrameCryptor extends BaseFrameCryptor {
      */
     setParticipant(id: string, keys: ParticipantKeyHandler): void;
     unsetParticipant(): void;
-    getParticipantId(): string | undefined;
+    isEnabled(): boolean | undefined;
+    getParticipantIdentity(): string | undefined;
     getTrackId(): string | undefined;
     /**
      * Update the video codec used by the mediaStreamTrack
@@ -60,6 +63,7 @@ export declare class FrameCryptor extends BaseFrameCryptor {
      */
     setRtpMap(map: Map<number, VideoCodec>): void;
     setupTransform(operation: 'encode' | 'decode', readable: ReadableStream, writable: WritableStream, trackId: string, codec?: VideoCodec): void;
+    setSifTrailer(trailer: Uint8Array): void;
     /**
      * Function that will be injected in a stream and will encrypt the given encoded frames.
      *
@@ -82,19 +86,19 @@ export declare class FrameCryptor extends BaseFrameCryptor {
      * 8) Append a single byte for the key identifier.
      * 9) Enqueue the encrypted frame for sending.
      */
-    encodeFunction(encodedFrame: RTCEncodedVideoFrame | RTCEncodedAudioFrame, controller: TransformStreamDefaultController): Promise<void>;
+    protected encodeFunction(encodedFrame: RTCEncodedVideoFrame | RTCEncodedAudioFrame, controller: TransformStreamDefaultController): Promise<void>;
     /**
      * Function that will be injected in a stream and will decrypt the given encoded frames.
      *
      * @param {RTCEncodedVideoFrame|RTCEncodedAudioFrame} encodedFrame - Encoded video frame.
      * @param {TransformStreamDefaultController} controller - TransportStreamController.
      */
-    decodeFunction(encodedFrame: RTCEncodedVideoFrame | RTCEncodedAudioFrame, controller: TransformStreamDefaultController): Promise<void>;
+    protected decodeFunction(encodedFrame: RTCEncodedVideoFrame | RTCEncodedAudioFrame, controller: TransformStreamDefaultController): Promise<void>;
     /**
      * Function that will decrypt the given encoded frame. If the decryption fails, it will
      * ratchet the key for up to RATCHET_WINDOW_SIZE times.
      */
-    decryptFrame(encodedFrame: RTCEncodedVideoFrame | RTCEncodedAudioFrame, keyIndex: number, initialMaterial?: KeySet | undefined, ratchetOpts?: DecodeRatchetOptions): Promise<RTCEncodedVideoFrame | RTCEncodedAudioFrame | undefined>;
+    private decryptFrame;
     /**
      * Construct the IV used for AES-GCM and sent (in plain) with the packet similar to
      * https://tools.ietf.org/html/rfc7714#section-8.1
@@ -115,12 +119,11 @@ export declare class FrameCryptor extends BaseFrameCryptor {
      * See also https://developer.mozilla.org/en-US/docs/Web/API/AesGcmParams
      */
     private makeIV;
-    getUnencryptedBytes(frame: RTCEncodedVideoFrame | RTCEncodedAudioFrame): number;
+    private getUnencryptedBytes;
     /**
      * inspects frame payloadtype if available and maps it to the codec specified in rtpMap
      */
-    getVideoCodec(frame: RTCEncodedVideoFrame): VideoCodec | undefined;
-    setSifTrailer(trailer: Uint8Array): void;
+    private getVideoCodec;
 }
 /**
  * Slice the NALUs present in the supplied buffer, assuming it is already byte-aligned

package/dist/ts4.2/src/e2ee/worker/ParticipantKeyHandler.d.ts

@@ -1,5 +1,6 @@
 import type TypedEventEmitter from 'typed-emitter';
-import type { KeyProviderOptions, KeySet, ParticipantKeyHandlerCallbacks } from '../types';
+import type { ParticipantKeyHandlerCallbacks } from '../events';
+import type { KeyProviderOptions, KeySet } from '../types';
 declare const ParticipantKeyHandler_base: new () => TypedEventEmitter<ParticipantKeyHandlerCallbacks>;
 /**
  * ParticipantKeyHandler is responsible for providing a cryptor instance with the
@@ -12,15 +13,13 @@ declare const ParticipantKeyHandler_base: new () => TypedEventEmitter<Participan
 export declare class ParticipantKeyHandler extends ParticipantKeyHandler_base {
     private currentKeyIndex;
     private cryptoKeyRing;
-    private enabled;
     private keyProviderOptions;
     private ratchetPromiseMap;
-    private participantId;
+    private participantIdentity;
     private decryptionFailureCount;
     private _hasValidKey;
     get hasValidKey(): boolean;
-    constructor(participantId: string | undefined, isEnabled: boolean, keyProviderOptions: KeyProviderOptions);
-    setEnabled(enabled: boolean): void;
+    constructor(participantIdentity: string, keyProviderOptions: KeyProviderOptions);
     decryptionFailure(): void;
     decryptionSuccess(): void;
     /**
@@ -50,16 +49,15 @@ export declare class ParticipantKeyHandler extends ParticipantKeyHandler_base {
      * also updates the currentKeyIndex
      */
     setKeyFromMaterial(material: CryptoKey, keyIndex?: number, emitRatchetEvent?: boolean): Promise<void>;
-    setKeySet(keySet: KeySet, keyIndex: number, emitRatchetEvent?: boolean): Promise<void>;
+    setKeySet(keySet: KeySet, keyIndex: number, emitRatchetEvent?: boolean): void;
     setCurrentKeyIndex(index: number): Promise<void>;
-    isEnabled(): boolean;
     getCurrentKeyIndex(): number;
     /**
      * returns currently used KeySet or the one at `keyIndex` if provided
      * @param keyIndex
      * @returns
      */
-    getKeySet(keyIndex?: number): KeySet;
+    getKeySet(keyIndex?: number): KeySet | undefined;
 }
 export {};
 //# sourceMappingURL=ParticipantKeyHandler.d.ts.map

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

@@ -32,6 +32,7 @@ export default class LocalParticipant extends Participant {
     constructor(sid: string, identity: string, engine: RTCEngine, options: InternalRoomOptions);
     get lastCameraError(): Error | undefined;
     get lastMicrophoneError(): Error | undefined;
+    get isE2EEEnabled(): boolean;
     getTrack(source: Track.Source): LocalTrackPublication | undefined;
     getTrackByName(name: string): LocalTrackPublication | undefined;
     /**

package/dist/ts4.2/src/room/track/processor/types.d.ts

@@ -23,7 +23,8 @@ export interface VideoProcessorOptions extends ProcessorOptions<Track.Kind.Video
  */
 export interface TrackProcessor<T extends Track.Kind, U extends ProcessorOptions<T> = ProcessorOptions<T>> {
     name: string;
-    init: (opts: U) => void;
+    init: (opts: U) => Promise<void>;
+    restart: (opts: U) => Promise<void>;
     destroy: () => Promise<void>;
     processedTrack?: MediaStreamTrack;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "livekit-client",
-  "version": "1.13.0",
+  "version": "1.13.2",
   "description": "JavaScript/TypeScript client SDK for LiveKit",
   "main": "./dist/livekit-client.umd.js",
   "unpkg": "./dist/livekit-client.umd.js",