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

package/src/member/util.ts

@@ -140,6 +140,9 @@ const MemberUtil = {
   isPresenterAssignmentProhibited: (participant: Participant) =>
     participant && participant.presenterAssignmentNotAllowed,
 
+  isAttendeeAssignmentProhibited: (participant: Participant) =>
+    !!(participant && participant.attendeeAssignmentNotAllowed),
+
   /**
    * checks to see if the participant id is the same as the passed id
    * there are multiple ids that can be used
@@ -436,5 +439,31 @@ const MemberUtil = {
 
     return participantUrl;
   },
+
+  /**
+   * Collects all CSIs reported for a participant across all their devices,
+   * looking at both the top-level `csis` array and any `mediaSessions[].csi` values.
+   *
+   * @param {Object} participant - The locus participant object.
+   * @returns {Array<number>} unique CSIs for this participant
+   */
+  extractCsis: (participant: Participant): number[] => {
+    const csis = new Set<number>();
+
+    participant?.devices?.forEach((device: any) => {
+      device?.csis?.forEach((csi: number) => {
+        if (typeof csi === 'number') {
+          csis.add(csi);
+        }
+      });
+      device?.mediaSessions?.forEach((mediaSession: any) => {
+        if (typeof mediaSession?.csi === 'number') {
+          csis.add(mediaSession.csi);
+        }
+      });
+    });
+
+    return Array.from(csis);
+  },
 };
 export default MemberUtil;

package/src/members/index.ts

@@ -1,7 +1,7 @@
 /*!
  * Copyright (c) 2015-2020 Cisco Systems, Inc. See LICENSE file.
  */
-import {get, isEmpty, set} from 'lodash';
+import {get, isEmpty, isEqual, set} from 'lodash';
 // @ts-ignore
 import {StatelessWebexPlugin} from '@webex/webex-core';
 
@@ -15,6 +15,7 @@ import {
 } from '../constants';
 import Trigger from '../common/events/trigger-proxy';
 import Member from '../member';
