@vonage/client-sdk-video 2.35.0-alpha.36 → 2.35.0-alpha.38

package/dist/js/opentok.js

@@ -1,11 +1,11 @@
 /**
- * @license OpenTok.js 2.35.0 c21053e02
+ * @license OpenTok.js 2.35.0 2592e1f
  *
  * Copyright (c) 2010-2026 TokBox, Inc.
  * Subject to the applicable Software Development Kit (SDK) License Agreement:
  * https://www.vonage.com/legal/communications-apis/terms-of-use/
  *
- * Date: Wed, 27 May 2026 10:59:03 GMT
+ * Date: Fri, 29 May 2026 07:34:13 GMT
  */
 
 (function webpackUniversalModuleDefinition(root, factory) {
@@ -31880,7 +31880,7 @@ if (isWorker()) {
   initWorker();
 }
 var Module = (() => {
-  var _scriptDir = "file:///Users/ec2-user/Desktop/webrtc-js-runner/actions-runner/_work/webrtc-js/webrtc-js/node_modules/@vonage/js-sframe/dist/js-sframe.es.js";
+  var _scriptDir = "file:///Users/ec2-user/actions-runner/webrtc-js/_work/webrtc-js/webrtc-js/node_modules/@vonage/js-sframe/dist/js-sframe.es.js";
   return function(Module2) {
     Module2 = Module2 || {};
     var Module2 = typeof Module2 != "undefined" ? Module2 : {};
@@ -41920,7 +41920,7 @@ function staticConfigFactory(_temp) {
     _ref$axios = _ref.axios,
     axios = _ref$axios === void 0 ? _axios.default : _ref$axios,
     _ref$properties = _ref.properties,
-    properties = _ref$properties === void 0 ? {"version":"v2.35.0","buildHash":"c21053e02","minimumVersion":{"firefox":52,"chrome":49},"debug":false,"websiteURL":"http://www.tokbox.com","configURL":"https://config.opentok.com","ipWhitelistConfigURL":"","cdnURL":"","loggingURL":"https://hlg.tokbox.com/prod","apiURL":"https://anvil.opentok.com","vonageApiURL":""} : _ref$properties;
+    properties = _ref$properties === void 0 ? {"version":"v2.35.0","buildHash":"2592e1f","minimumVersion":{"firefox":52,"chrome":49},"debug":false,"websiteURL":"http://www.tokbox.com","configURL":"https://config.opentok.com","ipWhitelistConfigURL":"","cdnURL":"","loggingURL":"https://hlg.tokbox.com/prod","apiURL":"https://anvil.opentok.com","vonageApiURL":""} : _ref$properties;
   /** @type builtInConfig */
   const builtInConfig = (0, _cloneDeep.default)(properties);
   /**
@@ -45066,47 +45066,39 @@ function PublisherFactory(_ref) {
             case 0:
               isStaticContent = isStaticContentHint();
               if (!_targetScalabilityMode) {
-                _context12.next = 19;
+                _context12.next = 17;
                 break;
               }
               _context12.prev = 2;
-              logAnalyticsEvent('setScalabilityMode', 'Attempt', {
-                scalabilityMode: _targetScalabilityMode
-              });
               if (!isStaticContent) {
-                _context12.next = 9;
+                _context12.next = 8;
                 break;
               }
-              _context12.next = 7;
+              _context12.next = 6;
               return _this._setScalabilityMode(getTemporalOnlyScalabilityMode(_targetScalabilityMode));
-            case 7:
-              _context12.next = 11;
+            case 6:
+              _context12.next = 10;
               break;
-            case 9:
-              _context12.next = 11;
+            case 8:
+              _context12.next = 10;
               return Promise.all([_this._setScalabilityMode(_targetScalabilityMode, TARGET_SCALABILITY_MODE_SVC_CODECS), _this._setScalabilityMode(getTemporalOnlyScalabilityMode(_targetScalabilityMode), TARGET_SCALABILITY_MODE_NON_SVC_CODECS)]);
-            case 11:
-              logAnalyticsEvent('setScalabilityMode', 'Success', {
-                scalabilityMode: _targetScalabilityMode
-              });
-              _context12.next = 18;
+            case 10:
+              _context12.next = 16;
               break;
-            case 14:
-              _context12.prev = 14;
+            case 12:
+              _context12.prev = 12;
               _context12.t0 = _context12["catch"](2);
-              logging.error('OT.Publisher failed to apply scalability mode', _context12.t0);
-              logAnalyticsEvent('setScalabilityMode', 'Failure', {
-                message: _context12.t0.message
-              });
-            case 18:
+              logging.error('OT.Publisher failed to apply target scalability mode', _context12.t0);
+              throw _context12.t0;
+            case 16:
               return _context12.abrupt("return");
-            case 19:
+            case 17:
               if (!(!properties.constraints.video || !sessionSimulcastEnabled || capableSimulcastStreams < 2)) {
-                _context12.next = 21;
+                _context12.next = 19;
                 break;
               }
               return _context12.abrupt("return");
-            case 21:
+            case 19:
               codecsWhitelist = ['VP9'];
               isCamera = !isScreenSharing && !isCustomVideoTrack;
               if (isCamera) {
@@ -45116,24 +45108,24 @@ function PublisherFactory(_ref) {
                 scalabilityMode = (0, _getScalabilityModeFromContentHint.default)(_this.getVideoContentHint());
               }
               if (!scalabilityMode) {
-                _context12.next = 33;
+                _context12.next = 31;
                 break;
               }
-              _context12.prev = 25;
-              _context12.next = 28;
+              _context12.prev = 23;
+              _context12.next = 26;
               return _this._setScalabilityMode(scalabilityMode, codecsWhitelist);
-            case 28:
-              _context12.next = 33;
+            case 26:
+              _context12.next = 31;
               break;
-            case 30:
-              _context12.prev = 30;
-              _context12.t1 = _context12["catch"](25);
+            case 28:
+              _context12.prev = 28;
+              _context12.t1 = _context12["catch"](23);
               logging.error('OT.Publisher failed to apply scalability mode', _context12.t1);
-            case 33:
+            case 31:
             case "end":
               return _context12.stop();
           }
-        }, _callee12, null, [[2, 14], [25, 30]]);
+        }, _callee12, null, [[2, 12], [23, 28]]);
       }));
       return function configureScalabilityMode() {
         return _ref21.apply(this, arguments);
@@ -45688,172 +45680,201 @@ function PublisherFactory(_ref) {
         this.destroy();
       }, this.session.MIGRATION_TIMEOUT);
     };
-    this.publish = targetElement => {
-      logging.debug('OT.Publisher: publish');
-      if (state.isAttemptingToPublish() || state.isPublishing()) {
-        reset();
-      }
-      state.set('GetUserMedia');
-      if (properties.style) {
-        this.setStyle(properties.style, null, true);
+    const publishWithCallback = function publishWithCallback(targetElement, callback) {
+      if (callback === void 0) {
+        callback = () => {};
       }
-      properties.classNames = 'OT_root OT_publisher';
-
-      // Defer actually creating the publisher DOM nodes until we know
-      // the DOM is actually loaded.
-      EnvironmentLoader.onLoad(() => {
-        logging.debug('OT.Publisher: publish: environment loaded');
-        // @note If ever replacing the widgetView with a new one elsewhere, you'll need to be
-        // mindful that audioLevelBehaviour has a reference to this one, and it will need to be
-        // updated accordingly.
-        // widgetView = new WidgetView(targetElement, properties);
-        widgetView = new WidgetView(targetElement, Object.assign({}, properties, {
-          widgetType: 'publisher'
-        }));
-        if (shouldAllowAudio) {
-          (0, _audioLevelBehaviour.default)({
-            publisher: this,
-            widgetView
-          });
-        }
-        widgetView.on('error', onVideoError);
-        this.id = widgetView.domId();
-        this.element = widgetView.domElement;
-        if (this.element && chromeMixin) {
-          // Only create the chrome if we have an element to insert it into
-          // for insertDefautlUI:false we don't create the chrome
-          chromeMixin.init(widgetView);
-        }
-        widgetView.on('videoDimensionsChanged', (oldValue, newValue) => {
-          // Ignore this event since there is no video.
-          if (!properties.publishVideo) {
-            return;
-          }
-          if (this.stream) {
-            this.stream.setVideoDimensions(newValue.width, newValue.height);
-          }
-          this.dispatchEvent(new Events.VideoDimensionsChangedEvent(this, oldValue, newValue));
-        });
-        widgetView.on('mediaStopped', track => {
-          const event = new Events.MediaStoppedEvent(this, track);
-
-          // When we have a disabled and transformed media track, we don't dispatch the event since
-          // it is not a media source stop. This is the case when we call publishVideo(false) or
-          // cycleVideo(), where the transformed track is stopped.
-          const isDisabledTransformedTrack = (track == null ? void 0 : track.readyState) === 'ended' &&
-          // Only transformed tracks have the writable property.
-          // See: https://developer.mozilla.org/en-US/docs/Web/API/MediaStreamTrackGenerator/writable
-          !!(track != null && track.writable);
-          if (!isDisabledTransformedTrack) {
-            this.dispatchEvent(event);
+      logging.debug('OT.Publisher: publish');
+      try {
+        if (state.isAttemptingToPublish() || state.isPublishing()) {
+          reset();
+        }
+        state.set('GetUserMedia');
+        if (properties.style) {
+          _this.setStyle(properties.style, null, true);
+        }
+        properties.classNames = 'OT_root OT_publisher';
+
+        // Defer actually creating the publisher DOM nodes until we know
+        // the DOM is actually loaded.
+        EnvironmentLoader.onLoad(() => {
+          logging.debug('OT.Publisher: publish: environment loaded');
+          // @note If ever replacing the widgetView with a new one elsewhere, you'll need to be
+          // mindful that audioLevelBehaviour has a reference to this one, and it will need to be
+          // updated accordingly.
+          // widgetView = new WidgetView(targetElement, properties);
+          widgetView = new WidgetView(targetElement, Object.assign({}, properties, {
+            widgetType: 'publisher'
+          }));
+          if (shouldAllowAudio) {
+            (0, _audioLevelBehaviour.default)({
+              publisher: _this,
+              widgetView
+            });
           }
-          if (event.isDefaultPrevented()) {
-            return;
+          widgetView.on('error', err => {
+            onVideoError(err);
+          });
+          _this.id = widgetView.domId();
+          _this.element = widgetView.domElement;
+          if (_this.element && chromeMixin) {
+            // Only create the chrome if we have an element to insert it into
+            // for insertDefautlUI:false we don't create the chrome
+            chromeMixin.init(widgetView);
           }
-          if (track) {
-            const kind = String(track.kind).toLowerCase();
-            // If we are publishing this kind when the track stops then
-            // make sure we start publishing again if we switch to a new track
-            if (kind === 'audio') {
-              updateAudio();
-            } else if (kind === 'video') {
-              updateVideo();
+          widgetView.on('videoDimensionsChanged', (oldValue, newValue) => {
+            // Ignore this event since there is no video.
+            if (!properties.publishVideo) {
+              return;
+            }
+            if (_this.stream) {
+              _this.stream.setVideoDimensions(newValue.width, newValue.height);
+            }
+            _this.dispatchEvent(new Events.VideoDimensionsChangedEvent(_this, oldValue, newValue));
+          });
+          widgetView.on('mediaStopped', track => {
+            const event = new Events.MediaStoppedEvent(_this, track);
+
+            // When we have a disabled and transformed media track, we don't dispatch the event since
+            // it is not a media source stop. This is the case when we call publishVideo(false) or
+            // cycleVideo(), where the transformed track is stopped.
+            const isDisabledTransformedTrack = (track == null ? void 0 : track.readyState) === 'ended' &&
+            // Only transformed tracks have the writable property.
+            // See: https://developer.mozilla.org/en-US/docs/Web/API/MediaStreamTrackGenerator/writable
+            !!(track != null && track.writable);
+            if (!isDisabledTransformedTrack) {
+              _this.dispatchEvent(event);
+            }
+            if (event.isDefaultPrevented()) {
+              return;
+            }
+            if (track) {
+              const kind = String(track.kind).toLowerCase();
+              // If we are publishing this kind when the track stops then
+              // make sure we start publishing again if we switch to a new track
+              if (kind === 'audio') {
+                updateAudio();
+              } else if (kind === 'video') {
+                updateVideo();
+              } else {
+                logging.warn(`Track with invalid kind has ended: ${track.kind}`);
+              }
+              logAnalyticsEvent('mediaStopped', 'Event', {
+                kind
+              });
+              return;
+            }
+            if (_this.session) {
+              _this._.unpublishFromSession(_this.session, 'mediaStopped');
             } else {
-              logging.warn(`Track with invalid kind has ended: ${track.kind}`);
+              _this.destroy('mediaStopped');
             }
-            logAnalyticsEvent('mediaStopped', 'Event', {
-              kind
-            });
-            return;
-          }
-          if (this.session) {
-            this._.unpublishFromSession(this.session, 'mediaStopped');
-          } else {
-            this.destroy('mediaStopped');
-          }
-        });
-        widgetView.on('videoElementCreated', element => {
-          this.dispatchEvent(new Events.MediaStreamAvailableEvent(webRTCStream));
-          const event = new Events.VideoElementCreatedEvent(element);
-          this.dispatchEvent(event);
-        });
-        getUserMedia().catch(userMediaError).then( /*#__PURE__*/function () {
-          var _ref30 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee20(stream) {
-            var _audioDevices, _videoDevices;
-            var hasVideoFilter, addAudioInputDevicesChangeListener, hasAudioVideoDevices;
-            return _regenerator.default.wrap(function _callee20$(_context20) {
-              while (1) switch (_context20.prev = _context20.next) {
-                case 0:
-                  // this comes from deviceHelpers.shouldAskForDevices in a round-about way
-                  audioDevices = processedOptions.audioDevices;
-                  videoDevices = processedOptions.videoDevices;
-                  hasVideoFilter = !!properties.videoFilter;
-                  if (!properties.disableAudioInputDeviceManagement) {
-                    // this is needed to refresh current audio input device after previous one was disconnected
-                    addAudioInputDevicesChangeListener = addAudioInputDevicesChangeListenerFactory();
-                    removeDeviceChangeListener = addAudioInputDevicesChangeListener(_this);
-                  }
-                  hasAudioVideoDevices = ((_audioDevices = audioDevices) == null ? void 0 : _audioDevices.length) > 0 || ((_videoDevices = videoDevices) == null ? void 0 : _videoDevices.length) > 0;
-                  if (hasAudioVideoDevices) {
-                    (0, _permissionListener.default)().then(listener => {
-                      listener.on('accessDenied', device => {
-                        _this.accessAllowed = false;
-                        _this.dispatchEvent((0, _accessDeniedEvent.default)(device, 'during the call'));
+          });
+          widgetView.on('videoElementCreated', element => {
+            _this.dispatchEvent(new Events.MediaStreamAvailableEvent(webRTCStream));
+            const event = new Events.VideoElementCreatedEvent(element);
+            _this.dispatchEvent(event);
+          });
+          getUserMedia().catch(err => {
+            callback(err);
+            userMediaError(err);
+          }).then( /*#__PURE__*/function () {
+            var _ref30 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee20(stream) {
+              var _audioDevices, _videoDevices;
+              var hasVideoFilter, addAudioInputDevicesChangeListener, hasAudioVideoDevices;
+              return _regenerator.default.wrap(function _callee20$(_context20) {
+                while (1) switch (_context20.prev = _context20.next) {
+                  case 0:
+                    // this comes from deviceHelpers.shouldAskForDevices in a round-about way
+                    audioDevices = processedOptions.audioDevices;
+                    videoDevices = processedOptions.videoDevices;
+                    hasVideoFilter = !!properties.videoFilter;
+                    if (!properties.disableAudioInputDeviceManagement) {
+                      // this is needed to refresh current audio input device after previous one was disconnected
+                      addAudioInputDevicesChangeListener = addAudioInputDevicesChangeListenerFactory();
+                      removeDeviceChangeListener = addAudioInputDevicesChangeListener(_this);
+                    }
+                    hasAudioVideoDevices = ((_audioDevices = audioDevices) == null ? void 0 : _audioDevices.length) > 0 || ((_videoDevices = videoDevices) == null ? void 0 : _videoDevices.length) > 0;
+                    if (hasAudioVideoDevices) {
+                      (0, _permissionListener.default)().then(listener => {
+                        listener.on('accessDenied', device => {
+                          _this.accessAllowed = false;
+                          const errorEvent = (0, _accessDeniedEvent.default)(device, 'during the call');
+                          _this.dispatchEvent(errorEvent);
+                        });
                       });
-                    });
-                  }
-                  if (hasVideoFilter) {
-                    // We need to get the device now, before the filter is applied
-                    // else the wrong device will be returned/nonsensical
-                    currentDeviceId = (0, _getDeviceIdFromStream.default)(stream, videoDevices);
-                  }
-                  _context20.next = 9;
-                  return onStreamAvailable(stream);
-                case 9:
-                  if (!properties.publishVideo) {
-                    _this._toggleVideo(properties.publishVideo, getVideoDimensions());
-                  }
-                  if (!isScreenSharing && !isCustomVideoTrack
-                  // For filtered video, we stored the currentDeviceId already.
-                  // (see note above)
-                  && !hasVideoFilter) {
-                    currentDeviceId = (0, _getDeviceIdFromStream.default)(stream, videoDevices);
-                    if (properties.publishVideo) {
-                      setCurrentTrackDeviceId(currentDeviceId);
                     }
-                  }
-                  return _context20.abrupt("return", bindVideo().catch(error => {
-                    if (error instanceof _cancel.CancellationError) {
-                      // If we get a CancellationError, it means something newer tried
-                      // to bindVideo before the old one succeeded, perhaps they called
-                      // switchTracks.. It should be rare, and they shouldn't be doing
-                      // this before loaded, but we'll handle it anyway.
-                      return undefined;
+                    if (hasVideoFilter) {
+                      // We need to get the device now, before the filter is applied
+                      // else the wrong device will be returned/nonsensical
+                      currentDeviceId = (0, _getDeviceIdFromStream.default)(stream, videoDevices);
                     }
-                    throw error;
-                  }).then(() => {
-                    onLoaded();
-                    if (!state.isDestroyed()) {
-                      _this.trigger('initSuccess');
-                      _this.trigger('loaded', _this);
+                    _context20.next = 9;
+                    return onStreamAvailable(stream);
+                  case 9:
+                    if (!properties.publishVideo) {
+                      _this._toggleVideo(properties.publishVideo, getVideoDimensions());
                     }
-                  }, err => {
-                    logging.error(`OT.Publisher.publish failed to bind video: ${err}`);
-                    onLoadFailure(err);
-                  }));
-                case 12:
-                case "end":
-                  return _context20.stop();
-              }
-            }, _callee20);
-          }));
-          return function (_x12) {
-            return _ref30.apply(this, arguments);
-          };
-        }());
-      });
+                    if (!isScreenSharing && !isCustomVideoTrack
+                    // For filtered video, we stored the currentDeviceId already.
+                    // (see note above)
+                    && !hasVideoFilter) {
+                      currentDeviceId = (0, _getDeviceIdFromStream.default)(stream, videoDevices);
+                      if (properties.publishVideo) {
+                        setCurrentTrackDeviceId(currentDeviceId);
+                      }
+                    }
+                    return _context20.abrupt("return", bindVideo().catch(error => {
+                      if (error instanceof _cancel.CancellationError) {
+                        // If we get a CancellationError, it means something newer tried
+                        // to bindVideo before the old one succeeded, perhaps they called
+                        // switchTracks.. It should be rare, and they shouldn't be doing
+                        // this before loaded, but we'll handle it anyway.
+                        return undefined;
+                      }
+                      throw error;
+                    }).then(() => {
+                      onLoaded();
+                      if (!state.isDestroyed()) {
+                        _this.trigger('initSuccess');
+                        _this.trigger('loaded', _this);
+                        callback();
+                      } else {
+                        callback(new Error('publisher destroyed'));
+                      }
+                    }, err => {
+                      logging.error(`OT.Publisher.publish failed to bind video: ${err}`);
+                      onLoadFailure(err);
+                      callback(err);
+                    }));
+                  case 12:
+                  case "end":
+                    return _context20.stop();
+                }
+              }, _callee20);
+            }));
+            return function (_x12) {
+              return _ref30.apply(this, arguments);
+            };
+          }());
+        });
+      } catch (err) {
+        callback(err);
+      }
+    };
+    this.publish = targetElement => {
+      publishWithCallback(targetElement);
       return this;
     };
