djs-selfbot-v13 3.7.33 → 3.7.34

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "djs-selfbot-v13",
-  "version": "3.7.33",
+  "version": "3.7.34",
   "description": "An unofficial discord.js fork for creating selfbots",
   "main": "./src/index.js",
   "types": "./typings/index.d.ts",
@@ -51,6 +51,8 @@
   },
   "homepage": "https://djs-selfbot.vercel.app/",
   "dependencies": {
+    "@dank074/discord-video-stream": "^6.0.0",
+    "@snazzah/davey": "^0.1.11",
     "@discordjs/builders": "^1.6.3",
     "@discordjs/collection": "^2.1.1",
     "@sapphire/async-queue": "^1.5.5",
@@ -68,6 +70,11 @@
     "werift-rtp": "^0.8.4",
     "ws": "^8.16.0"
   },
+  "optionalDependencies": {
+    "@snazzah/davey-linux-x64-gnu": "0.1.11",
+    "@snazzah/davey-linux-x64-musl": "0.1.11",
+    "@snazzah/davey-win32-x64-msvc": "0.1.11"
+  },
   "engines": {
     "node": ">=20.18"
   },

package/src/client/Client.js

@@ -10,6 +10,7 @@ const BaseClient = require('./BaseClient');
 const ActionsManager = require('./actions/ActionsManager');
 const ClientVoiceManager = require('./voice/ClientVoiceManager');
 const StreamSession = require('./voice/StreamSession');
+const WebRtcStreamSession = require('./voice/WebRtcStreamSession');
 const WebSocketManager = require('./websocket/WebSocketManager');
 const { Error, TypeError } = require('../errors');
 const BaseGuildEmojiManager = require('../managers/BaseGuildEmojiManager');
@@ -920,51 +921,44 @@ class Client extends BaseClient {
       guildId,
       channelId,
       url,
-      fps = 30,
+      fps,
       height,
       width,
-      bitrate = 2000,
+      bitrate = 5000,
+      bitrateMax,
       audioBitrate,
-      videoCodec = 'H264',
       preset,
+      tune,
       audio,
-      video = false,
+      livestream = false,
+      downloadHttp = true,
     } = options;
 
     if (!url) throw new Error('STREAM_URL_REQUIRED');
     if (!guildId || !channelId) throw new Error('STREAM_CHANNEL_REQUIRED');
 
