@opentok/client 2.35.0-alpha.49 → 2.35.0-alpha.50

package/dist/js/opentok.js

@@ -1,11 +1,11 @@
 /**
- * @license OpenTok.js 2.35.0 1130ccbf0
+ * @license OpenTok.js 2.35.0 af69a9c37
  *
  * 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: Tue, 09 Jun 2026 09:26:44 GMT
+ * Date: Tue, 09 Jun 2026 11:10:58 GMT
  */
 
 (function webpackUniversalModuleDefinition(root, factory) {
@@ -2398,20 +2398,30 @@ const PENDING = Symbol('pendingCalls');
 /**
  * Add (or overwrite) a pending method call.
  * Keeps only the latest call per method.
+ * Accepts a cancel function called when the method is overridden.
  *
  * @param {Object} instance
  * @param {Function} method
  * @param {Array} args
+ * @param {Function} cancel
  */
-function addToPending(instance, method, args) {
+function addToPending(instance, method, args, cancel) {
+  if (cancel === void 0) {
+    cancel = () => {};
+  }
   if (!instance[PENDING]) {
     // eslint-disable-next-line no-param-reassign
     instance[PENDING] = new Map();
   }
   const queue = instance[PENDING];
+  const previous = queue.get(method);
+  if (previous && typeof previous.cancel === 'function') {
+    previous.cancel();
+  }
   queue.set(method, {
     fn: method.bind(instance),
-    args
+    args,
+    cancel
   });
 }
 
@@ -25597,7 +25607,7 @@ function SubscriberFactory(_ref2) {
       logAnalyticsEvent('SetStyle', 'Subscriber', payload, null, 0.1);
     });
     function setAudioOnly(audioOnly) {
-      getAllPeerConnections().forEach( /*#__PURE__*/function () {
+      const peerConnectionUpdates = getAllPeerConnections().map( /*#__PURE__*/function () {
         var _ref21 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee10(peerConnection) {
           return _regenerator.default.wrap(function _callee10$(_context10) {
             while (1) switch (_context10.prev = _context10.next) {
@@ -25605,7 +25615,7 @@ function SubscriberFactory(_ref2) {
                 _context10.next = 2;
                 return peerConnection;
               case 2:
-                _context10.sent.subscribeToVideo(!audioOnly);
+                return _context10.abrupt("return", _context10.sent.subscribeToVideo(!audioOnly));
               case 3:
               case "end":
                 return _context10.stop();
@@ -25626,6 +25636,7 @@ function SubscriberFactory(_ref2) {
       if (_audioLevelMeter) {
         _audioLevelMeter.audioOnly(audioFallback);
       }
+      return peerConnectionUpdates;
     }
 
     // logs an analytics event for getStats on the first call
@@ -26338,6 +26349,7 @@ function SubscriberFactory(_ref2) {
     };
     function applyAudioVolume(audioVolume) {
       const video = _widgetView && _widgetView.video();
+      const promises = [];
       if (video) {
         try {
           video.setAudioVolume(audioVolume);
@@ -26346,28 +26358,34 @@ function SubscriberFactory(_ref2) {
           if (_audioVolume === 0) {
             logging.info('Using subscribeToAudio to mute Audio because setAudioVolume(0) failed');
             // If we can't set the audioVolume to 0 then at least mute by setting subscribeToAudio(false)
-            _subscriber.subscribeToAudio(false, 'internal');
+            promises.push(_subscriber.subscribeToAudio.promise(false, 'internal'));
           }
         }
       }
       if (_chrome) {
         _chrome.muteButton.muted(audioVolume === 0);
       }
+      return Promise.all(promises);
     }
-    function setAudioVolume(requestedVolume) {
+    function setAudioVolume(requestedVolume, callback) {
+      if (callback === void 0) {
+        callback = () => {};
+      }
       const volume = normalizeAudioVolume(requestedVolume);
+      const rangeErrorMessage = 'value should be an integer between 0 and 100';
       if (isNaN(volume)) {
-        logging.error('OT.Subscriber.setAudioVolume: value should be an integer between 0 and 100');
+        logging.error(`OT.Subscriber.setAudioVolume: ${rangeErrorMessage}`);
+        callback(new Error(rangeErrorMessage));
         return {
           volume,
-          error: 'value should be an integer between 0 and 100'
+          error: rangeErrorMessage
         };
       }
       if (volume !== requestedVolume) {
-        logging.warn('OT.Subscriber.setAudioVolume: value should be an integer between 0 and 100');
+        logging.warn(`OT.Subscriber.setAudioVolume: ${rangeErrorMessage}`);
       }
       if (volume === _audioVolume) {
-        applyAudioVolume(_audioVolume);
+        applyAudioVolume(_audioVolume).then(() => callback()).catch(err => callback(err));
         return {
           volume,
           message: 'Requested volume is same as already set audioVolume'
@@ -26377,15 +26395,16 @@ function SubscriberFactory(_ref2) {
         _latestPositiveVolume = _audioVolume;
       }
       _audioVolume = volume;
-      applyAudioVolume(_audioVolume);
+      const promises = [applyAudioVolume(_audioVolume)];
       if (_audioVolume > 0 && !_isSubscribingToAudio) {
         // in Firefox (and others) we don't stop subscribing to audio when muted, however if we are 'unmuting' and in
         // the subscribeToAudio: false state we should subscribe to audio again
 
         // subscribeToAudio is going to call us with _latestPositiveVolume so we'll update it here
         _latestPositiveVolume = _audioVolume;
-        _subscriber.subscribeToAudio(true, 'internal');
+        promises.push(_subscriber.subscribeToAudio.promise(true, 'internal'));
       }
+      Promise.all(promises).then(() => callback()).catch(err => callback(err));
       return {
         volume
       };
@@ -26408,6 +26427,13 @@ function SubscriberFactory(_ref2) {
         });
       }
     });
+    const setAudioVolumeWithCallback = function setAudioVolumeWithCallback(requestedVolume, callback) {
+      if (callback === void 0) {
+        callback = () => {};
+      }
+      const result = setAudioVolume(requestedVolume, callback);
+      logSetAudioVolumeLimitedRunner.run(result);
+    };
 
     /**
      * Sets the audio volume, between 0 and 100, of the Subscriber.
@@ -26428,13 +26454,41 @@ function SubscriberFactory(_ref2) {
      * @method #setAudioVolume
      * @memberOf Subscriber
      */
-
     this.setAudioVolume = requestedVolume => {
-      const result = setAudioVolume(requestedVolume);
-      logSetAudioVolumeLimitedRunner.run(result);
+      setAudioVolumeWithCallback(requestedVolume);
       return this;
     };
 
+    /**
+     * Promise-based variant of {@link Subscriber#setAudioVolume}.
+     *
+     * Sets the audio volume of the Subscriber and returns a Promise that settles once all
+     * underlying audio operations have completed (including any audio-processor connector
+     * update triggered by unmuting).
+     *
+     * @param {Number} value - The audio volume, between 0 and 100.
+     * @returns {Promise<void>} Resolves when the volume has been successfully applied;
+     *   rejects with an <code>Error</code> if the value is out of range or if any
+     *   underlying audio operation fails.
+     *
+     * @example
+     * subscriber.setAudioVolume.promise(50)
+     *   .then(() => console.log('volume set'))
+     *   .catch(err => console.error('failed to set volume', err));
+     *
+     * @method #setAudioVolume.promise
+     * @memberOf Subscriber
+     */
+    this.setAudioVolume.promise = requestedVolume => new Promise((resolve, reject) => {
+      setAudioVolumeWithCallback(requestedVolume, err => {
+        if (err) {
+          reject(err);
+        } else {
+          resolve();
+        }
+      });
+    });
+
     /**
     * Returns the audio volume, between 0 and 100, of the Subscriber.
     *
@@ -26457,40 +26511,17 @@ function SubscriberFactory(_ref2) {
       }
       return _audioVolume;
     };
-
-    /**
-    * Toggles audio on and off. Starts subscribing to audio (if it is available and currently
-    * not being subscribed to) when the <code>value</code> is <code>true</code>; stops
-    * subscribing to audio (if it is currently being subscribed to) when the <code>value</code>
-    * is <code>false</code>.
-    * <p>
-    * <i>Note:</i> This method only affects the local playback of audio. It has no impact on the
-    * audio for other connections subscribing to the same stream. If the Publisher is not
-    * publishing audio, enabling the Subscriber audio will have no practical effect.
-    * </p>
-    *
-    * @param {Boolean} value Whether to start subscribing to audio (<code>true</code>) or not
-    * (<code>false</code>).
-    *
-    * @return {Subscriber} The Subscriber object. This lets you chain method calls, as in the
-    * following:
-    *
-    * <pre>mySubscriber.subscribeToAudio(true).subscribeToVideo(false);</pre>
-    *
-    * @see <a href="#subscribeToVideo">subscribeToVideo()</a>
-    * @see <a href="Session.html#subscribe">Session.subscribe()</a>
-    * @see <a href="StreamPropertyChangedEvent.html">StreamPropertyChangedEvent</a>
-    *
-    * @method #subscribeToAudio
-    * @memberOf Subscriber
-    */
-    this.subscribeToAudio = (pValue, reason) => {
+    const subscribeToAudioWithCallback = function subscribeToAudioWithCallback(pValue, reason, callback) {
+      if (callback === void 0) {
+        callback = () => {};
+      }
       const value = (0, _castToBoolean.default)(pValue, true);
+      const promises = [];
       if (!reason && !_state.isSubscribing()) {
-        (0, _pendingCalls.addToPending)(this, this.subscribeToAudio, [value]);
-        return this;
+        (0, _pendingCalls.addToPending)(_this, subscribeToAudioWithCallback, [value, reason, callback], () => callback(new Error('pending subscribeToAudio overridden')));
+        return;
       }
-      getAllPeerConnections().forEach( /*#__PURE__*/function () {
+      const subs = getAllPeerConnections().map( /*#__PURE__*/function () {
         var _ref33 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee18(peerConnection) {
           return _regenerator.default.wrap(function _callee18$(_context18) {
             while (1) switch (_context18.prev = _context18.next) {
@@ -26498,7 +26529,7 @@ function SubscriberFactory(_ref2) {
                 _context18.next = 2;
                 return peerConnection;
               case 2:
-                _context18.sent.subscribeToAudio(value);
+                return _context18.abrupt("return", _context18.sent.subscribeToAudio(value));
               case 3:
               case "end":
                 return _context18.stop();
@@ -26509,6 +26540,7 @@ function SubscriberFactory(_ref2) {
           return _ref33.apply(this, arguments);
         };
       }());
+      promises.push(...subs);
       if (_stream && getAllPeerConnections().length !== 0) {
         setChannelActiveStateForSubscriber({
           channelType: 'audio',
@@ -26526,7 +26558,7 @@ function SubscriberFactory(_ref2) {
       }
       if (_audioConnector.audioMediaProcessorConnector) {
         if (_isSubscribingToAudio) {
-          _setAudioMediaProcessorConnector();
+          promises.push(_setAudioMediaProcessorConnector());
         } else {
           try {
             _audioConnector.resetAudioStreamAndTrack();
@@ -26534,17 +26566,90 @@ function SubscriberFactory(_ref2) {
             logAnalyticsEvent('subscribeToAudio', 'Failure', {
               message: `Error resetting track: ${error.message}`
             });
-            return this;
+            callback(error);
+            return;
           }
         }
       }
-      logAnalyticsEvent('subscribeToAudio', 'Success', {
-        subscribeToAudio: value
-      }, {
-        attemptDuration: Date.now() - attemptStart
+      Promise.all(promises).then(() => {
+        logAnalyticsEvent('subscribeToAudio', 'Success', {
+          subscribeToAudio: value
+        }, {
+          attemptDuration: Date.now() - attemptStart
+        });
+        callback();
+      }).catch(err => {
+        logAnalyticsEvent('subscribeToAudio', 'Failure', {
+          message: (err == null ? void 0 : err.message) || String(err)
+        }, {
+          attemptDuration: Date.now() - attemptStart
+        });
+        callback(err);
       });
+    };
+
+    /**
+    * Toggles audio on and off. Starts subscribing to audio (if it is available and currently
+    * not being subscribed to) when the <code>value</code> is <code>true</code>; stops
+    * subscribing to audio (if it is currently being subscribed to) when the <code>value</code>
+    * is <code>false</code>.
+    * <p>
+    * <i>Note:</i> This method only affects the local playback of audio. It has no impact on the
+    * audio for other connections subscribing to the same stream. If the Publisher is not
+    * publishing audio, enabling the Subscriber audio will have no practical effect.
+    * </p>
+    *
+    * @param {Boolean} value Whether to start subscribing to audio (<code>true</code>) or not
+    * (<code>false</code>).
+    *
+    * @return {Subscriber} The Subscriber object. This lets you chain method calls, as in the
+    * following:
+    *
+    * <pre>mySubscriber.subscribeToAudio(true).subscribeToVideo(false);</pre>
+    *
+    * @see <a href="#subscribeToVideo">subscribeToVideo()</a>
+    * @see <a href="Session.html#subscribe">Session.subscribe()</a>
+    * @see <a href="StreamPropertyChangedEvent.html">StreamPropertyChangedEvent</a>
+    *
+    * @method #subscribeToAudio
+    * @memberOf Subscriber
+    */
+    this.subscribeToAudio = (pValue, reason) => {
+      subscribeToAudioWithCallback(pValue, reason);
       return this;
     };
+
+    /**
+     * Promise-based variant of {@link Subscriber#subscribeToAudio}.
+     *
+     * Toggles audio on or off and returns a Promise that settles once all underlying
+     * peer-connection and audio-processor operations have completed.
+     *
+     * @param {Boolean} value - <code>true</code> to start subscribing to audio,
+     *   <code>false</code> to stop.
+     * @param {String} [reason] - Internal reason string (e.g. <code>'internal'</code>).
+     *   Pass <code>undefined</code> for a user-initiated call.
+     * @returns {Promise<void>} Resolves when audio has been successfully toggled;
+     *   rejects with an <code>Error</code> if any operation fails.
+     *
+     * @example
+     * // Mute audio and wait until the operation is fully complete
+     * subscriber.subscribeToAudio.promise(false)
+     *   .then(() => console.log('audio muted'))
+     *   .catch(err => console.error('failed to mute audio', err));
+     *
+     * @method #subscribeToAudio.promise
+     * @memberOf Subscriber
+     */
+    this.subscribeToAudio.promise = (pValue, reason) => new Promise((resolve, reject) => {
+      subscribeToAudioWithCallback(pValue, reason, err => {
+        if (err) {
+          reject(err);
+        } else {
+          resolve();
+        }
+      });
+    });
     const reasonMap = {
       auto: 'quality',
       publishVideo: 'publishVideo',
@@ -26563,6 +26668,106 @@ function SubscriberFactory(_ref2) {
         document.removeEventListener('visibilitychange', onVisibilityChange);
       });
     }
+    const subscribeToVideoWithCallback = /*#__PURE__*/function () {
+      var _ref34 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee19(pValue, reason, callback) {
+        var enableVideo, attemptStart, promises, message;
+        return _regenerator.default.wrap(function _callee19$(_context19) {
+          while (1) switch (_context19.prev = _context19.next) {
+            case 0:
+              if (callback === void 0) {
+                callback = () => {};
+              }
+              enableVideo = (0, _castToBoolean.default)(pValue, true);
+              if (!(!reason && !_state.isSubscribing())) {
+                _context19.next = 5;
+                break;
+              }
+              (0, _pendingCalls.addToPending)(_this, subscribeToVideoWithCallback, [enableVideo, reason, callback], () => callback(new Error('pending subscribeToVideo overridden')));
+              return _context19.abrupt("return");
+            case 5:
+              // We restore to undefined to keep backward compatibility
+              // eslint-disable-next-line no-param-reassign
+              if (reason === 'internal') {
+                reason = undefined;
+              }
+              if (!reason) {
+                _isVideoManuallyMuted = !enableVideo;
+              } else if (reason === 'auto') {
+                updateCongestionLevel(enableVideo ? null : 2);
+              }
+              logAnalyticsEvent('subscribeToVideo', 'Attempt', {
+                subscribeToVideo: enableVideo,
+                reason
+              });
+              attemptStart = Date.now();
+              promises = setAudioOnly(!enableVideo || !_stream.hasVideo || !_webRTCStream);
+              if (!(_stream.hasVideo && !_streamHasTracks('video'))) {
+                _context19.next = 17;
+                break;
+              }
+              if (enableVideo) {
+                logging.info('Subscriber is audio-only due to incompatibility, can\'t subscribeToVideo.');
+              }
+              _properties.subscribeToVideo = false;
+              message = 'No video tracks available';
+              logAnalyticsEvent('subscribeToVideo', 'Failure', {
+                message
+              });
+              callback(new Error(message));
+              return _context19.abrupt("return");
+            case 17:
+              if (_chrome && _chrome.videoDisabledIndicator) {
+                // If this is an auto disableVideo then we want to show the indicator, otherwise hide it again
+                _chrome.videoDisabledIndicator.disableVideo(!enableVideo && reason === 'auto');
+              }
+              if (getAllPeerConnections().length > 0 && _session && _stream) {
+                if ((enableVideo !== _properties.subscribeToVideo || reason !== _lastSubscribeToVideoReason) && !(_isVideoManuallyMuted && !!reason)) {
+                  setChannelActiveStateForSubscriber({
+                    channelType: 'video',
+                    activeState: enableVideo,
+                    activeReason: reason
+                  });
+                }
+              }
+              _properties.subscribeToVideo = enableVideo;
+              _lastSubscribeToVideoReason = reason;
+              _videoEnabled = enableVideo;
+              if (_videoMediaProcessorConnector) {
+                if (_videoEnabled) {
+                  promises.push(_setVideoMediaProcessorConnector());
+                } else {
+                  _resetVideoStream();
+                }
+              }
+              if (reason !== 'loading') {
+                _this.dispatchEvent(new Events.VideoEnabledChangedEvent(enableVideo ? 'videoEnabled' : 'videoDisabled', {
+                  reason: reasonMap[reason] || 'subscribeToVideo'
+                }));
+              }
+              Promise.all(promises).then(() => {
+                logAnalyticsEvent('subscribeToVideo', 'Success', {
+                  subscribeToVideo: enableVideo,
+                  reason
+                }, {
+                  attemptDuration: Date.now() - attemptStart
+                });
+                callback();
+              }).catch(err => {
+                logAnalyticsEvent('subscribeToVideo', 'Failure', {
+                  message: (err == null ? void 0 : err.message) || String(err)
+                });
+                callback(err);
+              });
+            case 25:
+            case "end":
+              return _context19.stop();
+          }
+        }, _callee19);
+      }));
+      return function subscribeToVideoWithCallback(_x19, _x20, _x21) {
+        return _ref34.apply(this, arguments);
+      };
+    }();
 
     /**
     * Toggles video on and off. Starts subscribing to video (if it is available and
@@ -26591,73 +26796,42 @@ function SubscriberFactory(_ref2) {
     * @memberOf Subscriber
     */
     this.subscribeToVideo = (pValue, reason) => {
-      const enableVideo = (0, _castToBoolean.default)(pValue, true);
-      if (!reason && !_state.isSubscribing()) {
-        (0, _pendingCalls.addToPending)(this, this.subscribeToVideo, [enableVideo]);
-        return this;
-      }
-      if (reason === 'internal') {
-        // We restore to undefined to keep backward compatibility
-        // eslint-disable-next-line no-param-reassign
-        reason = undefined;
-      }
-      if (!reason) {
-        _isVideoManuallyMuted = !enableVideo;
-      } else if (reason === 'auto') {
-        updateCongestionLevel(enableVideo ? null : 2);
-      }
-      logAnalyticsEvent('subscribeToVideo', 'Attempt', {
-        subscribeToVideo: enableVideo,
-        reason
-      });
-      const attemptStart = Date.now();
-      setAudioOnly(!enableVideo || !_stream.hasVideo || !_webRTCStream);
-      if (_stream.hasVideo && !_streamHasTracks('video')) {
-        if (enableVideo) {
-          logging.info('Subscriber is audio-only due to incompatibility, can\'t subscribeToVideo.');
-        }
-        _properties.subscribeToVideo = false;
-        logAnalyticsEvent('subscribeToVideo', 'Failure', {
-          message: 'No video tracks available'
-        });
-        return this;
-      }
-      if (_chrome && _chrome.videoDisabledIndicator) {
-        // If this is an auto disableVideo then we want to show the indicator, otherwise hide it again
-        _chrome.videoDisabledIndicator.disableVideo(!enableVideo && reason === 'auto');
-      }
-      if (getAllPeerConnections().length > 0 && _session && _stream) {
-        if ((enableVideo !== _properties.subscribeToVideo || reason !== _lastSubscribeToVideoReason) && !(_isVideoManuallyMuted && !!reason)) {
-          setChannelActiveStateForSubscriber({
-            channelType: 'video',
-            activeState: enableVideo,
-            activeReason: reason
-          });
-        }
-      }
-      _properties.subscribeToVideo = enableVideo;
-      _lastSubscribeToVideoReason = reason;
-      _videoEnabled = enableVideo;
-      if (_videoMediaProcessorConnector) {
-        if (_videoEnabled) {
-          _setVideoMediaProcessorConnector();
+      subscribeToVideoWithCallback(pValue, reason);
+      return this;
+    };
+
+    /**
+     * Promise-based variant of {@link Subscriber#subscribeToVideo}.
+     *
+     * Toggles video on or off and returns a Promise that settles once all underlying
+     * operations have completed (including any video media-processor connector update).
+     *
+     * @param {Boolean} value - <code>true</code> to start subscribing to video,
+     *   <code>false</code> to stop.
+     * @param {String} [reason] - Internal reason string (e.g. <code>'auto'</code>).
+     *   Pass <code>undefined</code> for a user-initiated call.
+     * @returns {Promise<void>} Resolves when video has been successfully toggled;
+     *   rejects with an <code>Error</code> if any operation fails (e.g. no video tracks
+     *   available, or the media-processor connector throws).
+     *
+     * @example
+     * // Disable video and wait until the operation is fully complete
+     * subscriber.subscribeToVideo.promise(false)
+     *   .then(() => console.log('video disabled'))
+     *   .catch(err => console.error('failed to disable video', err));
+     *
+     * @method #subscribeToVideo.promise
+     * @memberOf Subscriber
+     */
+    this.subscribeToVideo.promise = (pValue, reason) => new Promise((resolve, reject) => {
+      subscribeToVideoWithCallback(pValue, reason, err => {
+        if (err) {
+          reject(err);
         } else {
-          _resetVideoStream();
+          resolve();
         }
-      }
-      logAnalyticsEvent('subscribeToVideo', 'Success', {
-        subscribeToVideo: enableVideo,
-        reason
-      }, {
-        attemptDuration: Date.now() - attemptStart
       });
-      if (reason !== 'loading') {
-        this.dispatchEvent(new Events.VideoEnabledChangedEvent(enableVideo ? 'videoEnabled' : 'videoDisabled', {
-          reason: reasonMap[reason] || 'subscribeToVideo'
-        }));
-      }
-      return this;
-    };
+    });
 
     /**
     * Sets the preferred resolution of the subscriber's video.
@@ -26951,12 +27125,12 @@ function SubscriberFactory(_ref2) {
       }
     };
     this._setupPeerConnection = /*#__PURE__*/function () {
-      var _ref35 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee19(_ref34) {
+      var _ref36 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee20(_ref35) {
         var send, log, logQoS, sourceStreamId, peerId;
-        return _regenerator.default.wrap(function _callee19$(_context19) {
-          while (1) switch (_context19.prev = _context19.next) {
+        return _regenerator.default.wrap(function _callee20$(_context20) {
+          while (1) switch (_context20.prev = _context20.next) {
             case 0:
-              send = _ref34.send, log = _ref34.log, logQoS = _ref34.logQoS, sourceStreamId = _ref34.sourceStreamId, peerId = _ref34.peerId;
+              send = _ref35.send, log = _ref35.log, logQoS = _ref35.logQoS, sourceStreamId = _ref35.sourceStreamId, peerId = _ref35.peerId;
               if (_properties.testNetwork) {
                 setAudioVolume(0);
               }
@@ -27008,15 +27182,15 @@ function SubscriberFactory(_ref2) {
                   });
                 });
               });
-              return _context19.abrupt("return", peerConnectionsAsync[sourceStreamId]);
+              return _context20.abrupt("return", peerConnectionsAsync[sourceStreamId]);
             case 7:
             case "end":
-              return _context19.stop();
+              return _context20.stop();
           }
-        }, _callee19);
+        }, _callee20);
       }));
-      return function (_x19) {
-        return _ref35.apply(this, arguments);
+      return function (_x22) {
+        return _ref36.apply(this, arguments);
       };
     }();
 
@@ -27073,103 +27247,103 @@ function SubscriberFactory(_ref2) {
     this.on('styleValueChanged', updateChromeForStyleChange, this);
     this._ = {
       getDataChannel(label, options, completion) {
-        return (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee20() {
-          return _regenerator.default.wrap(function _callee20$(_context20) {
-            while (1) switch (_context20.prev = _context20.next) {
+        return (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee21() {
+          return _regenerator.default.wrap(function _callee21$(_context21) {
+            while (1) switch (_context21.prev = _context21.next) {
               case 0:
                 if (getCurrentPeerConnection()) {
-                  _context20.next = 3;
+                  _context21.next = 3;
                   break;
                 }
                 completion(new OTHelpers.Error('Cannot create a DataChannel before there is a publisher connection.'));
-                return _context20.abrupt("return");
+                return _context21.abrupt("return");
               case 3:
-                _context20.next = 5;
+                _context21.next = 5;
                 return getCurrentPeerConnection();
               case 5:
-                _context20.sent.getDataChannel(label, options, completion);
+                _context21.sent.getDataChannel(label, options, completion);
               case 6:
               case "end":
-                return _context20.stop();
+                return _context21.stop();
             }
-          }, _callee20);
+          }, _callee21);
         }))();
       },
       iceRestart(reason, forcedRestart) {
-        return (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee21() {
+        return (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee22() {
           var peerConnection;
-          return _regenerator.default.wrap(function _callee21$(_context21) {
-            while (1) switch (_context21.prev = _context21.next) {
+          return _regenerator.default.wrap(function _callee22$(_context22) {
+            while (1) switch (_context22.prev = _context22.next) {
               case 0:
                 if (forcedRestart === void 0) {
                   forcedRestart = false;
                 }
                 if (_session._.isSocketConnected()) {
-                  _context21.next = 4;
+                  _context22.next = 4;
                   break;
                 }
                 logging.debug('Subscriber: Skipping ice restart, websocket is not connected');
-                return _context21.abrupt("return");
+                return _context22.abrupt("return");
               case 4:
                 if (!_session.sessionInfo.p2pEnabled) {
-                  _context21.next = 6;
+                  _context22.next = 6;
                   break;
                 }
-                return _context21.abrupt("return");
+                return _context22.abrupt("return");
               case 6:
-                _context21.next = 8;
+                _context22.next = 8;
                 return getPeerConnectionBySourceStreamId('MANTIS');
               case 8:
-                peerConnection = _context21.sent;
+                peerConnection = _context22.sent;
                 if (peerConnection) {
-                  _context21.next = 12;
+                  _context22.next = 12;
                   break;
                 }
                 logging.debug('Subscriber: Skipping ice restart, we have no peer connection');
-                return _context21.abrupt("return");
+                return _context22.abrupt("return");
               case 12:
                 logging.debug('Subscriber: iceRestart attempt');
                 peerConnection.iceRestart(reason, forcedRestart);
               case 14:
               case "end":
-                return _context21.stop();
+                return _context22.stop();
             }
-          }, _callee21);
+          }, _callee22);
         }))();
       },
       unblockAudio: () => _widgetView && _widgetView.unblockAudio(),
       webRtcStream: () => _webRTCStream,
       setIceConfig: function () {
-        var _setIceConfig = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee23(iceConfig) {
-          return _regenerator.default.wrap(function _callee23$(_context23) {
-            while (1) switch (_context23.prev = _context23.next) {
+        var _setIceConfig = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee24(iceConfig) {
+          return _regenerator.default.wrap(function _callee24$(_context24) {
+            while (1) switch (_context24.prev = _context24.next) {
               case 0:
                 getAllPeerConnections().forEach( /*#__PURE__*/function () {
-                  var _ref36 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee22(pc) {
-                    return _regenerator.default.wrap(function _callee22$(_context22) {
-                      while (1) switch (_context22.prev = _context22.next) {
+                  var _ref37 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee23(pc) {
+                    return _regenerator.default.wrap(function _callee23$(_context23) {
+                      while (1) switch (_context23.prev = _context23.next) {
                         case 0:
-                          _context22.next = 2;
+                          _context23.next = 2;
                           return pc;
                         case 2:
-                          return _context22.abrupt("return", _context22.sent.setIceConfig(iceConfig));
+                          return _context23.abrupt("return", _context23.sent.setIceConfig(iceConfig));
                         case 3:
                         case "end":
-                          return _context22.stop();
+                          return _context23.stop();
                       }
-                    }, _callee22);
+                    }, _callee23);
                   }));
-                  return function (_x21) {
-                    return _ref36.apply(this, arguments);
+                  return function (_x24) {
+                    return _ref37.apply(this, arguments);
                   };
                 }());
               case 1:
               case "end":
-                return _context23.stop();
+                return _context24.stop();
             }
-          }, _callee23);
+          }, _callee24);
         }));
-        function setIceConfig(_x20) {
+        function setIceConfig(_x23) {
           return _setIceConfig.apply(this, arguments);
         }
         return setIceConfig;
@@ -27188,15 +27362,15 @@ function SubscriberFactory(_ref2) {
         amrState.startTransitionToRouted(_transitionRelayedToRouted);
       },
       startMigration() {
-        return (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee24() {
-          return _regenerator.default.wrap(function _callee24$(_context24) {
-            while (1) switch (_context24.prev = _context24.next) {
+        return (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee25() {
+          return _regenerator.default.wrap(function _callee25$(_context25) {
+            while (1) switch (_context25.prev = _context25.next) {
               case 0:
                 if (!_state.isMigrating()) {
-                  _context24.next = 2;
+                  _context25.next = 2;
                   break;
                 }
-                return _context24.abrupt("return");
+                return _context25.abrupt("return");
               case 2:
                 _state.set('Migrating');
                 logAnalyticsEvent('SessionMigration', 'Attempt');
@@ -27206,53 +27380,53 @@ function SubscriberFactory(_ref2) {
                 socket = _session._.getSocket();
                 socket.on('signalingNetworkQualityScoreChanged', networkConditionChecker.checkNetworkConditionChange);
                 if (!_session.sessionInfo.p2pEnabled) {
-                  _context24.next = 12;
+                  _context25.next = 12;
                   break;
                 }
                 subscriberCreate('P2P');
-                _context24.next = 16;
+                _context25.next = 16;
                 break;
               case 12:
-                _context24.next = 14;
+                _context25.next = 14;
                 return getPeerConnectionBySourceStreamId('MANTIS');
               case 14:
-                _previousPeerConnection = _context24.sent;
+                _previousPeerConnection = _context25.sent;
                 subscriberCreate('MANTIS');
               case 16:
               case "end":
-                return _context24.stop();
+                return _context25.stop();
             }
-          }, _callee24);
+          }, _callee25);
         }))();
       },
       finishMigration() {
-        return (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee26() {
+        return (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee27() {
           var destroyPeerConnection, _getPeerConnectionByS;
-          return _regenerator.default.wrap(function _callee26$(_context26) {
-            while (1) switch (_context26.prev = _context26.next) {
+          return _regenerator.default.wrap(function _callee27$(_context27) {
+            while (1) switch (_context27.prev = _context27.next) {
               case 0:
                 destroyPeerConnection = /*#__PURE__*/function () {
-                  var _ref37 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee25(pc, sourceStreamId) {
-                    return _regenerator.default.wrap(function _callee25$(_context25) {
-                      while (1) switch (_context25.prev = _context25.next) {
+                  var _ref38 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee26(pc, sourceStreamId) {
+                    return _regenerator.default.wrap(function _callee26$(_context26) {
+                      while (1) switch (_context26.prev = _context26.next) {
                         case 0:
                           if (!pc) {
-                            _context25.next = 5;
+                            _context26.next = 5;
                             break;
                           }
-                          _context25.next = 3;
+                          _context26.next = 3;
                           return _subscriberStatsHelper.removePeerConnection(pc);
                         case 3:
                           pc.close();
                           delete peerConnectionsAsync[sourceStreamId];
                         case 5:
                         case "end":
-                          return _context25.stop();
+                          return _context26.stop();
                       }
-                    }, _callee25);
+                    }, _callee26);
                   }));
-                  return function destroyPeerConnection(_x22, _x23) {
-                    return _ref37.apply(this, arguments);
+                  return function destroyPeerConnection(_x25, _x26) {
+                    return _ref38.apply(this, arguments);
                   };
                 }(); // Clear previous PC
                 // We don't pass 'MANTIS' because we don't want to delete the new MANTIS peer connection
@@ -27268,9 +27442,9 @@ function SubscriberFactory(_ref2) {
                 logAnalyticsEvent('SessionMigration', 'Success');
               case 7:
               case "end":
-                return _context26.stop();
+                return _context27.stop();
             }
-          }, _callee26);
+          }, _callee27);
         }))();
       },
       setSinkId(deviceId) {
@@ -27408,6 +27582,9 @@ function SubscriberFactory(_ref2) {
     * @param {Boolean} value Whether to start subscribing to captions (<code>true</code>) or not
     * (<code>false</code>).
     *
+    * @return {Promise<void>} A promise that resolves when the server has acknowledged the
+    * caption channel update. The promise is rejected if an error occurs while sending the update.
+    *
     * @see <a href="#isSubscribedToCaptions">isSubscribedToCaptions()</a>
     * @see <a href="#event:captionReceived">captionReceived</a> event
     * @see <a href="StreamPropertyChangedEvent.html">StreamPropertyChangedEvent</a>
@@ -27416,34 +27593,36 @@ function SubscriberFactory(_ref2) {
     * @method #subscribeToCaptions
     * @memberOf Subscriber
     */
-    this.subscribeToCaptions = /*#__PURE__*/function () {
-      var _ref38 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee27(value) {
-        var active, attributes;
-        return _regenerator.default.wrap(function _callee27$(_context27) {
-          while (1) switch (_context27.prev = _context27.next) {
-            case 0:
-              active = (0, _castToBoolean.default)(value, true);
-              attributes = {
-                active
-              };
-              _properties.subscribeToCaptions = active;
-              logAnalyticsEvent('subscribeToCaptions', 'Attempt', {
-                subscribeToCaptions: active
-              });
-              socket.subscriberChannelUpdate(_stream.id, _this.widgetId, 'caption1', attributes);
-              logAnalyticsEvent('subscribeToCaptions', 'Success', {
-                subscribeToCaptions: active
-              });
-            case 6:
-            case "end":
-              return _context27.stop();
+    this.subscribeToCaptions = value => new Promise((resolve, reject) => {
+      try {
+        const active = (0, _castToBoolean.default)(value, true);
+        const attributes = {
+          active
+        };
+        _properties.subscribeToCaptions = active;
+        logAnalyticsEvent('subscribeToCaptions', 'Attempt', {
+          subscribeToCaptions: active
+        });
+        socket.subscriberChannelUpdate(_stream.id, this.widgetId, 'caption1', attributes, err => {
+          if (err) {
+            logAnalyticsEvent('subscribeToCaptions', 'Failure', {
+              message: (err == null ? void 0 : err.message) || String(err)
+            });
+            reject(err);
+          } else {
+            logAnalyticsEvent('subscribeToCaptions', 'Success', {
+              subscribeToCaptions: active
+            });
+            resolve();
           }
-        }, _callee27);
-      }));
-      return function (_x24) {
-        return _ref38.apply(this, arguments);
-      };
-    }();
+        });
+      } catch (err) {
+        logAnalyticsEvent('subscribeToCaptions', 'Failure', {
+          message: (err == null ? void 0 : err.message) || String(err)
+        });
+        reject(err);
+      }
+    });
 
     /**
      * Sets the preferred language for captions translation for this subscriber.
@@ -27467,7 +27646,7 @@ function SubscriberFactory(_ref2) {
                 _context28.next = 4;
                 break;
               }
-              message = `Invalid captions language code ${langCode}`;
+              message = `Invalid captions translation language ${langCode}`;
               logging.warn(`setCaptionsTranslationLanguage: ${message}`);
               throw otError(_Errors.default.INVALID_PARAMETER, new Error(`setCaptionsTranslationLanguage: ${message}`));
             case 4:
@@ -27486,7 +27665,7 @@ function SubscriberFactory(_ref2) {
           }
         }, _callee28);
       }));
-      return function (_x25) {
+      return function (_x27) {
         return _ref39.apply(this, arguments);
       };
     }();
@@ -27720,7 +27899,7 @@ function SubscriberFactory(_ref2) {
           }
         }, _callee29, null, [[15, 20]]);
       }));
-      return function (_x26) {
+      return function (_x28) {
         return _ref40.apply(this, arguments);
       };
     }();
@@ -27895,7 +28074,7 @@ function SubscriberFactory(_ref2) {
           }
         }, _callee31);
       }));
-      return function (_x27) {
+      return function (_x29) {
         return _ref42.apply(this, arguments);
       };
     }();
@@ -29339,8 +29518,11 @@ function RaptorSocketFactory(deps) {
     this.subscriberUpdate = function (streamId, subscriberId, attributes) {
       this.publish(RaptorMessage.subscribers.update(_apiKey, _sessionId, streamId, subscriberId, attributes), {}, true);
     };
-    this.subscriberChannelUpdate = function (streamId, subscriberId, channelId, attributes) {
-      this.publish(RaptorMessage.subscriberChannels.update(_apiKey, _sessionId, streamId, subscriberId, channelId, attributes), {}, true);
+    this.subscriberChannelUpdate = function (streamId, subscriberId, channelId, attributes, completion) {
+      if (completion === void 0) {
+        completion = () => {};
+      }
+      this.publish(RaptorMessage.subscriberChannels.update(_apiKey, _sessionId, streamId, subscriberId, channelId, attributes), {}, true, completion);
     };
     this.forceDisconnect = function (connectionIdToDisconnect, completion) {
       this.publish(RaptorMessage.connections.destroy({
@@ -41954,7 +42136,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":"1130ccbf0","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":"af69a9c37","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);
   /**