+    this.publish.promise = targetElement => new Promise((resolve, reject) => {
+      publishWithCallback(targetElement, err => {
+        if (err) {
+          reject(err);
+        } else {
+          resolve(this);
+        }
+      });
+    });
     this._getRoutedVideoSenders = /*#__PURE__*/(0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee21() {
       var routedPeerConnection;
       return _regenerator.default.wrap(function _callee21$(_context21) {
@@ -46022,6 +46043,30 @@ function PublisherFactory(_ref) {
       }
       refreshAudioVideoUI(activeReason);
     };
+    const publishAudioWithCallback = function publishAudioWithCallback(value, callback) {
+      if (callback === void 0) {
+        callback = () => {};
+      }
+      logAnalyticsEvent('publishAudio', 'Attempt', {
+        publishAudio: value
+      });
+      const attemptStart = Date.now();
+      properties.publishAudio = value;
+      try {
+        updateAudio();
+        logAnalyticsEvent('publishAudio', 'Success', {
+          publishAudio: value
+        }, {
+          attemptDuration: Date.now() - attemptStart
+        });
+        callback();
+      } catch (err) {
+        logAnalyticsEvent('publishAudio', 'Failure', {
+          message: err.message
+        });
+        callback(err);
+      }
+    };
 
     /**
     * Starts publishing audio (if it is currently not being published)
@@ -46038,26 +46083,44 @@ function PublisherFactory(_ref) {
     * @memberOf Publisher
     */
     this.publishAudio = value => {
-      logAnalyticsEvent('publishAudio', 'Attempt', {
-        publishAudio: value
-      });
-      const attemptStart = Date.now();
-      properties.publishAudio = value;
-      try {
-        updateAudio();
-        logAnalyticsEvent('publishAudio', 'Success', {
-          publishAudio: value
-        }, {
-          attemptDuration: Date.now() - attemptStart
-        });
-      } catch (e) {
-        logAnalyticsEvent('publishAudio', 'Failure', {
-          message: e.message
-        });
-      }
+      publishAudioWithCallback(value);
       return this;
     };
-    const finishPublishCaptions = value => {
+
+    /**
+     * Promise-based variant of {@link Publisher#publishAudio}.
+     * Resolves when the session confirms the audio state change via a
+     * <code>streamPropertyChanged</code> event, or rejects with an error if it fails.
+     *
+     * @param {Boolean} value Whether to start publishing audio (<code>true</code>)
+     * or not (<code>false</code>).
+     * @returns {Promise<void>} Resolves on success, rejects with an
+     * <code><a href="Error.html">Error</a></code> on failure.
+     *
+     * @example
+     * await publisher.publishAudio.promise(false);
+     *
+     * @method #publishAudio.promise
+     * @memberOf Publisher
+     */
+    this.publishAudio.promise = value => new Promise((resolve, reject) => {
+      if (!this.session) {
+        reject(new Error('Cannot publish audio before publishing to a session'));
+        return;
+      }
+      if (properties.publishAudio === value) {
+        resolve();
+        return;
+      }
+      publishAudioWithCallback(value, err => {
+        if (err) {
+          reject(err);
+        } else {
+          resolve();
+        }
+      });
+    });
+    const finishPublishCaptions = (value, resolve, reject) => {
       try {
         privateEvents.dispatchEvent(new Events.PublisherCaptionsEnabled(value));
         this.stream.setChannelActiveState({
@@ -46067,11 +46130,13 @@ function PublisherFactory(_ref) {
         logAnalyticsEvent('publishCaptions', 'Success', {
           publishCaptions: value
         });
+        resolve();
       } catch (e) {
         logAnalyticsEvent('publishCaptions', 'Failure', {
           message: e.message,
           publishCaptions: value
         });
+        reject(e);
       }
     };
 
@@ -46096,20 +46161,20 @@ function PublisherFactory(_ref) {
     * @see <a href="Subscriber.html#isSubscribedToCaptions">isSubscribedToCaptions()</a>
     * @see <a href="Stream.html#hasCaptions">Stream.hasCaptions</a>
     * @see StreamPropertyChangedEvent
+    * @returns {Promise}
     * @method #publishCaptions
     * @memberOf Publisher
     */
-
-    this.publishCaptions = value => {
+    this.publishCaptions = value => new Promise((resolve, reject) => {
       logAnalyticsEvent('publishCaptions', 'Attempt', {
         publishCaptions: value
       });
       if (this.stream) {
-        finishPublishCaptions(value);
+        finishPublishCaptions(value, resolve, reject);
       } else {
-        streamReadyJobs.add(() => finishPublishCaptions(value));
+        streamReadyJobs.add(() => finishPublishCaptions(value, resolve, reject));
       }
-    };
+    });
     let updateVideoSenderParametersSentinel;
 
     // keeps track of if the client has called mediaStreamTrack.stop(), so that we don't restart
@@ -46606,6 +46671,31 @@ function PublisherFactory(_ref) {
       });
       return this;
     };
+
+    /**
+     * Promise-based variant of {@link Publisher#publishVideo}.
+     * Resolves when the operation completes, or rejects with an error if it fails.
+     *
+     * @param {Boolean} value Whether to start publishing video (<code>true</code>)
+     * or not (<code>false</code>).
+     * @returns {Promise<void>} Resolves on success, rejects with an
+     * <code><a href="Error.html">Error</a></code> on failure.
+     *
+     * @example
+     * await publisher.publishVideo.promise(true);
+     *
+     * @method #publishVideo.promise
+     * @memberOf Publisher
+     */
+    this.publishVideo.promise = value => new Promise((resolve, reject) => {
+      this.publishVideo(value, err => {
+        if (err) {
+          reject(err);
+        } else {
+          resolve();
+        }
+      });
+    });
     this._publishVideo = /*#__PURE__*/function () {
       var _ref44 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee32(value) {
         var videoDimensions;
@@ -46685,7 +46775,7 @@ function PublisherFactory(_ref) {
       _targetContentHint = videoContentHint;
       (0, _videoContentHint.setVideoContentHint)(webRTCStream, videoContentHint);
       if (changedStaticContent || isScreenSharing && properties._setDefaultScalabilityMode) {
-        configureScalabilityMode();
+        configureScalabilityMode().catch(() => {});
       }
     };
 
@@ -46731,11 +46821,30 @@ function PublisherFactory(_ref) {
     * @memberOf Publisher
     */
     this.setTargetScalabilityMode = scalabilityMode => {
+      logAnalyticsEvent('setTargetScalabilityMode', 'Attempt', undefined, {
+        targetScalabilityMode: scalabilityMode
+      });
       if (!VALID_TARGET_SCALABILITY_MODES.has(scalabilityMode)) {
-        throw otError(Errors.INVALID_PARAMETER, new Error(INVALID_TARGET_SCALABILITY_MODE_MESSAGE));
+        const error = otError(Errors.INVALID_PARAMETER, new Error(INVALID_TARGET_SCALABILITY_MODE_MESSAGE));
+        logAnalyticsEvent('setTargetScalabilityMode', 'Failure', {
+          message: error.message
+        }, {
+          targetScalabilityMode: scalabilityMode
+        });
+        throw error;
       }
       _targetScalabilityMode = scalabilityMode;
-      configureScalabilityMode();
+      configureScalabilityMode().then(() => {
+        logAnalyticsEvent('setTargetScalabilityMode', 'Success', undefined, {
+          targetScalabilityMode: scalabilityMode
+        });
+      }).catch(err => {
+        logAnalyticsEvent('setTargetScalabilityMode', 'Failure', {
+          message: err.message
+        }, {
+          targetScalabilityMode: scalabilityMode
+        });
+      });
     };
 
     /**
@@ -47401,7 +47510,7 @@ function PublisherFactory(_ref) {
       let shouldRePublishVideo = false;
       if (properties.publishVideo && document.hidden) {
         shouldRePublishVideo = true;
-        // turning the video off to prevent that videotrack is ended
+        // Turning the video off to prevent that videotrack is ended.
         this.publishVideo(false);
       }
       // trigger the handler onVisibilityChange
@@ -48032,7 +48141,7 @@ function PublisherFactory(_ref) {
             }
             this._setScalableFramerates(properties.scalableFramerates);
             this._setScalableVideoLayers(properties.scalableVideoLayers);
-            configureScalabilityMode();
+            configureScalabilityMode().catch(() => {});
 
             // See OPENTOK-45935
             // Some users reuse the publisher when disconnecting and reconnecting