+import MemberUtil from '../member/util';
 import LoggerProxy from '../common/logs/logger-proxy';
 import ParameterError from '../common/errors/parameter';
 import {
@@ -99,6 +100,15 @@ export default class Members extends StatelessWebexPlugin {
   selfId: any;
   type: any;
 
+  /**
+   * Map of CSI -> memberId that previously used the CSI in a Locus update.
+   * Keyed by CSI so findMemberByCsi can resolve it in O(1).
+   * Kept here (rather than on each Member) so it survives members being removed
+   * and re-added (e.g. when entering/leaving a breakout session).
+   * @private
+   */
+  private memberIdByHistoryCsi: Map<number, string> = new Map();
+
   namespace = MEETINGS;
 
   /**
@@ -315,6 +325,14 @@ export default class Members extends StatelessWebexPlugin {
    * @memberof Members
    */
   clearMembers() {
+    // capture CSIs of all current members before reset so findMemberByCsi can
+    // still resolve them if a member is later re-added (e.g. when leaving a
+    // breakout session)
+    Object.values(this.membersCollection.getAll()).forEach((member) => {
+      MemberUtil.extractCsis(member.participant).forEach((csi) =>
+        this.memberIdByHistoryCsi.set(csi, member.id)
+      );
+    });
     this.membersCollection.reset();
     Trigger.trigger(
       this,
@@ -569,6 +587,15 @@ export default class Members extends StatelessWebexPlugin {
    */
   private removeMembers(removedMembers: Array<string>) {
     removedMembers.forEach((memberId) => {
+      // capture CSIs before removal so findMemberByCsi can still resolve them
+      // if the member is later re-added (e.g. when leaving a breakout session)
+      // with a participant payload that no longer contains the original CSIs
+      const existingMember = this.membersCollection.get(memberId);
+      if (existingMember) {
+        MemberUtil.extractCsis(existingMember.participant).forEach((csi) =>
+          this.memberIdByHistoryCsi.set(csi, memberId)
+        );
+      }
       this.membersCollection.remove(memberId);
     });
   }
@@ -598,6 +625,19 @@ export default class Members extends StatelessWebexPlugin {
               set(member, prop, existingValue);
             }
           });
+
+          // remember CSIs the member used previously so findMemberByCsi can still
+          // resolve a CSI even after participant.devices[].csis no longer contains it.
+          // Skip re-extracting when devices haven't changed - existing history already covers them.
+          const devicesUnchanged = isEqual(
+            existingMember.participant?.devices,
+            member.participant?.devices
+          );
+          if (!devicesUnchanged) {
+            MemberUtil.extractCsis(existingMember.participant).forEach((csi) =>
+              this.memberIdByHistoryCsi.set(csi, member.id)
+            );
+          }
         }
       }
       this.membersCollection.set(member.id, member);
@@ -1096,12 +1136,16 @@ export default class Members extends StatelessWebexPlugin {
    * Transfers the host to another member
    * @param {String} memberId
    * @param {boolean} [moderator] default true
+   * @param {String} [breakoutLocusUrl] when provided, the request is sent against this locus url
+   * (i.e. the breakout session's locus) instead of the main session's locus url
    * @returns {Promise}
    * @public
    * @memberof Members
    */
-  public transferHostToMember(memberId: string, moderator = true) {
-    if (!this.locusUrl) {
+  public transferHostToMember(memberId: string, moderator = true, breakoutLocusUrl = '') {
+    const locusUrl = breakoutLocusUrl || this.locusUrl;
+
+    if (!locusUrl) {
       return Promise.reject(
         new ParameterError(
           'The associated locus url for this meetings members object must be defined.'
@@ -1113,11 +1157,14 @@ export default class Members extends StatelessWebexPlugin {
         new ParameterError('The member id must be defined to transfer host to the member.')
       );
     }
-    const options = MembersUtil.generateTransferHostMemberOptions(
+    const options: Record<string, any> = MembersUtil.generateTransferHostMemberOptions(
       memberId,
       moderator,
-      this.locusUrl
+      locusUrl
     );
+    if (breakoutLocusUrl && breakoutLocusUrl !== this.locusUrl) {
+      options.authorizingLocusUrl = this.locusUrl;
+    }
 
     return this.membersRequest.transferHostToMember(options);
   }
@@ -1161,18 +1208,34 @@ export default class Members extends StatelessWebexPlugin {
     );
   }
 
-  /** Finds a member that has any device with a csi matching provided value
+  /** Finds a member that has any device with a csi matching provided value.
+   * Falls back to the `memberIdByHistoryCsi` map so that a CSI a member used in
+   * a previous Locus update can still be resolved even if it is no longer
+   * present in `participant.devices[].csis`.
    *
    * @param {number} csi
    * @returns {Member}
    */
   findMemberByCsi(csi) {
-    return Object.values(this.membersCollection.getAll()).find((member) =>
+    const members = Object.values(this.membersCollection.getAll());
+
+    const currentMatch = members.find((member) =>
       // @ts-ignore
       member.participant?.devices?.find((device) =>
         device.csis?.find((memberCsi) => memberCsi === csi)
       )
     );
+
+    if (currentMatch) {
+      return currentMatch;
+    }
+
+    const historyMemberId = this.memberIdByHistoryCsi.get(csi);
+    if (historyMemberId) {
+      return this.membersCollection.get(historyMemberId);
+    }
+
+    return undefined;
   }
 
   /**

package/src/members/util.ts

@@ -13,7 +13,7 @@ import {
   ALIAS,
 } from '../constants';
 
-import {RoleAssignmentOptions, RoleAssignmentRequest, ServerRoleShape} from './types';
+import {RoleAssignmentOptions, RoleAssignmentRequest, ServerRoleShape, ServerRoles} from './types';
 import {Invitee} from '../meeting/type';
 
 const MembersUtil = {
@@ -330,12 +330,20 @@ const MembersUtil = {
     };
   },
 
-  getTransferHostToMemberRequestParams: (options) => {
-    const body = {
+  getTransferHostToMemberRequestParams: (options: any) => {
+    const body: Record<string, any> = {
       role: {
-        moderator: options.moderator,
+        roles: [
+          {
+            hasRole: true,
+            type: ServerRoles.Moderator,
+          },
+        ],
       },
     };
+    if (options.authorizingLocusUrl) {
+      body.authorizingLocusUrl = options.authorizingLocusUrl;
+    }
     const uri = `${options.locusUrl}/${PARTICIPANT}/${options.memberId}/${CONTROLS}`;
 
     return {

package/src/metrics/constants.ts

@@ -11,6 +11,7 @@ const BEHAVIORAL_METRICS = {
   ADD_MEDIA_SUCCESS: 'js_sdk_add_media_success',
   ADD_MEDIA_FAILURE: 'js_sdk_add_media_failures',
   ADD_MEDIA_RETRY: 'js_sdk_add_media_retry',
+  LOCUS_MEDIA_REQUEST_RETRY: 'js_sdk_locus_media_request_retry',
   ROAP_MERCURY_EVENT_RECEIVED: 'js_sdk_roap_mercury_received',
   CONNECTION_SUCCESS: 'js_sdk_connection_success',
   CONNECTION_FAILURE: 'js_sdk_connection_failures',
@@ -96,6 +97,9 @@ const BEHAVIORAL_METRICS = {
   SET_CUSTOM_CODEC_PARAMETERS_USED: 'js_sdk_set_custom_codec_parameters_used',
   MARK_CUSTOM_CODEC_PARAMETERS_FOR_DELETION_USED:
     'js_sdk_mark_custom_codec_parameters_for_deletion_used',
+  HASH_TREE_SYNC_FAILURE: 'js_sdk_hash_tree_sync_failure',
+  HASH_TREE_HEARTBEAT_WATCHDOG_EXPIRED: 'js_sdk_hash_tree_heartbeat_watchdog_expired',
+  HASH_TREE_EMPTY_LOCUS_STATE_ELEMENTS: 'js_sdk_hash_tree_empty_locus_state_elements',
 };
 
 export {BEHAVIORAL_METRICS as default};

package/src/multistream/codec/constants.ts

@@ -0,0 +1,58 @@
+import {AV1EncodingParams, SupportedResolution} from '@webex/internal-media-core';
+
+export const AV1_CODEC_PARAMETERS: Record<SupportedResolution, AV1EncodingParams> = {
+  '90p': {
+    levelIdx: 0,
+    tier: 0,
+    maxWidth: 160,
+    maxHeight: 90,
+    maxPicSize: 147_456,
+    maxDecodeRate: 5_529_600,
+  },
+  '180p': {
+    levelIdx: 0,
+    tier: 0,
+    maxWidth: 320,
+    maxHeight: 180,
+    maxPicSize: 147_456,
+    maxDecodeRate: 5_529_600,
+  },
+  '360p': {
+    levelIdx: 1,
+    tier: 0,
+    maxWidth: 640,
+    maxHeight: 360,
+    maxPicSize: 278_784,
+    maxDecodeRate: 10_454_400,
+  },
+  '540p': {
+    levelIdx: 4,
+    tier: 0,
+    maxWidth: 960,
+    maxHeight: 540,
+    maxPicSize: 665_856,
+    maxDecodeRate: 24_969_600,
+  },
+  '720p': {
+    levelIdx: 5,
+    tier: 0,
+    maxWidth: 1280,
+    maxHeight: 720,
+    maxPicSize: 1_065_024,
+    maxDecodeRate: 39_938_400,
+  },
+  '1080p': {
+    levelIdx: 8,
+    tier: 0,
+    maxWidth: 1920,
+    maxHeight: 1080,
+    maxPicSize: 2_359_296,
+    maxDecodeRate: 77_856_768,
+  },
+};
+
+export const H264_CODEC_PARAMETERS = {
+  maxFs: 8192,
+  maxFps: 3000,
+  maxMbps: 245760,
+};

package/src/multistream/mediaRequestManager.ts

@@ -9,6 +9,11 @@ import {
   getRecommendedMaxBitrateForFrameSize,
   RecommendedOpusBitrates,
   NamedMediaGroup,
+  AV1Codec,
+  SupportedResolution,
+  AV1EncodingParams,
+  MediaType,
+  MediaCodecMimeType,
 } from '@webex/internal-media-core';
 import {cloneDeepWith, debounce} from 'lodash';
 
@@ -16,6 +21,7 @@ import LoggerProxy from '../common/logs/logger-proxy';
 
 import {ReceiveSlot, ReceiveSlotEvents} from './receiveSlot';
 import {MAX_FS_VALUES} from './remoteMedia';
+import {AV1_CODEC_PARAMETERS, H264_CODEC_PARAMETERS} from './codec/constants';
 
 export interface ActiveSpeakerPolicyInfo {
   policy: 'active-speaker';
@@ -54,34 +60,49 @@ export interface MediaRequest {
 
 export type MediaRequestId = string;
 
-const CODEC_DEFAULTS = {
-  h264: {
-    maxFs: 8192,
-    maxFps: 3000,
-    maxMbps: 245760,
-  },
-};
-
 const DEBOUNCED_SOURCE_UPDATE_TIME = 1000;
 
+const RESOLUTION_BUCKETS: Array<[SupportedResolution, number]> = [
+  ['90p', MAX_FS_VALUES['90p']],
+  ['180p', MAX_FS_VALUES['180p']],
+  ['360p', MAX_FS_VALUES['360p']],
+  ['540p', MAX_FS_VALUES['540p']],
+  ['720p', MAX_FS_VALUES['720p']],
+];
+
 type DegradationPreferences = {
   maxMacroblocksLimit: number;
 };
 
 type SendMediaRequestsCallback = (streamRequests: StreamRequest[]) => void;
+type GetIngressPayloadTypeCallback = (
+  mediaType: MediaType,
+  codecMimeType: MediaCodecMimeType
+) => number | undefined;
 type Kind = 'audio' | 'video';
 
-type Options = {
+type AudioMediaRequestManagerOptions = {
   degradationPreferences: DegradationPreferences;
-  kind: Kind;
+  kind: 'audio';
   trimRequestsToNumOfSources: boolean; // if enabled, AS speaker requests will be trimmed based on the calls to setNumCurrentSources()
 };
 
+type VideoMediaRequestManagerOptions = {
+  degradationPreferences: DegradationPreferences;
+  kind: 'video';
+  trimRequestsToNumOfSources: boolean;
+  enableAv1?: boolean;
+};
+
+type Options = AudioMediaRequestManagerOptions | VideoMediaRequestManagerOptions;
+
 type ClientRequestsMap = {[key: MediaRequestId]: MediaRequest};
 
 export class MediaRequestManager {
   private sendMediaRequestsCallback: SendMediaRequestsCallback;
 
+  private getIngressPayloadTypeCallback: GetIngressPayloadTypeCallback;
+
   private kind: Kind;
 
   private counter: number;
@@ -95,11 +116,17 @@ export class MediaRequestManager {
   private debouncedSourceUpdateListener: () => void;
 
   private trimRequestsToNumOfSources: boolean;
+  private enableAv1: boolean;
   private numTotalSources: number;
   private numLiveSources: number;
 
-  constructor(sendMediaRequestsCallback: SendMediaRequestsCallback, options: Options) {
+  constructor(
+    sendMediaRequestsCallback: SendMediaRequestsCallback,
+    getIngressPayloadTypeCallback: GetIngressPayloadTypeCallback,
+    options: Options
+  ) {
     this.sendMediaRequestsCallback = sendMediaRequestsCallback;
+    this.getIngressPayloadTypeCallback = getIngressPayloadTypeCallback;
     this.counter = 0;
     this.numLiveSources = 0;
     this.numTotalSources = 0;
@@ -107,6 +134,7 @@ export class MediaRequestManager {
     this.degradationPreferences = options.degradationPreferences;
     this.kind = options.kind;
     this.trimRequestsToNumOfSources = options.trimRequestsToNumOfSources;
+    this.enableAv1 = options.kind === 'video' && !!options.enableAv1;
     this.sourceUpdateListener = this.commit.bind(this);
     this.debouncedSourceUpdateListener = debounce(
       this.sourceUpdateListener,
@@ -135,8 +163,8 @@ export class MediaRequestManager {
       Object.values(clientRequests).forEach((mr) => {
         if (mr.codecInfo) {
           mr.codecInfo.maxFs = Math.min(
-            mr.preferredMaxFs || CODEC_DEFAULTS.h264.maxFs,
-            mr.codecInfo.maxFs || CODEC_DEFAULTS.h264.maxFs,
+            mr.preferredMaxFs || H264_CODEC_PARAMETERS.maxFs,
+            mr.codecInfo.maxFs || H264_CODEC_PARAMETERS.maxFs,
             maxFsLimits[i]
           );
           // we only consider sources with "live" state
@@ -176,7 +204,7 @@ export class MediaRequestManager {
     }
 
     return getRecommendedMaxBitrateForFrameSize(
-      mediaRequest.codecInfo.maxFs || CODEC_DEFAULTS.h264.maxFs
+      mediaRequest.codecInfo.maxFs || H264_CODEC_PARAMETERS.maxFs
     );
   }
 
@@ -192,12 +220,80 @@ export class MediaRequestManager {
   // eslint-disable-next-line class-methods-use-this
   private getH264MaxMbps(mediaRequest: MediaRequest): number {
     // fallback for maxFps (not needed for maxFs, since there is a fallback already in getDegradedClientRequests)
-    const maxFps = mediaRequest.codecInfo.maxFps || CODEC_DEFAULTS.h264.maxFps;
+    const maxFps = mediaRequest.codecInfo.maxFps || H264_CODEC_PARAMETERS.maxFps;
 
     // divided by 100 since maxFps is 3000 (for 30 frames per seconds)
     return (mediaRequest.codecInfo.maxFs * maxFps) / 100;
   }
 
+  /**
+   * Returns the AV1 encoding parameters for a media request
+   * @param mediaRequest - The media request to get the AV1 encoding parameters for
+   * @returns {AV1EncodingParams} The AV1 encoding parameters
+   */
+  // eslint-disable-next-line class-methods-use-this
+  private getAv1EncodingParams(mediaRequest: MediaRequest): AV1EncodingParams {
+    const frameSize = mediaRequest.codecInfo.maxFs || H264_CODEC_PARAMETERS.maxFs;
+    const resolution = RESOLUTION_BUCKETS.find(([, maxFs]) => frameSize <= maxFs)?.[0] ?? '1080p';
+
+    return AV1_CODEC_PARAMETERS[resolution];
+  }
+
+  private buildH264CodecInfo(mr: MediaRequest): WcmeCodecInfo | undefined {
+    if (!mr.codecInfo) {
+      return undefined;
+    }
+
+    const h264PayloadType = this.getIngressPayloadTypeCallback(
+      mr.receiveSlots[0].mediaType,
+      MediaCodecMimeType.H264
+    );
+
+    if (h264PayloadType === undefined) {
+      return undefined;
+    }
+
+    return WcmeCodecInfo.fromH264(
+      h264PayloadType,
+      new H264Codec(
+        mr.codecInfo.maxFs,
+        mr.codecInfo.maxFps || H264_CODEC_PARAMETERS.maxFps,
+        this.getH264MaxMbps(mr),
+        mr.codecInfo.maxWidth,
+        mr.codecInfo.maxHeight
+      )
+    );
+  }
+
+  private buildAv1CodecInfo(mr: MediaRequest): WcmeCodecInfo | undefined {
+    if (!this.enableAv1 || !mr.codecInfo) {
+      return undefined;
+    }
+
+    const av1PayloadType = this.getIngressPayloadTypeCallback(
+      mr.receiveSlots[0].mediaType,
+      MediaCodecMimeType.AV1
+    );
+
+    if (av1PayloadType === undefined) {
+      return undefined;
+    }
+
+    const av1EncodingParams = this.getAv1EncodingParams(mr);
+
+    return WcmeCodecInfo.fromAv1(
+      av1PayloadType,
+      new AV1Codec(
+        av1EncodingParams.levelIdx,
+        av1EncodingParams.tier,
+        mr.codecInfo.maxWidth || av1EncodingParams.maxWidth,
+        mr.codecInfo.maxHeight || av1EncodingParams.maxHeight,
+        av1EncodingParams.maxPicSize,
+        av1EncodingParams.maxDecodeRate
+      )
+    );
+  }
+
   /** Modifies the passed in clientRequests and makes sure that in total they don't ask
    *  for more streams than there are available.
    *
@@ -298,6 +394,12 @@ export class MediaRequestManager {
     // map all the client media requests to wcme stream requests
     Object.values(clientRequests).forEach((mr) => {
       if (mr.receiveSlots.length > 0) {
+        const codecInfos: WcmeCodecInfo[] = mr.codecInfo
+          ? [this.buildH264CodecInfo(mr), this.buildAv1CodecInfo(mr)].filter(
+              (info): info is WcmeCodecInfo => info !== undefined
+            )
+          : [];
+
         streamRequests.push(
           new StreamRequest(
             mr.policyInfo.policy === 'active-speaker'
@@ -314,25 +416,14 @@ export class MediaRequestManager {
               : new ReceiverSelectedInfo(mr.policyInfo.csi),
             mr.receiveSlots.map((receiveSlot) => receiveSlot.wcmeReceiveSlot),
             this.getMaxPayloadBitsPerSecond(mr),
-            mr.codecInfo && [
-              WcmeCodecInfo.fromH264(
-                0x80,
-                new H264Codec(
-                  mr.codecInfo.maxFs,
-                  mr.codecInfo.maxFps || CODEC_DEFAULTS.h264.maxFps,
-                  this.getH264MaxMbps(mr),
-                  mr.codecInfo.maxWidth,
-                  mr.codecInfo.maxHeight
-                )
-              ),
-            ]
+            codecInfos
           )
         );
       }
     });
 
     this.sendMediaRequestsCallback(streamRequests);
-    LoggerProxy.logger.info(`multistream:sendRequests --> media requests sent. `);
+    LoggerProxy.logger.info(`multistream:sendRequests --> media requests sent.`);
   }
 
   public addRequest(mediaRequest: MediaRequest, commit = true): MediaRequestId {

package/src/multistream/receiveSlot.ts

@@ -134,6 +134,24 @@ export class ReceiveSlot extends EventsScope {
         });
       }
     );
+
+    this.mcReceiveSlot.on(WcmeReceiveSlotEvents.MediaStarted, () => {
+      LoggerProxy.logger.log(
+        `ReceiveSlot#setupEventListeners --> media started on receive slot ${this.id}, mediaType=${this.mediaType}`
+      );
+    });
+
+    this.mcReceiveSlot.on(WcmeReceiveSlotEvents.MediaStopped, () => {
+      LoggerProxy.logger.log(
+        `ReceiveSlot#setupEventListeners --> media stopped on receive slot ${this.id}, mediaType=${this.mediaType}`
+      );
+    });
+
+    this.mcReceiveSlot.on(WcmeReceiveSlotEvents.MediaEnded, () => {
+      LoggerProxy.logger.log(
+        `ReceiveSlot#setupEventListeners --> media ended on receive slot ${this.id}, mediaType=${this.mediaType}`
+      );
+    });
   }
 
   /** Tries to find the member id for this receive slot if it hasn't got one */

package/src/reachability/index.ts

@@ -33,6 +33,7 @@ import {
   NatTypeUpdatedEventData,
   ResultEventData,
 } from './clusterReachability';
+import {isReachabilityEnabled, resolveReachabilityProtocols} from './util';
 import EventsScope from '../common/events/events-scope';
 import BEHAVIORAL_METRICS from '../metrics/constants';
 import Metrics from '../metrics';
@@ -194,7 +195,7 @@ export default class Reachability extends EventsScope {
    */
   public async gatherReachability(trigger: string): Promise<ReachabilityResults> {
     // @ts-ignore
-    if (!this.webex.config.meetings.enableReachabilityChecks) {
+    if (!isReachabilityEnabled(this.webex.config.meetings.enableReachabilityChecks)) {
       throw new Error('enableReachabilityChecks is disabled in config');
     }
 
@@ -515,7 +516,7 @@ export default class Reachability extends EventsScope {
    * Returns true only if ALL protocols (UDP, TCP and TLS) have been tested and none
    * of the media clusters where reachable with any of the protocols. This is done
    * irrespective of the config, so for example:
-   * if config.meetings.experimental.enableTlsReachability === false,
+   * if config.meetings.enableReachabilityChecks disables TLS,
    * it will return false, because TLS reachability won't be tested,
    * so we can't say for sure that media backend is unreachable over TLS.
    *
@@ -888,14 +889,21 @@ export default class Reachability extends EventsScope {
 
     this.startTime = performance.now();
 
+    const protocols = resolveReachabilityProtocols(
+      // @ts-ignore
+      this.webex.config.meetings.enableReachabilityChecks
+    );
+
+    const enabledProtocols = [
+      protocols.udp && 'UDP',
+      protocols.tcp && 'TCP',
+      protocols.tls && 'TLS',
+    ].filter(Boolean);
+
     LoggerProxy.logger.log(
-      `Reachability:index#performReachabilityChecks --> doing UDP${
-        // @ts-ignore
-        this.webex.config.meetings.experimental.enableTcpReachability ? ',TCP' : ''
-      }${
-        // @ts-ignore
-        this.webex.config.meetings.experimental.enableTlsReachability ? ',TLS' : ''
-      } reachability checks`
+      `Reachability:index#performReachabilityChecks --> doing ${enabledProtocols.join(
+        ','
+      )} reachability checks`
     );
 
     this.resetResultCounters();
@@ -905,18 +913,14 @@ export default class Reachability extends EventsScope {
       const cluster = clusterList[key];
 
       // Linus doesn't support TCP reachability checks on video mesh nodes
-      const includeTcpReachability =
-        // @ts-ignore
-        this.webex.config.meetings.experimental.enableTcpReachability && !cluster.isVideoMesh;
+      const includeTcpReachability = protocols.tcp && !cluster.isVideoMesh;
 
       if (!includeTcpReachability) {
         cluster.tcp = [];
       }
 
       // Linus doesn't support xTLS reachability checks on video mesh nodes
-      const includeTlsReachability =
-        // @ts-ignore
-        this.webex.config.meetings.experimental.enableTlsReachability && !cluster.isVideoMesh;
+      const includeTlsReachability = protocols.tls && !cluster.isVideoMesh;
 
       if (!includeTlsReachability) {
         cluster.xtls = [];

package/src/reachability/reachability.types.ts

@@ -2,6 +2,17 @@ import {IP_VERSION, Enum} from '../constants';
 
 export type Protocol = 'udp' | 'tcp' | 'xtls';
 
+// Per-protocol reachability flags, fully resolved.
+export type ResolvedReachabilityProtocols = {
+  udp: boolean;
+  tcp: boolean;
+  tls: boolean;
+};
+
+export type ReachabilityProtocolConfig = Partial<Omit<ResolvedReachabilityProtocols, 'udp'>>;
+
+export type EnableReachabilityChecksConfig = boolean | ReachabilityProtocolConfig;
+
 /**
  * Events emitted by ReachabilityPeerConnection
  */