twilio-video 2.17.0 → 2.18.2

package/lib/preflight/preflighttest.ts

@@ -1,5 +1,5 @@
-import { DEFAULT_LOGGER_NAME, DEFAULT_LOG_LEVEL } from '../util/constants';
-import { PreflightOptions, PreflightTestReport, RTCIceCandidateStats, SelectedIceCandidatePairStats } from '../../tsdef/PreflightTypes';
+import { DEFAULT_ENVIRONMENT, DEFAULT_LOGGER_NAME, DEFAULT_LOG_LEVEL, DEFAULT_REALM, SDK_NAME, SDK_VERSION } from '../util/constants';
+import { PreflightOptions, PreflightTestReport, RTCIceCandidateStats, SelectedIceCandidatePairStats, Stats } from '../../tsdef/PreflightTypes';
 import { StatsReport } from '../../tsdef/types';
 import { Timer } from './timer';
 import { calculateMOS } from './mos';
@@ -10,9 +10,13 @@ import { syntheticAudio } from './syntheticaudio';
 import { syntheticVideo } from './syntheticvideo';
 import { waitForSometime } from '../util';
 
+const { WS_SERVER } = require('../util/constants');
 const Log = require('../util/log');
 const EventEmitter = require('../eventemitter');
 const MovingAverageDelta = require('../util/movingaveragedelta');
+const EventObserver = require('../util/eventobserver');
+const InsightsPublisher = require('../util/insightspublisher');
+const { createSID, sessionSID } = require('../util/sid');
 
 const SECOND = 1000;
 const DEFAULT_TEST_DURATION = 10 * SECOND;
@@ -71,6 +75,16 @@ declare interface PreflightStats {
   iceCandidateStats: RTCIceCandidateStats[],
 }
 
+declare interface PreflightTestReportInternal extends PreflightTestReport {
+  error?: string,
+  mos?: Stats|null
+}
+
+declare interface PreflightOptionsInternal extends PreflightOptions {
+  environment?: string;
+  wsServer?: string;
+}
+
 function notEmpty<TValue>(value: TValue | null | undefined): value is TValue {
   return value !== null && typeof value !== 'undefined';
 }
