livekit-client 2.18.0 → 2.18.2

package/src/e2ee/utils.ts

@@ -1,5 +1,6 @@
 import { type DataPacket, EncryptedPacketPayload } from '@livekit/protocol';
 import { ENCRYPTION_ALGORITHM } from './constants';
+import type { KeyProviderOptions } from './types';
 
 export function isE2EESupported() {
   return isInsertableStreamSupported() || isScriptTransformSupported();
@@ -92,8 +93,8 @@ function getAlgoOptions(algorithmName: string, salt: string) {
  * Derives a set of keys from the master key.
  * See https://tools.ietf.org/html/draft-omara-sframe-00#section-4.3.1
  */
-export async function deriveKeys(material: CryptoKey, salt: string) {
-  const algorithmOptions = getAlgoOptions(material.algorithm.name, salt);
+export async function deriveKeys(material: CryptoKey, options: KeyProviderOptions) {
+  const algorithmOptions = getAlgoOptions(material.algorithm.name, options.ratchetSalt);
 
   // https://developer.mozilla.org/en-US/docs/Web/API/SubtleCrypto/deriveKey#HKDF
   // https://developer.mozilla.org/en-US/docs/Web/API/HkdfParams
@@ -102,7 +103,7 @@ export async function deriveKeys(material: CryptoKey, salt: string) {
     material,
     {
       name: ENCRYPTION_ALGORITHM,
-      length: 128,
+      length: options.keySize,
     },
     false,
     ['encrypt', 'decrypt'],

package/src/e2ee/worker/DataCryptor.ts

@@ -93,10 +93,7 @@ export class DataCryptor {
             // if not, it might be that a different frame has already ratcheted and we try with that one first
             ratchetResult = await keys.ratchetKey(keyIndex, false);
 
-            ratchetedKeySet = await deriveKeys(
-              ratchetResult.cryptoKey,
-              keys.keyProviderOptions.ratchetSalt,
-            );
+            ratchetedKeySet = await deriveKeys(ratchetResult.cryptoKey, keys.keyProviderOptions);
           }
 
           const decryptedData = await DataCryptor.decrypt(

package/src/e2ee/worker/FrameCryptor.ts

@@ -603,10 +603,7 @@ export class FrameCryptor extends BaseFrameCryptor {
             // if not, it might be that a different frame has already ratcheted and we try with that one first
             ratchetResult = await this.keys.ratchetKey(keyIndex, false);
 
-            ratchetedKeySet = await deriveKeys(
-              ratchetResult.cryptoKey,
-              this.keyProviderOptions.ratchetSalt,
-            );
+            ratchetedKeySet = await deriveKeys(ratchetResult.cryptoKey, this.keyProviderOptions);
           }
 
           const frame = await this.decryptFrame(encodedFrame, keyIndex, initialMaterial || keySet, {

package/src/e2ee/worker/ParticipantKeyHandler.ts

@@ -173,7 +173,7 @@ export class ParticipantKeyHandler extends (EventEmitter as new () => TypedEvent
     ratchetedResult: RatchetResult | null = null,
     updateCurrentKeyIndex = true,
   ) {
-    const keySet = await deriveKeys(material, this.keyProviderOptions.ratchetSalt);
+    const keySet = await deriveKeys(material, this.keyProviderOptions);
     const newIndex = keyIndex >= 0 ? keyIndex % this.cryptoKeyRing.length : this.currentKeyIndex;
     workerLogger.debug(`setting new key with index ${keyIndex}`, {
       usage: material.usages,

package/src/index.ts

@@ -11,10 +11,8 @@ import DefaultReconnectPolicy from './room/DefaultReconnectPolicy';
 import type { ReconnectContext, ReconnectPolicy } from './room/ReconnectPolicy';
 import Room, { ConnectionState, type RoomEventCallbacks } from './room/Room';
 import * as attributes from './room/attribute-typings';
-// FIXME: remove this import in a follow up data track pull request.
-import './room/data-track/incoming/IncomingDataTrackManager';
-// FIXME: remove this import in a follow up data track pull request.
-import './room/data-track/outgoing/OutgoingDataTrackManager';
+import LocalDataTrack from './room/data-track/LocalDataTrack';
+import RemoteDataTrack, { type DataTrackSubscribeOptions } from './room/data-track/RemoteDataTrack';
 import LocalParticipant from './room/participant/LocalParticipant';
 import Participant, {
   ConnectionQuality,
@@ -142,6 +140,8 @@ export {
   isVideoTrack,
   isLocalParticipant,
   isRemoteParticipant,
+  LocalDataTrack,
+  RemoteDataTrack,
 };
 export type {
   AudioAnalyserOptions,
@@ -158,6 +158,7 @@ export type {
   RoomEventCallbacks,
   ParticipantEventCallbacks,
   PublicationEventCallbacks,
+  DataTrackSubscribeOptions,
 };
 export { DataTrackPacket, type DataTrackPacketHeader } from './room/data-track/packet';
 export {
@@ -165,5 +166,13 @@ export {
   type DataTrackUserTimestampExtension,
   type DataTrackE2eeExtension,
 } from './room/data-track/packet/extensions';
+export { type DataChannelKind } from './room/RTCEngine';
 
 export { LocalTrackRecorder } from './room/track/record';
+export {
+  type Serializer,
+  isSerializer,
+  type SerializerInput,
+  type SerializerOutput,
+  serializers,
+} from './utils/serializer';

package/src/room/PCTransport.ts

@@ -55,6 +55,8 @@ export default class PCTransport extends EventEmitter {
 
   private offerLock: Mutex;
 
+  private pendingInitialOffer?: RTCSessionDescriptionInit;
+
   pendingCandidates: RTCIceCandidateInit[] = [];
 
   restartingIce: boolean = false;
@@ -163,6 +165,16 @@ export default class PCTransport extends EventEmitter {
       this.remoteStereoMids = stereoMids;
       this.remoteNackMids = nackMids;
     } else if (sd.type === 'answer') {
+      if (this.pendingInitialOffer) {
+        const initialOffer = this.pendingInitialOffer;
+        this.pendingInitialOffer = undefined;
+        const sdpParsed = parse(initialOffer.sdp ?? '');
+        sdpParsed.media.forEach((media) => {
+          ensureIPAddrMatchVersion(media);
+        });
+        this.log.debug('setting pending initial offer before processing answer', this.logContext);
+        await this.setMungedSDP(initialOffer, write(sdpParsed));
+      }
       const sdpParsed = parse(sd.sdp ?? '');
       sdpParsed.media.forEach((media) => {
         const mid = getMidString(media.mid!);
@@ -255,6 +267,31 @@ export default class PCTransport extends EventEmitter {
     }
   }, debounceInterval);
 
+  async createInitialOffer() {
+    const unlock = await this.offerLock.lock();
+    try {
+      if (this.pc.signalingState !== 'stable') {
+        this.log.warn(
+          'signaling state is not stable, cannot create initial offer',
+          this.logContext,
+        );
+        return;
+      }
+      const offerId = this.latestOfferId + 1;
+      this.latestOfferId = offerId;
+      const offer = await this.pc.createOffer();
+      this.pendingInitialOffer = { sdp: offer.sdp, type: offer.type };
+      const sdpParsed = parse(offer.sdp ?? '');
+      sdpParsed.media.forEach((media) => {
+        ensureIPAddrMatchVersion(media);
+      });
+      offer.sdp = write(sdpParsed);
+      return { offer, offerId };
+    } finally {
+      unlock();
+    }
+  }
+
   async createAndSendOffer(options?: RTCOfferOptions) {
     const unlock = await this.offerLock.lock();
 
@@ -268,7 +305,10 @@ export default class PCTransport extends EventEmitter {
         this.restartingIce = true;
       }
 
-      if (this._pc && this._pc.signalingState === 'have-local-offer') {
+      if (
+        this._pc &&
+        (this._pc.signalingState === 'have-local-offer' || this.pendingInitialOffer)
+      ) {
         // we're waiting for the peer to accept our offer, so we'll just wait
         // the only exception to this is when ICE restart is needed
         const currentSD = this._pc.remoteDescription;

package/src/room/PCTransportManager.ts

@@ -72,7 +72,7 @@ export class PCTransportManager {
     return this._mode;
   }
 
-  constructor(rtcConfig: RTCConfiguration, mode: PCMode, loggerOptions: LoggerOptions) {
+  constructor(mode: PCMode, loggerOptions: LoggerOptions, rtcConfig?: RTCConfiguration) {
     this.log = getLogger(loggerOptions.loggerName ?? LoggerNames.PCManager);
     this.loggerOptions = loggerOptions;