-    const channel =
-      this.guilds.cache.get(guildId)?.channels.cache.get(channelId) ?? this.channels.cache.get(channelId);
-
-    if (!channel) throw new Error('STREAM_CHANNEL_NOT_FOUND');
-
-    const voiceConnection = await this.voice.joinChannel(channel, {
-      selfVideo: Boolean(video),
-      videoCodec,
-    });
-
-    const streamConnection = await voiceConnection.createStreamConnection();
-
-    if (!video && voiceConnection.status === VoiceStatus.CONNECTED) {
-      voiceConnection.setVideoStatus(false);
+    let playUrl = url;
+    if (typeof url === 'string' && url.startsWith('http') && downloadHttp) {
+      playUrl = await WebRtcStreamSession.resolveUrl(url);
     }
 
-    await streamConnection.waitForDaveReady();
-    streamConnection.sendScreenshareState(false);
-
-    const session = new StreamSession(this, voiceConnection, streamConnection, {
-      url,
+    const session = new WebRtcStreamSession(this, {
+      guildId,
+      channelId,
+      url: playUrl,
       fps,
       height,
       width,
       bitrate,
+      bitrateMax,
       audioBitrate,
       preset,
+      tune,
       audio,
+      livestream,
     });
 
-    session._play();
+    await session.start();
     return session;
   }
 

package/src/client/voice/ClientVoiceManager.js

@@ -2,7 +2,7 @@
 
 const VoiceConnection = require('./VoiceConnection');
 const { Error } = require('../../errors');
-const { Events, VoiceStatus, Opcodes } = require('../../util/Constants');
+const { Events, VoiceStatus, Opcodes } = require('../../util/Constants');
 
 /**
  * Manages voice connections for the client
@@ -60,7 +60,7 @@ class ClientVoiceManager {
 
   onVoiceStateUpdate(payload) {
     const { guild_id, session_id, channel_id } = payload;
-    if (payload.user_id !== this.client.user?.id) return;
+    if (payload.user_id !== this.client.user?.id) return;
     // @discordjs/voice
     if (payload.guild_id && payload.session_id && payload.user_id === this.client.user?.id) {
       this.adapters.get(payload.guild_id)?.onVoiceStateUpdate(payload);
@@ -72,9 +72,9 @@ class ClientVoiceManager {
     this.client.emit('debug', `[VOICE] connection? ${!!connection}, ${guild_id} ${session_id} ${channel_id}`);
     if (!connection) return;
     if (!channel_id) {
-      if (connection.status === VoiceStatus.AUTHENTICATING || connection.status === VoiceStatus.CONNECTING) {
-        return;
-      }
+      if (connection.status === VoiceStatus.AUTHENTICATING || connection.status === VoiceStatus.CONNECTING) {
+        return;
+      }
       connection._disconnect();
       this.connection = null;
       return;
@@ -97,62 +97,73 @@ class ClientVoiceManager {
    * @typedef {Object} JoinChannelConfig
    */
 
-  /**
-   * Clears stale voice/stream state before joining a channel.
-   * @param {VoiceChannel} channel The channel to join
-   * @returns {Promise<void>}
-   * @private
-   */
-  preJoinCleanup(channel) {
-    return new Promise(resolve => {
-      const userId = this.client.user?.id;
-      const voiceState = channel.guild?.voiceStates.cache.get(userId);
-      const inTarget = voiceState?.channelId === channel.id;
-      const isStreaming = voiceState?.streaming || this.client.user?.voice?.streaming;
-      const needsCleanup = inTarget && (isStreaming || !this.connection);
-
-      if (!needsCleanup) {
-        resolve();
-        return;
-      }
-
-      const streamKey = `guild:${channel.guild.id}:${channel.id}:${userId}`;
-      let settled = false;
-      const done = () => {
-        if (settled) return;
-        settled = true;
-        this.client.removeListener(Events.VOICE_STATE_UPDATE, onState);
-        setTimeout(resolve, 400).unref();
-      };
-
-      const onState = (_old, newState) => {
-        if (newState.id !== userId) return;
-        if (!newState.channelId && !newState.streaming) done();
-      };
-
-      this.client.on(Events.VOICE_STATE_UPDATE, onState);
-
-      if (isStreaming) {
-        this.client.ws.broadcast({
-          op: Opcodes.STREAM_DELETE,
-          d: { stream_key: streamKey },
-        });
-      }
-
-      this.client.ws.broadcast({
-        op: Opcodes.VOICE_STATE_UPDATE,
-        d: {
-          guild_id: channel.guild.id,
-          channel_id: null,
-          self_mute: false,
-          self_deaf: false,
-        },
-      });
-
-      setTimeout(done, 4000).unref();
-    });
-  }
-
+  /**
+   * Clears stale voice/stream state before joining a channel.
+   * @param {VoiceChannel} channel The channel to join
+   * @returns {Promise<void>}
+   * @private
+   */
+  preJoinCleanup(channel) {
+    return new Promise(resolve => {
+      const guild = channel.guild;
+      if (!guild) {
+        resolve();
+        return;
+      }
+
+      const userId = this.client.user?.id;
+      const voiceState = guild.voiceStates.cache.get(userId);
+      const inVoice = Boolean(voiceState?.channelId);
+      const isStreaming = Boolean(voiceState?.streaming);
+
+      if (this.connection) {
+        this.connection.disconnect();
+        this.connection = null;
+      }
+
+      if (!inVoice && !isStreaming) {
+        resolve();
+        return;
+      }
+
+      const streamKey = `guild:${guild.id}:${voiceState.channelId}:${userId}`;
+      let settled = false;
+      const done = () => {
+        if (settled) return;
+        settled = true;
+        this.client.removeListener(Events.VOICE_STATE_UPDATE, onState);
+        setTimeout(resolve, 500).unref();
+      };
+
+      const onState = (_old, newState) => {
+        if (newState.id !== userId || newState.guild?.id !== guild.id) return;
+        if (!newState.channelId && !newState.streaming) done();
+      };
+
+      this.client.on(Events.VOICE_STATE_UPDATE, onState);
+      this.client.emit('debug', `[VOICE] preJoinCleanup: quitte le salon ${voiceState.channelId}`);
+
+      if (isStreaming) {
+        this.client.ws.broadcast({
+          op: Opcodes.STREAM_DELETE,
+          d: { stream_key: streamKey },
+        });
+      }
+
+      this.client.ws.broadcast({
+        op: Opcodes.VOICE_STATE_UPDATE,
+        d: {
+          guild_id: guild.id,
+          channel_id: null,
+          self_mute: false,
+          self_deaf: false,
+        },
+      });
+
+      setTimeout(done, 5000).unref();
+    });
+  }
+
   /**
    * Sets up a request to join a voice channel.
    * @param {VoiceChannel | StageChannel | DMChannel | GroupDMChannel | Snowflake} channel The voice channel to join
@@ -166,32 +177,32 @@ class ClientVoiceManager {
         throw new Error('VOICE_JOIN_CHANNEL', channel.full);
       }
 
-      const startJoin = () => {
+      const startJoin = () => {
       let connection = this.connection;
 
-      if (connection?.status === VoiceStatus.CONNECTED && connection.channel.id === channel.id) {
+      if (connection?.status === VoiceStatus.CONNECTED && connection.channel.id === channel.id) {
         resolve(connection);
         return;
       }
 
-      if (connection) {
-        connection.disconnect();
-        this.connection = null;
-        connection = null;
-      }
-
-      connection = new VoiceConnection(this, channel);
-      if (config?.videoCodec) connection.setVideoCodec(config.videoCodec);
-      connection.on('debug', msg =>
-        this.client.emit('debug', `[VOICE (${channel.guild?.id || channel.id}:${connection.status})]: ${msg}`),
-      );
-      connection.authenticate({
-        self_mute: Boolean(config.selfMute),
-        self_deaf: Boolean(config.selfDeaf),
-        self_video: Boolean(config.selfVideo),
-      });
-      this.connection = connection;
-
+      if (connection) {
+        connection.disconnect();
+        this.connection = null;
+        connection = null;
+      }
+
+      connection = new VoiceConnection(this, channel);
+      if (config?.videoCodec) connection.setVideoCodec(config.videoCodec);
+      connection.on('debug', msg =>
+        this.client.emit('debug', `[VOICE (${channel.guild?.id || channel.id}:${connection.status})]: ${msg}`),
+      );
+      connection.authenticate({
+        self_mute: Boolean(config.selfMute),
+        self_deaf: Boolean(config.selfDeaf),
+        self_video: Boolean(config.selfVideo),
+      });
+      this.connection = connection;
+
       connection.once('failed', reason => {
         this.connection = null;
         reject(reason);
@@ -208,9 +219,9 @@ class ClientVoiceManager {
           this.connection = null;
         });
       });
-      };
-
-      this.preJoinCleanup(channel).then(startJoin).catch(reject);
+      };
+
+      this.preJoinCleanup(channel).then(startJoin).catch(reject);
     });
   }
 }

package/src/client/voice/StreamSession.js

@@ -1,5 +1,8 @@
 'use strict';
 
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
 const { EventEmitter } = require('events');
 
 /**
@@ -7,6 +10,21 @@ const { EventEmitter } = require('events');
  * @extends {EventEmitter}
  */
 class StreamSession extends EventEmitter {
+  /**
+   * Downloads an HTTP(S) video to a temp file (recommended on VPS).
+   * @param {string} url Remote video URL
+   * @returns {Promise<string>} Local file path
+   */
+  static async resolveUrl(url) {
+    const response = await fetch(url);
+    if (!response.ok) throw new Error(`STREAM_URL_HTTP_${response.status}`);
+    const buffer = Buffer.from(await response.arrayBuffer());
+    if (buffer.length < 1024) throw new Error('STREAM_URL_INVALID');
+    const tmpPath = path.join(os.tmpdir(), `djs-stream-${Date.now()}.mp4`);
+    fs.writeFileSync(tmpPath, buffer);
+    console.log(`[stream] vidéo téléchargée: ${tmpPath} (${(buffer.length / 1024 / 1024).toFixed(2)} Mo)`);
+    return tmpPath;
+  }
   /**
    * @param {import('../Client')} client Discord client
    * @param {import('./VoiceConnection')} voiceConnection Voice connection
@@ -68,6 +86,8 @@ class StreamSession extends EventEmitter {
 
     if (!url.startsWith('http')) {
       videoOptions.inputFFmpegArgs = ['-re'];
+    } else {
+      videoOptions.inputFFmpegArgs = ['-reconnect', '1', '-reconnect_at_eof', '1', '-reconnect_streamed', '1'];
     }
 
     this.videoDispatcher = this.streamConnection.playVideo(url, videoOptions);
@@ -80,6 +100,8 @@ class StreamSession extends EventEmitter {
       };
       if (!url.startsWith('http')) {
         audioOptions.inputFFmpegArgs = ['-re'];
+      } else {
+        audioOptions.inputFFmpegArgs = ['-reconnect', '1', '-reconnect_at_eof', '1', '-reconnect_streamed', '1'];
       }
       this.voiceAudioDispatcher = this.voiceConnection.playAudio(url, audioOptions);
       this.audioDispatcher = this.streamConnection.playAudio(url, audioOptions);
@@ -165,4 +187,7 @@ module.exports = StreamSession;
  * @property {string} [preset='ultrafast'] x264 preset
  * @property {boolean} [audio=true] Whether to play audio
  * @property {boolean} [video=false] Enable webcam (false = screenshare only)
+ * @property {boolean} [downloadHttp=true] Download HTTP URLs locally before playback
+ * @property {number} [bitrateMax] Max video bitrate in kbps
+ * @property {boolean} [livestream=false] Enable readrateInitialBurst (live sources)
  */

package/src/client/voice/VoiceConnection.js

@@ -498,6 +498,7 @@ class VoiceConnection extends EventEmitter {
    * @private
    */
   authenticate(options = {}) {
+    this._joinOptions = options;
     this.sendVoiceStateUpdate(options);
     this.connectTimeout = setTimeout(() => this.authenticateFailed('VOICE_CONNECTION_TIMEOUT'), 30_000).unref();
   }

package/src/client/voice/WebRtcStreamSession.js

@@ -0,0 +1,191 @@
+'use strict';
+
+const { EventEmitter } = require('events');
+const { PassThrough } = require('stream');
+const ffmpeg = require('fluent-ffmpeg');
+const { Streamer, playStream } = require('@dank074/discord-video-stream');
+const StreamSession = require('./StreamSession');
+const StageChannel = require('../../structures/StageChannel');
+
+if (typeof globalThis.WebSocket === 'undefined') {
+  globalThis.WebSocket = require('ws');
+}
+
+let _ffmpegPathReady = null;
+
+/** Utilise le ffmpeg jellyfin de node-av (libx264/libopus) si disponible. */
+function ensureFfmpegPath() {
+  if (_ffmpegPathReady) return _ffmpegPathReady;
+  _ffmpegPathReady = import('node-av/ffmpeg')
+    .then(({ ffmpegPath, isFfmpegAvailable }) => {
+      if (!isFfmpegAvailable()) {
+        console.warn('[stream] ffmpeg node-av introuvable — ffmpeg système utilisé (vérifie libx264/libopus)');
+        return null;
+      }
+      const path = ffmpegPath();
+      ffmpeg.setFfmpegPath(path);
+      console.log(`[stream] ffmpeg: ${path}`);
+      return path;
+    })
+    .catch(() => {
+      console.warn('[stream] impossible de charger node-av/ffmpeg — ffmpeg système utilisé');
+      return null;
+    });
+  return _ffmpegPathReady;
+}
+
+/**
+ * Go Live via WebRTC — ffmpeg custom (sans azmq) + playStream de la librairie.
+ * @extends {EventEmitter}
+ */
+class WebRtcStreamSession extends EventEmitter {
+  static resolveUrl = StreamSession.resolveUrl;
+
+  /**
+   * @param {import('../Client')} client
+   * @param {import('./StreamSession').StartStreamOptions} options
+   */
+  constructor(client, options) {
+    super();
+    this.client = client;
+    this.options = options;
+    this.streamer = new Streamer(client);
+    this._abort = new AbortController();
+    this._playPromise = null;
+    this._command = null;
+    this._started = false;
+  }
+
+  /**
+   * Construit la commande ffmpeg : transcode en H264 + Opus, sortie nut.
+   * Pas de filtre azmq (compatibilité ffmpeg sans libzmq).
+   */
+  _buildFfmpeg(url) {
+    const {
+      fps,
+      height = 720,
+      width = -2,
+      bitrate = 5000,
+      bitrateMax,
+      audioBitrate = 128,
+      preset = 'superfast',
+      tune = 'film',
+      audio,
+    } = this.options;
+
+    const maxRate = bitrateMax ?? Math.round(bitrate * 1.5);
+    const includeAudio = audio !== false;
+    const output = new PassThrough();
+    const command = ffmpeg(url);
+
+    const isHttp = typeof url === 'string' && /^https?:\/\//i.test(url);
+    if (isHttp) {
+      command.inputOptions([
+        '-reconnect 1',
+        '-reconnect_at_eof 1',
+        '-reconnect_streamed 1',
+        '-reconnect_delay_max 4294',
+      ]);
+    }
+
+    command.output(output).outputFormat('nut');
+
+    command.addOutputOption('-map 0:v');
+    command.videoFilter(`scale=${width}:${height}`);
+    // fps forcé seulement si demandé explicitement (sinon on garde celui de la source = vitesse 1x)
+    if (fps && fps > 0) command.fpsOutput(fps);
+    command.addOutputOption([
+      '-b:v',
+      `${bitrate}k`,
+      '-maxrate:v',
+      `${maxRate}k`,
+      '-bufsize:v',
+      `${Math.round(bitrate / 2)}k`,
+      '-bf',
+      '0',
+      '-pix_fmt',
+      'yuv420p',
+      '-force_key_frames',
+      'expr:gte(t,n_forced*1)',
+    ]);
+    command.videoCodec('libx264');
+    command.outputOptions(['-forced-idr 1', `-tune ${tune}`, `-preset ${preset}`]);
+
+    if (includeAudio) {
+      command.addOutputOption('-map 0:a:0?');
+      command.audioChannels(2);
+      command.audioFrequency(48000);
+      command.audioCodec('libopus');
+      command.audioBitrate(`${audioBitrate}k`);
+      command.audioFilters('volume=1');
+    }
+
+    return { command, output };
+  }
+
+  async _run(url, signal) {
+    await ensureFfmpegPath();
+
+    const { command, output } = this._buildFfmpeg(url);
+    this._command = command;
+
+    command.on('start', cmd => this.emit('debug', `[cmd] ${cmd}`));
+    command.on('stderr', line => this.emit('debug', String(line)));
+
+    command.on('error', (err, _stdout, stderr) => {
+      if (stderr) this.emit('debug', String(stderr));
+      if (signal.aborted) return;
+      const msg = err?.message || String(err);
+      this.emit('error', new Error(stderr ? `${msg}\n${stderr}` : msg));
+    });
+
+    signal.addEventListener('abort', () => command.kill('SIGTERM'), { once: true });
+    command.run();
+
+    const { livestream } = this.options;
+    const playOptions = { type: 'go-live' };
+    if (livestream) playOptions.readrateInitialBurst = 10;
+
+    this._playPromise = playStream(output, this.streamer, playOptions, signal);
+
+    this._playPromise
+      .then(() => this.emit('finish'))
+      .catch(err => {
+        if (signal.aborted || err?.name === 'AbortError') return;
+        this.emit('error', err);
+      });
+
+    return this._playPromise;
+  }
+
+  async start() {
+    const { guildId, channelId, url } = this.options;
+    await ensureFfmpegPath();
+    await this.streamer.joinVoice(guildId, channelId);
+
+    if (this.client.user?.voice?.channel instanceof StageChannel) {
+      await this.client.user.voice.setSuppressed(false);
+    }
+
+    this._started = true;
+    void this._run(url, this._abort.signal);
+  }
+
+  stop() {
+    this._abort.abort();
+  }
+
+  async replay() {
+    this.stop();
+    this._abort = new AbortController();
+    await this._run(this.options.url, this._abort.signal);
+  }
+
+  disconnect() {
+    this.stop();
+    if (this._started) this.streamer.leaveVoice();
+    this._started = false;
+  }
+}
+
+module.exports = WebRtcStreamSession;

package/src/client/voice/networking/VoiceWebSocket.js

@@ -138,13 +138,15 @@ class VoiceWebSocket extends EventEmitter {
     this._identified = true;
 
     const isStream = this.connection.constructor.name === 'StreamConnection';
+    const sessionId = this.connection.authentication.sessionId;
+    const maxDave = getMaxProtocolVersion();
     const data = {
       server_id: this.connection.serverId || this.connection.channel.guild?.id || this.connection.channel.id,
       user_id: this.client.user.id,
       token: this.connection.authentication.token,
-      session_id: this.connection.authentication.sessionId,
-      max_dave_protocol_version: getMaxProtocolVersion(),
+      session_id: sessionId,
     };
+    if (maxDave > 0) data.max_dave_protocol_version = maxDave;
 
     if (isStream) {
       data.channel_id = this.connection.channel.id;
@@ -253,60 +255,14 @@ class VoiceWebSocket extends EventEmitter {
       return;
     }
     if (event.code === 4006) {
-      const isStream = this.connection.constructor.name === 'StreamConnection';
-      this.connection._sessionRetries ??= 0;
-      if (this.connection._sessionRetries < 3) {
-        this.connection._sessionRetries++;
-        this._identified = false;
-        this.reset();
-        this.connection.authentication = {};
-        this.connection.status = VoiceStatus.AUTHENTICATING;
-        if (isStream) {
-          this.connection.serverId = null;
-          if (this.connection.sockets.ws) {
-            this.connection.sockets.ws.shutdown();
-            this.connection.sockets.ws = null;
-          }
-          if (this.connection.sockets.udp) {
-            this.connection.sockets.udp.shutdown();
-            this.connection.sockets.udp = null;
-          }
-          if (this.connection.voiceConnection) {
-            this.connection.voiceConnection.streamConnection = this.connection;
-          }
-          clearTimeout(this.connection.connectTimeout);
-          this.connection.connectTimeout = setTimeout(
-            () => this.connection.authenticateFailed('VOICE_CONNECTION_TIMEOUT'),
-            30_000,
-          ).unref();
-          this.connection.channel.client.ws.broadcast({
-            op: Opcodes.STREAM_DELETE,
-            d: { stream_key: this.connection.streamKey },
-          });
-          setTimeout(() => {
-            this.connection.sendSignalScreenshare();
-          }, 1500).unref();
-        } else {
-          if (this.connection.sockets.ws) {
-            this.connection.sockets.ws.shutdown();
-            this.connection.sockets.ws = null;
-          }
-          if (this.connection.sockets.udp) {
-            this.connection.sockets.udp.shutdown();
-            this.connection.sockets.udp = null;
-          }
-          this.connection.status = VoiceStatus.RECONNECTING;
-          setTimeout(() => {
-            if (this.connection.authentication.token && this.connection.authentication.endpoint) {
-              this.connection.connect();
-            } else {
-              this.connection.sendVoiceStateUpdate();
-            }
-          }, 500).unref();
-        }
-        return;
-      }
       this.dead = true;
+      const guildId = this.connection.channel.guild?.id;
+      if (guildId) {
+        this.connection.channel.client.ws.broadcast({
+          op: Opcodes.VOICE_STATE_UPDATE,
+          d: { guild_id: guildId, channel_id: null, self_mute: false, self_deaf: false },
+        });
+      }
       this.emit('error', new Error('VOICE_SESSION_EXPIRED'));
       return;
     }

package/src/errors/Messages.js

@@ -186,9 +186,11 @@ const Messages = {
   VOICE_USER_MISSING: "Couldn't resolve the user to create stream.",
   VOICE_JOIN_CHANNEL: (full = false) =>
     `You do not have permission to join this voice channel${full ? '; it is full.' : '.'}`,
-  VOICE_CONNECTION_TIMEOUT: 'Connection not established within 30 seconds.',
+  VOICE_CONNECTION_TIMEOUT:
+    'Connection not established within 30 seconds. Close the official Discord app (desktop/mobile) on this account, leave any voice channel, then retry.',
   VOICE_DAVE_REQUIRED: '%s',
-  VOICE_SESSION_EXPIRED: 'Voice session is no longer valid.',
+  VOICE_SESSION_EXPIRED:
+    'Voice session is no longer valid (4006). Quit any other Discord client on this account, leave voice channels, then retry.',
   VOICE_TOKEN_ABSENT: 'Token not provided from voice server packet.',
   VOICE_SESSION_ABSENT: 'Session ID not supplied.',
   VOICE_INVALID_ENDPOINT: 'Invalid endpoint received.',

package/typings/index.d.ts

@@ -1196,6 +1196,7 @@ export interface StartStreamOptions {
   url: string;
   fps?: number;
   height?: number;
+  width?: number;
   bitrate?: number;
   audioBitrate?: number;
   videoCodec?: 'H264' | 'VP8';
@@ -1203,6 +1204,12 @@ export interface StartStreamOptions {
   audio?: boolean;
   /** Enable webcam. Default false (screenshare only). */
   video?: boolean;
+  /** Download HTTP URLs locally before playback. Default true. */
+  downloadHttp?: boolean;
+  /** Max video bitrate in kbps. Default: bitrate * 1.5 */
+  bitrateMax?: number;
+  /** Low-latency encoding and playback. Default true. */
+  lowLatency?: boolean;
 }
 
 export class StreamSession extends EventEmitter {