@@ -108,12 +122,16 @@ export class PreflightTest extends EventEmitter {
    */
   constructor(token: string, options: PreflightOptions) {
     super();
+    const internalOptions = options as PreflightOptionsInternal;
+    const { environment = 'prod', region = 'gll', duration = DEFAULT_TEST_DURATION } = internalOptions;
+    // eslint-disable-next-line new-cap
+    const wsServer = internalOptions.wsServer || WS_SERVER(environment, region);
+
     this._log = new Log('default', this, DEFAULT_LOG_LEVEL, DEFAULT_LOGGER_NAME);
-    this._testDuration = options.duration || DEFAULT_TEST_DURATION;
+    this._testDuration = duration;
     this._instanceId = nInstances++;
-
     this._testTiming.start();
-    this._runPreflightTest(token, options);
+    this._runPreflightTest(token, environment, wsServer);
   }
 
   toString(): string {
@@ -127,7 +145,7 @@ export class PreflightTest extends EventEmitter {
     this._stopped = true;
   }
 
-  private _generatePreflightReport(collectedStats: PreflightStats) : PreflightTestReport  {
+  private _generatePreflightReport(collectedStats?: PreflightStats, error? : Error) : PreflightTestReportInternal  {
     this._testTiming.stop();
     return {
       testTiming: this._testTiming.getTimeMeasurement(),
@@ -139,12 +157,15 @@ export class PreflightTest extends EventEmitter {
         media: this._mediaTiming.getTimeMeasurement()
       },
       stats: {
-        jitter: makeStat(collectedStats.jitter),
-        rtt: makeStat(collectedStats.rtt),
-        packetLoss: makeStat(collectedStats.packetLoss),
+        jitter: makeStat(collectedStats?.jitter),
+        rtt: makeStat(collectedStats?.rtt),
+        packetLoss: makeStat(collectedStats?.packetLoss),
       },
-      selectedIceCandidatePairStats: collectedStats.selectedIceCandidatePairStats,
-      iceCandidateStats: collectedStats.iceCandidateStats
+      selectedIceCandidatePairStats: collectedStats ? collectedStats.selectedIceCandidatePairStats : null,
+      iceCandidateStats: collectedStats ? collectedStats.iceCandidateStats : [],
+      // NOTE(mpatwardhan): internal properties.
+      error: error?.toString(),
+      mos: makeStat(collectedStats?.mos),
     };
   }
 
@@ -211,9 +232,79 @@ export class PreflightTest extends EventEmitter {
     }
   }
 
-  private async _runPreflightTest(token: string, options: PreflightOptions) {
+  private _setupInsights({ token, environment = DEFAULT_ENVIRONMENT, realm = DEFAULT_REALM } : {
+    token: string,
+    environment?: string,
+    realm?: string
+  }) {
+    const eventPublisherOptions = {};
+    const eventPublisher = new InsightsPublisher(
+      token,
+      SDK_NAME,
+      SDK_VERSION,
+      environment,
+      realm,
+      eventPublisherOptions);
+
+    // event publisher requires room sid/participant sid. supply fake ones.
+    eventPublisher.connect('PREFLIGHT_ROOM_SID', 'PREFLIGHT_PARTICIPANT');
+    const eventObserver = new EventObserver(eventPublisher, Date.now(), this._log);
+
+    // eslint-disable-next-line no-undefined
+    const undefinedValue = undefined;
+    return {
+      reportToInsights: ({ report }: { report: PreflightTestReportInternal }) => {
+        const jitterStats = report.stats.jitter || undefinedValue;
+        const rttStats = report.stats.rtt || undefinedValue;
+        const packetLossStats = report.stats.packetLoss || undefinedValue;
+        const mosStats  = report.mos || undefinedValue;
+
+        // stringify important info from ice candidates.
+        const candidateTypeToProtocols = new Map<string, string[]>();
+        report.iceCandidateStats.forEach(candidateStats => {
+          if (candidateStats.candidateType && candidateStats.protocol) {
+            let protocols = candidateTypeToProtocols.get(candidateStats.candidateType) || [];
+            if (protocols.indexOf(candidateStats.protocol) < 0) {
+              protocols.push(candidateStats.protocol);
+            }
+            candidateTypeToProtocols.set(candidateStats.candidateType, protocols);
+          }
+        });
+        const iceCandidateStats = JSON.stringify(Object.fromEntries(candidateTypeToProtocols));
+
+        const insightsReport  = {
+          name: 'report',
+          group: 'preflight',
+          level: report.error ? 'error' : 'info',
+          payload: {
+            sessionSID,
+            preflightSID: createSID('PF'),
+            testTiming: report.testTiming,
+            dtlsTiming: report.networkTiming.dtls,
+            iceTiming: report.networkTiming.ice,
+            peerConnectionTiming: report.networkTiming.peerConnection,
+            connectTiming: report.networkTiming.connect,
+            mediaTiming: report.networkTiming.media,
+            selectedLocalCandidate: report.selectedIceCandidatePairStats?.localCandidate,
+            selectedRemoteCandidate: report.selectedIceCandidatePairStats?.remoteCandidate,
+            iceCandidateStats,
+            jitterStats,
+            rttStats,
+            packetLossStats,
+            mosStats,
+            error: report.error
+          }
+        };
+        eventObserver.emit('event', insightsReport);
+        setTimeout(() => eventPublisher.disconnect(), 2000);
+      }
+    };
+  }
+
+  private async _runPreflightTest(token: string, environment: string, wsServer: string) {
     let localTracks: MediaStreamTrack[] = [];
     let pcs: RTCPeerConnection[] = [];
+    const { reportToInsights } = this._setupInsights({ token, environment });
     try {
       let elements = [];
       localTracks = await this._executePreflightStep('Acquire media', () => [syntheticAudio(), syntheticVideo({ width: 640, height: 480 })]);
@@ -221,7 +312,7 @@ export class PreflightTest extends EventEmitter {
       this.emit('debug', { localTracks });
 
       this._connectTiming.start();
-      let iceServers = await this._executePreflightStep('Get turn credentials', () => getTurnCredentials(token, options));
+      let iceServers = await this._executePreflightStep('Get turn credentials', () => getTurnCredentials(token, wsServer));
       this._connectTiming.stop();
       this.emit('progress', PreflightProgress.connected);
 
@@ -287,9 +378,12 @@ export class PreflightTest extends EventEmitter {
         () => this._collectRTCStatsForDuration(this._testDuration, initCollectedStats(), senderPC, receiverPC));
 
       const report = await this._executePreflightStep('generate report', () => this._generatePreflightReport(collectedStats));
+      reportToInsights({ report });
       this.emit('completed', report);
 
     } catch (error) {
+      // eslint-disable-next-line no-undefined
+      reportToInsights({ report: this._generatePreflightReport(undefined, error) });
       this.emit('failed', error);
     } finally {
       pcs.forEach(pc => pc.close());

package/lib/signaling/v2/cancelableroomsignalingpromise.js

@@ -57,8 +57,6 @@ function createCancelableRoomSignalingPromise(token, wsServer, localParticipant,
     };
 
     const {
-      InsightsPublisher,
-      NullInsightsPublisher,
       automaticSubscription,
       bandwidthProfile,
       dominantSpeaker,
@@ -69,10 +67,8 @@ function createCancelableRoomSignalingPromise(token, wsServer, localParticipant,
       name,
       networkMonitor,
       networkQuality,
-      insights,
       realm,
       sdpSemantics,
-      wsServerInsights
     } = options;
 
     // decide which msp channels to request
@@ -92,20 +88,13 @@ function createCancelableRoomSignalingPromise(token, wsServer, localParticipant,
       networkMonitor,
       networkQuality,
       iceServers,
-      insights,
       onIced,
       realm,
       renderHints,
       sdpSemantics,
       trackPriority,
       trackSwitchOff
-    }, typeof wsServerInsights === 'string' ? {
-      wsServerInsights
-    } : {}, InsightsPublisher ? {
-      InsightsPublisher
-    } : {}, NullInsightsPublisher ? {
-      NullInsightsPublisher
-    } : {}, bandwidthProfile ? {
+    }, bandwidthProfile ? {
       bandwidthProfile
     } : {});
 

package/lib/signaling/v2/mediasignaling.js

@@ -50,19 +50,16 @@ class MediaSignaling extends EventEmitter {
     const receiverPromise = this._getReceiver(id).then(receiver => {
       if (receiver.kind !== 'data') {
         this._log.error('Expected a DataTrackReceiver');
-        throw new Error('Expected a DataTrackReceiver');
       } if (this._receiverPromise !== receiverPromise) {
         return;
       }
 
       try {
         this._transport = receiver.toDataTransport();
+        this.emit('ready', this._transport);
       } catch (ex) {
-        this._log.error('Failed to toDataTransport');
-        throw new Error('Failed to toDataTransport');
+        this._log.error(`Failed to toDataTransport: ${ex.message}`);
       }
-      this.emit('ready', this._transport);
-
       receiver.once('close', () => this._teardown());
     });
     this._receiverPromise = receiverPromise;

package/lib/signaling/v2/peerconnection.js

@@ -904,7 +904,9 @@ class PeerConnectionV2 extends StateMachine {
       log.debug(`Starting ICE reconnect timeout: ${delay}`);
       this._iceReconnectTimeout.start();
     }
-    this.offer();
+    this.offer().catch(ex => {
+      log.error(`offer failed in _initiateIceRestart with: ${ex.message}`);
+    });
   }
 
   /**
@@ -1747,7 +1749,7 @@ function updateEncodingParameters(pcv2) {
       params.encodings[0].networkPriority = 'high';
     }
 
-    if (!isFirefox && sender.track.kind === 'video') {
+    if (isSafari && sender.track.kind === 'video') {
       const { width, height }  = sender.track.getSettings();
       pcv2._updateEncodings(width, height, params.encodings);
     }

package/lib/signaling/v2/twilioconnectiontransport.js

@@ -1,14 +1,12 @@
 'use strict';
 
 const { getSdpFormat } = require('@twilio/webrtc/lib/util/sdp');
-const packageInfo = require('../../../package.json');
-const InsightsPublisher = require('../../util/insightspublisher');
-const NullInsightsPublisher = require('../../util/insightspublisher/null');
 const StateMachine = require('../../statemachine');
 const TwilioConnection = require('../../twilioconnection');
 const DefaultBackoff = require('backoff');
 const { reconnectBackoffConfig } = require('../../util/constants');
 const Timeout = require('../../util/timeout');
+const { SDK_NAME, SDK_VERSION } = require('../../util/constants');
 
 const {
   createBandwidthProfilePayload,
@@ -27,8 +25,6 @@ const {
 
 const ICE_VERSION = 1;
 const RSP_VERSION = 2;
-const SDK_NAME = `${packageInfo.name}.js`;
-const SDK_VERSION = packageInfo.version;
 
 /*
 TwilioConnectionTransport States
@@ -90,8 +86,6 @@ class TwilioConnectionTransport extends StateMachine {
   constructor(name, accessToken, localParticipant, peerConnectionManager, wsServer, options) {
     options = Object.assign({
       Backoff: DefaultBackoff,
-      InsightsPublisher,
-      NullInsightsPublisher,
       TwilioConnection,
       iceServers: null,
       sdpFormat: getSdpFormat(options.sdpSemantics),
@@ -102,19 +96,6 @@ class TwilioConnectionTransport extends StateMachine {
     }, options);
     super('connecting', states);
 
-    const eventPublisherOptions = {};
-    if (options.wsServerInsights) {
-      eventPublisherOptions.gateway = options.wsServerInsights;
-    }
-
-    const EventPublisher = options.insights ? options.InsightsPublisher : options.NullInsightsPublisher;
-    const eventPublisher = new EventPublisher(
-      accessToken,
-      SDK_NAME,
-      SDK_VERSION,
-      options.environment,
-      options.realm,
-      eventPublisherOptions);
 
     Object.defineProperties(this, {
       _accessToken: {
@@ -126,9 +107,6 @@ class TwilioConnectionTransport extends StateMachine {
       _bandwidthProfile: {
         value: options.bandwidthProfile
       },
-      _disconnectEventPublisher: {
-        value: () => eventPublisher.disconnect()
-      },
       _dominantSpeaker: {
         value: options.dominantSpeaker
       },
@@ -198,16 +176,9 @@ class TwilioConnectionTransport extends StateMachine {
       }
     });
 
-    // eslint-disable-next-line no-warning-comments
-    // TODO(mmalavalli): Create and set EventPublisher outside this class, so
-    // that the EventPublisher constructor is no longer a dependency.
-    this._eventObserver.setPublisher(eventPublisher);
 
     setupTransport(this);
 
-    this.once('connected', ({ sid, participant }) => {
-      eventPublisher.connect(sid, participant.sid);
-    });
   }
 
   /**
@@ -315,7 +286,6 @@ class TwilioConnectionTransport extends StateMachine {
       this.preempt('disconnected', null, [error]);
       this._sendConnectOrSyncOrDisconnectMessage();
       this._twilioConnection.close();
-      this._disconnectEventPublisher();
       return true;
     }
     return false;

package/lib/util/constants.js

@@ -1,4 +1,7 @@
 'use strict';
+const packageInfo = require('../../package.json');
+module.exports.SDK_NAME = `${packageInfo.name}.js`;
+module.exports.SDK_VERSION = packageInfo.version;
 
 module.exports.DEFAULT_ENVIRONMENT = 'prod';
 module.exports.DEFAULT_REALM = 'us1';

package/lib/util/eventobserver.js

@@ -8,7 +8,8 @@ const VALID_GROUPS = [
   'room',
   'media',
   'quality',
-  'video-processor'
+  'video-processor',
+  'preflight'
 ];
 
 const VALID_LEVELS = [
@@ -27,40 +28,35 @@ const VALID_LEVELS = [
 class EventObserver extends EventEmitter {
   /**
    * Constructor.
+   * @param {InsightsPublisher} publisher
    * @param {number} connectTimestamp
    * @param {Log} log
    * @param {EventListener} [eventListener]
    */
-  constructor(connectTimestamp, log, eventListener = null) {
+  constructor(publisher, connectTimestamp, log, eventListener = null) {
     super();
-
-    Object.defineProperties(this, {
-      _publisher: {
-        value: null,
-        writable: true
-      }
-    });
-
     this.on('event', ({ name, group, level, payload }) => {
       if (typeof name !== 'string') {
+        log.error('Unexpected name: ', name);
         throw new Error('Unexpected name: ', name);
       }
 
       if (!VALID_GROUPS.includes(group)) {
+        log.error('Unexpected group: ', group);
         throw new Error('Unexpected group: ', group);
       }
 
       if (!VALID_LEVELS.includes(level)) {
+        log.error('Unexpected level: ', level);
         throw new Error('Unexpected level: ', level);
       }
 
       const timestamp = Date.now();
       const elapsedTime = timestamp - connectTimestamp;
 
-      if (this._publisher) {
-        const publisherPayload = Object.assign({ elapsedTime, level }, payload ? payload : {});
-        this._publisher.publish(group, name, publisherPayload);
-      }
+      const publisherPayload = Object.assign({ elapsedTime, level }, payload ? payload : {});
+      publisher.publish(group, name, publisherPayload);
+
       const event = Object.assign({
         elapsedTime,
         group,
@@ -82,14 +78,6 @@ class EventObserver extends EventEmitter {
       }
     });
   }
-
-  /**
-   * sets the publisher object. Once set events will be sent to publisher.
-   * @param {InsightsPublisher} publisher
-  */
-  setPublisher(publisher) {
-    this._publisher = publisher;
-  }
 }
 
 /**

package/lib/util/index.js

@@ -3,6 +3,7 @@
 const constants = require('./constants');
 const { typeErrors: E, trackPriority } = constants;
 const util = require('@twilio/webrtc/lib/util');
+const { sessionSID } = require('./sid');
 
 /**
  * Return the given {@link LocalTrack} or a new {@link LocalTrack} for the
@@ -572,6 +573,8 @@ function createRoomConnectEventPayload(connectOptions) {
     return val ? 'true' : 'false';
   }
   const payload = {
+    sessionSID,
+
     // arrays props converted to lengths.
     iceServers: (connectOptions.iceServers || []).length,
     audioTracks: (connectOptions.tracks || []).filter(track => track.kind === 'audio').length,

package/lib/util/sid.js

@@ -0,0 +1,20 @@
+const SID_CHARS = '1234567890abcdef';
+const SID_CHAR_LENGTH = 32;
+// copied from: https://code.hq.twilio.com/flex/monkey/blob/0fdce2b6c52d6be0b17a5cdb92f0c54f119b8ea8/src/client/lib/sid.ts#L39
+
+/**
+ * Generates a random sid using given prefix.
+ * @param {string} prefix
+ * @returns string
+ */
+function createSID(prefix) {
+  let result = '';
+  for (let i = 0; i < SID_CHAR_LENGTH; i++) {
+    result += SID_CHARS.charAt(Math.floor(Math.random() * SID_CHARS.length));
+  }
+  return `${prefix}${result}`;
+}
+
+exports.sessionSID = createSID('SS');
+exports.createSID = createSID;
+

package/lib/util/twilio-video-errors.js

@@ -19,9 +19,6 @@ exports.createTwilioError = function createTwilioError(code, message) {
   return TwilioErrorByCode[code] ? new TwilioErrorByCode[code]() : new TwilioError(code, message);
 };
 
-// Note(mpatwardhan): We derive twilio specific errors here. After typescript compiles to es5 `instanceof` does not work
-// on objects that derive from Error/Array types. To workaround we call setPrototypeOf after calling super()
-// more on this at: https://github.com/Microsoft/TypeScript/wiki/Breaking-Changes#extending-built-ins-like-error-array-and-map-may-no-longer-work
 /**
  * @class AccessTokenInvalidError
  * @classdesc Raised whenever the AccessToken used for connecting to a Room is invalid.
@@ -239,6 +236,7 @@ class SignalingServerBusyError extends TwilioError {
     Object.setPrototypeOf(this, SignalingServerBusyError.prototype);
   }
 }
+
 exports.SignalingServerBusyError = SignalingServerBusyError;
 Object.defineProperty(TwilioErrorByCode, 53006, { value: SignalingServerBusyError });
 
@@ -388,7 +386,7 @@ Object.defineProperty(TwilioErrorByCode, 53107, { value: RoomMaxParticipantsOutO
 class RoomTypeInvalidError extends TwilioError {
   constructor() {
     super(53108, 'RoomType is not valid');
-    Object.setPrototypeOf(this, RoomMaxParticipantsOutOfRangeError.prototype);
+    Object.setPrototypeOf(this, RoomTypeInvalidError.prototype);
   }
 }
 
@@ -565,6 +563,40 @@ class RoomCompletedError extends TwilioError {
 exports.RoomCompletedError = RoomCompletedError;
 Object.defineProperty(TwilioErrorByCode, 53118, { value: RoomCompletedError });
 
+/**
+ * @class RoomAudioOnlyFlagNotSupportedError
+ * @classdesc Raised whenever a participant tries to set the AudioOnly flag for a Room type other than Group Rooms.
+ * @extends TwilioError
+ * @property {number} code - 53124
+ * @property {string} message - 'The AudioOnly flag is not supported for the Room type'
+ */
+class RoomAudioOnlyFlagNotSupportedError extends TwilioError {
+  constructor() {
+    super(53124, 'The AudioOnly flag is not supported for the Room type');
+    Object.setPrototypeOf(this, RoomAudioOnlyFlagNotSupportedError.prototype);
+  }
+}
+
+exports.RoomAudioOnlyFlagNotSupportedError = RoomAudioOnlyFlagNotSupportedError;
+Object.defineProperty(TwilioErrorByCode, 53124, { value: RoomAudioOnlyFlagNotSupportedError });
+
+/**
+ * @class RoomTrackKindNotSupportedError
+ * @classdesc Raised whenever a participant tries to publish a track or connects with a track that is not supported by the group room.
+ * @extends TwilioError
+ * @property {number} code - 53125
+ * @property {string} message - 'The track kind is not supported by the Room'
+ */
+class RoomTrackKindNotSupportedError extends TwilioError {
+  constructor() {
+    super(53125, 'The track kind is not supported by the Room');
+    Object.setPrototypeOf(this, RoomTrackKindNotSupportedError.prototype);
+  }
+}
+
+exports.RoomTrackKindNotSupportedError = RoomTrackKindNotSupportedError;
+Object.defineProperty(TwilioErrorByCode, 53125, { value: RoomTrackKindNotSupportedError });
+
 /**
  * @class ParticipantIdentityInvalidError
  * @classdesc Raised whenever a Participant identity is invalid, and the scenario is not covered by a more specific error code.
@@ -618,7 +650,7 @@ Object.defineProperty(TwilioErrorByCode, 53202, { value: ParticipantIdentityChar
 
 /**
  * @class ParticipantMaxTracksExceededError
- * @classdesc Raised when the Room limit for published tracks has been reached and a Participant tries to publish a track to the Room.
+ * @classdesc Raised whenever a Participant tries to publish a Track and the maximum number of published tracks allowed in the Room at the same time has been reached
  * @extends TwilioError
  * @property {number} code - 53203
  * @property {string} message - 'The maximum number of published tracks allowed in the Room at the same time has been reached'

package/package.json

@@ -2,7 +2,7 @@
   "name": "twilio-video",
   "title": "Twilio Video",
   "description": "Twilio Video JavaScript Library",
-  "version": "2.17.0",
+  "version": "2.18.2",
   "homepage": "https://twilio.com",
   "author": "Mark Andrus Roberts <mroberts@twilio.com>",
   "contributors": [
@@ -85,7 +85,7 @@
     "vinyl-fs": "^2.4.4",
     "vinyl-source-stream": "^1.1.0",
     "watchify": "^3.11.1",
-    "webrtc-adapter": "^4.1.1"
+    "webrtc-adapter": "^7.7.1"
   },
   "engines": {
     "node": ">=0.12"
@@ -97,7 +97,8 @@
     "lint:js": "eslint ./lib ./test/*.js ./docker/**/*.js ./test/framework/*.js ./test/lib/*.js ./test/integration/** ./test/unit/** ",
     "lint:ts": "eslint ./tsdef/*.ts ./lib/**/*.ts",
     "lint": "npm-run-all lint:js lint:ts",
-    "test:unit": "npm-run-all build:es5 test:unit:js test:unit:ts",
+    "printVersion": "node --version && npm --version",
+    "test:unit": "npm-run-all printVersion build:es5 test:unit:js test:unit:ts",
     "test:unit:js": "nyc --report-dir=./coverage/js --extension=.js --include=lib/**/* --reporter=html --reporter=lcov --reporter=text mocha ./test/unit/index.js",
     "test:unit:ts": "nyc --report-dir=./coverage/ts --extension=.ts --include=lib/**/* --reporter=html --reporter=lcov --reporter=text mocha -r ts-node/register ./test/unit/index.ts",
     "test:serversiderender": "mocha ./test/serversiderender/index.js",

package/tsconfig.json

@@ -4,7 +4,7 @@
     "checkJs": false,
     "declaration": false,
     "target": "es5",
-    "lib": ["es5", "es6", "es2016", "es2017.object", "es2018.promise", "dom"],
+    "lib": ["es5", "es6", "es2016", "es2019", "es2018.promise", "dom"],
     "downlevelIteration": true,
     "module": "commonjs",
     "noImplicitAny": true,

package/tsdef/PreflightTypes.d.ts

@@ -1,6 +1,5 @@
 export interface PreflightOptions {
   duration?: number;
-  environment?: string;
   region?: string;
 }
 
@@ -26,7 +25,7 @@ export interface RTCIceCandidateStats {
   candidateType?: string;
   priority?: number;
   url?: string;
-  relayProtocol?: number;
+  relayProtocol?: string;
 }
 
 export interface SelectedIceCandidatePairStats {