@webex/plugin-meetings 3.12.0-next.91 → 3.12.0-next.93

package/src/common/errors/webex-errors.ts

@@ -157,19 +157,63 @@ WebExMeetingsErrors[IceGatheringFailed.CODE] = IceGatheringFailed;
 class AddMediaFailed extends WebexMeetingsError {
   static CODE = 30203;
   cause?: Error;
+  connectionType?: string;
+  selectedCandidatePairChanges?: number;
+  numTransports?: number;
+  iceConnected?: boolean;
 
   /**
    * Creates a new AddMediaFailed error
-   * @param {Error} [cause] - The underlying error that caused the media addition to fail
+   * @param {Object} options
+   * @param {Error} [options.cause] - The underlying error that caused the media addition to fail
+   * @param {string} [options.connectionType] - The ICE connection type at the time of failure (e.g. 'UDP', 'TURN-TLS')
+   * @param {number} [options.selectedCandidatePairChanges] - Number of times the selected candidate pair changed
+   * @param {number} [options.numTransports] - Number of ICE transports
+   * @param {boolean} [options.iceConnected] - Whether ICE connection was established before the failure
    */
-  constructor(cause?: Error) {
+  constructor(
+    options: {
+      cause?: Error;
+      connectionType?: string;
+      selectedCandidatePairChanges?: number;
+      numTransports?: number;
+      iceConnected?: boolean;
+    } = {}
+  ) {
     super(AddMediaFailed.CODE, 'Failed to add media');
-    this.cause = cause;
+    this.cause = options.cause;
+    this.connectionType = options.connectionType;
+    this.selectedCandidatePairChanges = options.selectedCandidatePairChanges;
+    this.numTransports = options.numTransports;
+    this.iceConnected = options.iceConnected;
+  }
+
+  /**
+   * Returns true if the failure was due to a DTLS handshake failure
+   * (ICE connected successfully but the overall media connection failed).
+   */
+  get isDtlsHandshakeFailure(): boolean {
+    return this.iceConnected === true;
   }
 }
 export {AddMediaFailed};
 WebExMeetingsErrors[AddMediaFailed.CODE] = AddMediaFailed;
 
+/**
+ * @class MediaConnectionTimedOutError
+ * @classdesc Internal error thrown when the media connection times out waiting to connect.
+ */
+class MediaConnectionTimedOutError extends Error {
+  iceConnected: boolean;
+
+  constructor(message: string, iceConnected: boolean) {
+    super(message);
+    this.name = 'MediaConnectionTimedOutError';
+    this.iceConnected = iceConnected;
+  }
+}
+export {MediaConnectionTimedOutError};
+
 /**
  * @class SdpResponseTimeoutError
  * @classdesc Raised whenever we timeout waiting for remote SDP answer

package/src/locus-info/index.ts

@@ -518,7 +518,7 @@ export default class LocusInfo extends EventsScope {
     this.updateControls(locus.controls, locus.self);
     this.updateLocusUrl(locus.url, ControlsUtils.isMainSessionDTO(locus));
     this.updateFullState(locus.fullState);
-    this.updateMeetingInfo(locus.info);
+    this.updateMeetingInfo(locus.info, locus.self);
     this.updateEmbeddedApps(locus.embeddedApps);
     // self and participants generate sipUrl for 1:1 meeting
     this.updateSelf(locus.self);
@@ -2491,9 +2491,19 @@ export default class LocusInfo extends EventsScope {
    */
   updateMeetingInfo(info: object, self?: object) {
     const roles = self ? SelfUtils.getRoles(self) : this.parsedLocus.self?.roles || [];
-    if ((info && !isEqual(this.info, info)) || (!isEqual(this.roles, roles) && info)) {
-      const isJoined = SelfUtils.isJoined(self || this.parsedLocus.self);
-      const parsedInfo = InfoUtils.getInfos(this.parsedLocus.info, info, roles, isJoined);
+    const isJoined = SelfUtils.isJoined(self || this.parsedLocus.self);
+
+    // The parsed userDisplayHints depend on info, roles and isJoined, so we must recompute
+    // whenever any of them changes. A common case is self transitioning to JOINED via a delta
+    // that doesn't carry an info section - in that case we fall back to the previously stored
+    // info so the hints get reparsed with the new joined state (e.g. VIEW_THE_PARTICIPANT_LIST).
+    const infoToParse = info || this.info;
+    const infoChanged = info && !isEqual(this.info, info);
+    const rolesChanged = !isEqual(this.roles, roles);
+    const isJoinedChanged = SelfUtils.isJoined(this.parsedLocus.self) !== isJoined;
+
+    if (infoToParse && (infoChanged || rolesChanged || isJoinedChanged)) {
+      const parsedInfo = InfoUtils.getInfos(this.parsedLocus.info, infoToParse, roles, isJoined);
 
       if (parsedInfo.updates.isLocked) {
         this.emitScoped(
@@ -2516,7 +2526,7 @@ export default class LocusInfo extends EventsScope {
         );
       }
 
-      this.info = info;
+      this.info = infoToParse;
       this.parsedLocus.info = parsedInfo.current;
       // Parses the info and adds necessary values
       this.updateMeeting(parsedInfo.current);

package/src/media/MediaConnectionAwaiter.ts

@@ -10,6 +10,10 @@ export interface MediaConnectionAwaiterProps {
   correlationId: string;
 }
 
+export interface FailureResult {
+  iceConnected: boolean;
+}
+
 /**
  * @class MediaConnectionAwaiter
  */
@@ -58,6 +62,17 @@ export default class MediaConnectionAwaiter {
     return this.webrtcMediaConnection.getConnectionState() === ConnectionState.Failed;
   }
 
+  /**
+   * Returns true if ICE connection state indicates connectivity.
+   *
+   * @returns {boolean}
+   */
+  private isIceConnected(): boolean {
+    const state = this.webrtcMediaConnection.getIceConnectionState();
+
+    return state === 'connected' || state === 'completed';
+  }
+
   /**
    * Returns true if the ICE Gathering is completed, false otherwise.
    *
@@ -105,7 +120,7 @@ export default class MediaConnectionAwaiter {
 
       this.defer.reject({
         iceConnected: this.iceConnected,
-      });
+      } satisfies FailureResult);
     }
 
     if (!this.isConnected()) {
@@ -148,7 +163,7 @@ export default class MediaConnectionAwaiter {
       `Media:MediaConnectionAwaiter#iceConnectionStateHandler --> ICE connection state change -> ${iceConnectionState}`
     );
 
-    if (iceConnectionState === 'connected' && !this.iceConnected) {
+    if (this.isIceConnected() && !this.iceConnected) {
       this.iceConnected = true;
     }
 
@@ -249,13 +264,13 @@ export default class MediaConnectionAwaiter {
 
     this.defer.reject({
       iceConnected: this.iceConnected,
-    });
+    } satisfies FailureResult);
   }
 
   /**
    * Waits for the webrtc media connection to be connected.
    *
-   * @returns {Promise}
+   * @returns {Promise<void>} In case of failure, the promise is rejected with FailureResult
    */
   waitForMediaConnectionConnected(): Promise<void> {
     if (this.isConnected()) {
@@ -269,6 +284,8 @@ export default class MediaConnectionAwaiter {
       'Media:MediaConnectionAwaiter#waitForMediaConnectionConnected --> Waiting for media connection to be connected'
     );
 
+    this.iceConnected = this.isIceConnected();
+
     this.webrtcMediaConnection.on(
       MediaConnectionEventNames.PEER_CONNECTION_STATE_CHANGED,
       this.peerConnectionStateCallback

package/src/media/index.ts

@@ -142,6 +142,7 @@ Media.createMediaConnection = (
     enableExtmap?: boolean;
     turnServerInfo?: TurnServerInfo;
     bundlePolicy?: BundlePolicy;
+    iceTransportPolicy?: RTCIceTransportPolicy;
     iceCandidatesTimeout?: number;
     disableAudioMainDtx?: boolean;
     enableAudioTwcc?: boolean;
@@ -157,6 +158,7 @@ Media.createMediaConnection = (
     enableExtmap,
     turnServerInfo,
     bundlePolicy,
+    iceTransportPolicy,
     iceCandidatesTimeout,
     disableAudioMainDtx,
     enableAudioTwcc,
@@ -167,7 +169,7 @@ Media.createMediaConnection = (
   const iceServers = [];
 
   // we might not have any TURN server if TURN discovery failed or wasn't done or we land on a video mesh node
-  if (turnServerInfo?.urls.length > 0) {
+  if (turnServerInfo && turnServerInfo.urls.length > 0) {
     // TURN-TLS server
     iceServers.push({
       urls: turnServerInfo.urls,
@@ -187,6 +189,10 @@ Media.createMediaConnection = (
       config.bundlePolicy = bundlePolicy;
     }
 
+    if (iceTransportPolicy) {
+      config.iceTransportPolicy = iceTransportPolicy;
+    }
+
     if (disableAudioMainDtx !== undefined) {
       config.disableAudioMainDtx = disableAudioMainDtx;
     }

package/src/meeting/index.ts

@@ -66,6 +66,7 @@ import {
   NoMediaEstablishedYetError,
   UserNotJoinedError,
   AddMediaFailed,
+  MediaConnectionTimedOutError,
   SdpResponseTimeoutError,
 } from '../common/errors/webex-errors';
 
@@ -76,6 +77,7 @@ import Roap, {type TurnDiscoveryResult, type TurnDiscoverySkipReason} from '../r
 import {type TurnServerInfo} from '../roap/types';
 import Media, {type BundlePolicy} from '../media';
 import MediaProperties from '../media/properties';
+import {type FailureResult as MediaConnectionAwaiterFailureResult} from '../media/MediaConnectionAwaiter';
 import MeetingStateMachine from './state';
 import {createMuteState} from './muteState';
 import LocusInfo, {LocusLLMEvent} from '../locus-info';
@@ -790,6 +792,7 @@ export default class Meeting extends StatelessWebexPlugin {
   private addMediaData: {
     retriedWithTurnServer: boolean;
     icePhaseCallback: () => string;
+    iceTransportPolicy?: RTCIceTransportPolicy;
   };
 
   private sendSlotManager: SendSlotManager = new SendSlotManager(LoggerProxy);
@@ -5685,6 +5688,8 @@ export default class Meeting extends StatelessWebexPlugin {
         joined = true;
       }
 
+      const shouldRetryMediaWithOnlyTurnTLS = await this.shouldRetryMediaWithOnlyTurnTLS(prevError);
+
       const mediaResponse = await this.addMediaInternal(
         () => {
           // callback is not called when UserNotJoinedError is thrown
@@ -5692,8 +5697,9 @@ export default class Meeting extends StatelessWebexPlugin {
             ? 'JOIN_MEETING_FINAL'
             : 'JOIN_MEETING_RETRY';
         },
-        turnServerInfo,
         forceTurnDiscovery,
+        turnServerInfo,
+        shouldRetryMediaWithOnlyTurnTLS ? 'relay' : undefined,
         mediaOptions
       );
 
@@ -7907,17 +7913,54 @@ export default class Meeting extends StatelessWebexPlugin {
     return `MC-${this.id.substring(0, 4)}`;
   }
 
+  /**
+   * Determines if the next media attempt should use only TURN-TLS (iceTransportPolicy='relay').
+   * We do this in the hope that it will minimize the chance of Homer sending DTLS packets on a wrong
+   * transport (as there will be only 1 transport) and dealing with firewalls that let STUN packets through, but block
+   * other UDP traffic.
+   *
+   * For clients landing on video mesh nodes (VMN), reachability might still have successful TLS (to public nodes)
+   * but TURN discovery will result in empty TURN urls array and iceTransportPolicy='relay' will still be overriden to undefined,
+   * see the code in establishMediaConnection()
+   *
+   * @param {Error} prevError - The error from the previous addMedia attempt
+   * @returns {Promise<boolean>}
+   */
+  private async shouldRetryMediaWithOnlyTurnTLS(prevError: Error | undefined): Promise<boolean> {
+    if (
+      this.isMultistream &&
+      prevError instanceof AddMediaFailed &&
+      prevError.isDtlsHandshakeFailure &&
+      prevError.connectionType === 'UDP'
+    ) {
+      const hasTlsReachability =
+        // @ts-ignore
+        await this.webex.meetings.reachability.isAnyClusterReachableViaProtocol('xtls');
+
+      if (hasTlsReachability) {
+        LoggerProxy.logger.info(
+          'Meeting:index#shouldRetryMediaWithOnlyTurnTLS --> previous attempt failed due to DTLS handshake failure over UDP and TLS reachability is available'
+        );
+
+        return true;
+      }
+    }
+
+    return false;
+  }
+
   /**
    * Creates a webrtc media connection and publishes streams to it
    *
    * @param {Object} turnServerInfo TURN server information
    * @param {BundlePolicy} [bundlePolicy] Bundle policy settings
-   * @param {AddMediaOptions} [options] Options for enabling/disabling audio/video
+   * @param {RTCIceTransportPolicy} [iceTransportPolicy] ICE transport policy override
    * @returns {RoapMediaConnection | MultistreamRoapMediaConnection}
    */
   private async createMediaConnection(
     turnServerInfo?: TurnServerInfo,
-    bundlePolicy?: BundlePolicy
+    bundlePolicy?: BundlePolicy,
+    iceTransportPolicy?: RTCIceTransportPolicy
   ) {
     this.rtcMetrics = this.isMultistream
       ? // @ts-ignore
@@ -7941,6 +7984,7 @@ export default class Meeting extends StatelessWebexPlugin {
         enableExtmap: this.config.enableExtmap,
         turnServerInfo,
         bundlePolicy,
+        iceTransportPolicy,
         // @ts-ignore - config coming from registerPlugin
         iceCandidatesTimeout: this.config.iceCandidatesGatheringTimeout,
         // @ts-ignore - config coming from registerPlugin
@@ -8067,7 +8111,7 @@ export default class Meeting extends StatelessWebexPlugin {
     try {
       await this.mediaProperties.waitForMediaConnectionConnected(this.correlationId);
     } catch (error) {
-      const {iceConnected} = error;
+      const {iceConnected} = error as MediaConnectionAwaiterFailureResult;
 
       if (!this.hasMediaConnectionConnectedAtLeastOnce) {
         // Only send CA event for join flow if we haven't successfully connected media yet
@@ -8107,13 +8151,10 @@ export default class Meeting extends StatelessWebexPlugin {
         });
       }
 
-      const timedOutError = new Error(
-        `Timed out waiting for media connection to be connected, correlationId=${this.correlationId}`
+      throw new MediaConnectionTimedOutError(
+        `Timed out waiting for media connection to be connected, correlationId=${this.correlationId}`,
+        iceConnected
       );
-
-      timedOutError.cause = error;
-
-      throw timedOutError;
     }
   }
 
@@ -8326,7 +8367,18 @@ export default class Meeting extends StatelessWebexPlugin {
         error
       );
 
-      throw new AddMediaFailed(error);
+      const {connectionType, selectedCandidatePairChanges, numTransports} =
+        await this.mediaProperties.getCurrentConnectionInfo();
+
+      const iceConnected = error instanceof MediaConnectionTimedOutError && error.iceConnected;
+
+      throw new AddMediaFailed({
+        cause: error,
+        connectionType,
+        selectedCandidatePairChanges,
+        numTransports,
+        iceConnected,
+      });
     }
   }
 
@@ -8401,7 +8453,21 @@ export default class Meeting extends StatelessWebexPlugin {
         ({turnServerInfo} = await this.doTurnDiscovery(isReconnecting, isForced));
       }
 
-      const mc = await this.createMediaConnection(turnServerInfo, bundlePolicy);
+      if (
+        (!turnServerInfo || !turnServerInfo.urls?.length) &&
+        this.addMediaData.iceTransportPolicy === 'relay'
+      ) {
+        LoggerProxy.logger.info(
+          `${LOG_HEADER} cannot do iceTransportPolicy=relay, because there is no turn server info available`
+        );
+        // drop the forced relay policy and use the default, because we don't have a TURN server
+        this.addMediaData.iceTransportPolicy = undefined;
+      }
+      const mediaConnection = await this.createMediaConnection(
+        turnServerInfo,
+        bundlePolicy,
+        this.addMediaData.iceTransportPolicy
+      );
 
       LoggerProxy.logger.info(
         `${LOG_HEADER} media connection created this.isMultistream=${this.isMultistream}`
@@ -8438,7 +8504,7 @@ export default class Meeting extends StatelessWebexPlugin {
         await this.remoteMediaManager.start();
       }
 
-      await mc.initiateOffer();
+      await mediaConnection.initiateOffer();
 
       await this.waitForRemoteSDPAnswer();
 
@@ -8506,6 +8572,9 @@ export default class Meeting extends StatelessWebexPlugin {
 
     this.isMultistream = false;
 
+    // reset iceTransportPolicy, because it's only applied for multistream media connections
+    this.addMediaData.iceTransportPolicy = undefined;
+
     if (this.mediaProperties.webrtcMediaConnection) {
       // close peer connection, but don't reset mute state information, because we will want to use it on the retry
       this.closePeerConnections(false);
@@ -8630,8 +8699,9 @@ export default class Meeting extends StatelessWebexPlugin {
   addMedia(options: AddMediaOptions = {}): Promise<void> {
     return this.addMediaInternal(
       () => (this.turnServerUsed ? 'JOIN_MEETING_FINAL' : 'JOIN_MEETING_RETRY'),
-      undefined,
       false,
+      undefined /* turnServerInfo - it will be fetched via doTurnDiscovery() */,
+      undefined /* iceTransportPolicy - we're relying on the default value */,
       options
     );
   }
@@ -8640,8 +8710,9 @@ export default class Meeting extends StatelessWebexPlugin {
    * Internal version of addMedia() with some more arguments for finer control of its behavior
    *
    * @param {Function} icePhaseCallback - callback to determine the icePhase for CA "client.ice.end" failure events
-   * @param {TurnServerInfo} turnServerInfo - TURN server information
    * @param {boolean} forceTurnDiscovery - if true, TURN discovery will be done
+   * @param {TurnServerInfo} turnServerInfo - TURN server information
+   * @param {RTCIceTransportPolicy} [iceTransportPolicy] - ICE transport policy override
    * @param {AddMediaOptions} options - same as options of the public addMedia() method
    * @returns {Promise<void>}
    * @protected
@@ -8649,12 +8720,14 @@ export default class Meeting extends StatelessWebexPlugin {
    */
   protected async addMediaInternal(
     icePhaseCallback: () => string,
-    turnServerInfo: TurnServerInfo,
-    forceTurnDiscovery,
+    forceTurnDiscovery: boolean,
+    turnServerInfo?: TurnServerInfo,
+    iceTransportPolicy?: RTCIceTransportPolicy,
     options: AddMediaOptions = {}
   ): Promise<void> {
     this.addMediaData.retriedWithTurnServer = false;
     this.addMediaData.icePhaseCallback = icePhaseCallback;
+    this.addMediaData.iceTransportPolicy = iceTransportPolicy;
 
     this.hasMediaConnectionConnectedAtLeastOnce = false;
     const LOG_HEADER = 'Meeting:index#addMedia -->';
@@ -8663,7 +8736,7 @@ export default class Meeting extends StatelessWebexPlugin {
         options
       )}, turnServerInfo=${JSON.stringify(
         turnServerInfo
-      )}, forceTurnDiscovery=${forceTurnDiscovery}`
+      )}, forceTurnDiscovery=${forceTurnDiscovery}, iceTransportPolicy=${iceTransportPolicy}`
     );
 
     if (options.allowMediaInLobby !== true && this.meetingState !== FULL_STATE.ACTIVE) {
@@ -8777,12 +8850,7 @@ export default class Meeting extends StatelessWebexPlugin {
 
           // Establish new media connection with forced TURN discovery
           // We need to do TURN discovery again, because backend will be creating a new confluence, so it might land on a different node or cluster
-          await this.establishMediaConnection(
-            remoteMediaManagerConfig,
-            bundlePolicy,
-            true,
-            undefined
-          );
+          await this.establishMediaConnection(remoteMediaManagerConfig, bundlePolicy, true);
         } else {
           throw error;
         }
@@ -8812,6 +8880,7 @@ export default class Meeting extends StatelessWebexPlugin {
         isMultistream: this.isMultistream,
         retriedWithTurnServer: this.addMediaData.retriedWithTurnServer,
         isJoinWithMediaRetry: this.joinWithMediaRetryInfo.retryCount > 0,
+        iceTransportPolicy: this.addMediaData.iceTransportPolicy || 'all',
         ...reachabilityMetrics,
         ...iceCandidateErrors,
         iceCandidatesCount: this.iceCandidatesCount,
@@ -8833,14 +8902,16 @@ export default class Meeting extends StatelessWebexPlugin {
       // We can log ReceiveSlot SSRCs only after the SDP exchange, so doing it here:
       this.remoteMediaManager?.logAllReceiveSlots();
       this.startPeriodicLogUpload();
-    } catch (error) {
+    } catch (error: any) {
       LoggerProxy.logger.error(`${LOG_HEADER} failed to establish media connection: `, error);
 
       // @ts-ignore
       const reachabilityMetrics = await this.getMediaReachabilityMetricFields();
 
-      const {selectedCandidatePairChanges, numTransports} =
-        await this.mediaProperties.getCurrentConnectionInfo();
+      const {connectionType, selectedCandidatePairChanges, numTransports} =
+        error instanceof AddMediaFailed
+          ? error
+          : await this.mediaProperties.getCurrentConnectionInfo();
 
       const iceCandidateErrors = Object.fromEntries(this.iceCandidateErrors);
 
@@ -8857,6 +8928,7 @@ export default class Meeting extends StatelessWebexPlugin {
         retriedWithTurnServer: this.addMediaData.retriedWithTurnServer,
         isMultistream: this.isMultistream,
         isJoinWithMediaRetry: this.joinWithMediaRetryInfo.retryCount > 0,
+        iceTransportPolicy: this.addMediaData.iceTransportPolicy || 'all',
         signalingState:
           this.mediaProperties.webrtcMediaConnection?.multistreamConnection?.pc?.pc
             ?.signalingState ||
@@ -8872,6 +8944,7 @@ export default class Meeting extends StatelessWebexPlugin {
             ?.iceConnectionState ||
           this.mediaProperties.webrtcMediaConnection?.mediaConnection?.pc?.iceConnectionState ||
           'unknown',
+        connectionType,
         ...reachabilityMetrics,
         ...iceCandidateErrors,
         iceCandidatesCount: this.iceCandidatesCount,

package/src/reachability/clusterReachability.ts

@@ -6,13 +6,14 @@ import {Enum} from '../constants';
 import {
   ClusterReachabilityResult,
   NatType,
+  Protocol,
   ReachabilityPeerConnectionEvents,
 } from './reachability.types';
 import {ReachabilityPeerConnection} from './reachabilityPeerConnection';
 
 // data for the Events.resultReady event
 export type ResultEventData = {
-  protocol: 'udp' | 'tcp' | 'xtls';
+  protocol: Protocol;
   result: 'reachable' | 'unreachable' | 'untested';
   latencyInMilliseconds: number; // amount of time it took to get the ICE candidate
   clientMediaIPs?: string[];
@@ -20,7 +21,7 @@ export type ResultEventData = {
 
 // data for the Events.clientMediaIpsUpdated event
 export type ClientMediaIpsUpdatedEventData = {
-  protocol: 'udp' | 'tcp' | 'xtls';
+  protocol: Protocol;
   clientMediaIPs: string[];
 };
 

package/src/reachability/index.ts

@@ -25,6 +25,7 @@ import {
   TransportResultForBackend,
   GetClustersTrigger,
   NatType,
+  Protocol,
 } from './reachability.types';
 import {
   ClientMediaIpsUpdatedEventData,
@@ -569,6 +570,32 @@ export default class Reachability extends EventsScope {
     return unreachable;
   }
 
+  /**
+   * Checks if any cluster is reachable via the given protocol based on stored reachability results.
+   *
+   * @param {string} protocol - the protocol to check ('udp', 'tcp', or 'xtls')
+   * @returns {Promise<boolean>} true if at least one cluster has a 'reachable' result for the given protocol
+   */
+  async isAnyClusterReachableViaProtocol(protocol: Protocol): Promise<boolean> {
+    try {
+      // @ts-ignore
+      const resultsJson = await this.webex.boundedStorage.get(
+        this.namespace,
+        REACHABILITY.localStorageResult
+      );
+
+      const results: ReachabilityResults = JSON.parse(resultsJson);
+
+      return Object.values(results).some((result) => result[protocol]?.result === 'reachable');
+    } catch (e) {
+      LoggerProxy.logger.warn(
+        `Reachability:index#isAnyClusterReachableViaProtocol --> Error reading reachability data: ${e}`
+      );
+
+      return false;
+    }
+  }
+
   /**
    * Get list of all unreachable clusters
    * @returns {array} Unreachable clusters
@@ -701,7 +728,7 @@ export default class Reachability extends EventsScope {
    */
   protected getStatistics(
     results: Array<ClusterReachabilityResult & {isVideoMesh: boolean}>,
-    protocol: 'udp' | 'tcp' | 'xtls',
+    protocol: Protocol,
     isVideoMesh: boolean
   ) {
     const values = results

package/test/unit/spec/common/errors/webex-errors.ts

@@ -0,0 +1,62 @@
+import {assert} from '@webex/test-helper-chai';
+import {AddMediaFailed, MediaConnectionTimedOutError} from '@webex/plugin-meetings/src/common/errors/webex-errors';
+
+describe('MediaConnectionTimedOutError', () => {
+  [
+    {iceConnected: true, message: 'timeout with ice connected'},
+    {iceConnected: false, message: 'timeout without ice connected'},
+  ].forEach(({iceConnected, message}) => {
+    it(`stores message and iceConnected=${iceConnected}`, () => {
+      const error = new MediaConnectionTimedOutError(message, iceConnected);
+
+      assert.equal(error.message, message);
+      assert.equal(error.iceConnected, iceConnected);
+      assert.equal(error.name, 'MediaConnectionTimedOutError');
+      assert.instanceOf(error, Error);
+    });
+  });
+});
+
+describe('AddMediaFailed', () => {
+  it('stores all options properties', () => {
+    const cause = new Error('underlying');
+    const error = new AddMediaFailed({
+      cause,
+      connectionType: 'UDP',
+      selectedCandidatePairChanges: 3,
+      numTransports: 2,
+      iceConnected: true,
+    });
+
+    assert.equal(error.cause, cause);
+    assert.equal(error.connectionType, 'UDP');
+    assert.equal(error.selectedCandidatePairChanges, 3);
+    assert.equal(error.numTransports, 2);
+    assert.equal(error.iceConnected, true);
+    assert.equal(error.message, 'Failed to add media');
+  });
+
+  it('works with default empty options', () => {
+    const error = new AddMediaFailed();
+
+    assert.isUndefined(error.cause);
+    assert.isUndefined(error.connectionType);
+    assert.isUndefined(error.selectedCandidatePairChanges);
+    assert.isUndefined(error.numTransports);
+    assert.isUndefined(error.iceConnected);
+  });
+
+  describe('isDtlsHandshakeFailure', () => {
+    [
+      {iceConnected: true, expected: true},
+      {iceConnected: false, expected: false},
+      {iceConnected: undefined, expected: false},
+    ].forEach(({iceConnected, expected}) => {
+      it(`returns ${expected} when iceConnected=${iceConnected}`, () => {
+        const error = new AddMediaFailed({iceConnected});
+
+        assert.equal(error.isDtlsHandshakeFailure, expected);
+      });
+    });
+  });
+});