djs-selfbot-v13 3.7.36 → 3.7.38

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "djs-selfbot-v13",
-  "version": "3.7.36",
+  "version": "3.7.38",
   "description": "An unofficial discord.js fork for creating selfbots",
   "main": "./src/index.js",
   "types": "./typings/index.d.ts",

package/src/client/Client.js

@@ -932,6 +932,11 @@ class Client extends BaseClient {
       audio,
       livestream = false,
       downloadHttp = true,
+      encoder,
+      hardwareAcceleratedDecoding,
+      nvencPreset,
+      preEncode,
+      goLive,
     } = options;
 
     if (!url) throw new Error('STREAM_URL_REQUIRED');
@@ -939,7 +944,7 @@ class Client extends BaseClient {
 
     let playUrl = url;
     if (typeof url === 'string' && url.startsWith('http') && downloadHttp) {
-      playUrl = await WebRtcStreamSession.resolveUrl(url);
+      playUrl = await StreamSession.resolveUrl(url);
     }
 
     const session = new WebRtcStreamSession(this, {
@@ -956,6 +961,11 @@ class Client extends BaseClient {
       tune,
       audio,
       livestream,
+      encoder,
+      hardwareAcceleratedDecoding,
+      nvencPreset,
+      preEncode,
+      goLive,
     });
 
     await session.start();

package/src/client/voice/ClientVoiceManager.js

@@ -164,6 +164,80 @@ class ClientVoiceManager {
     });
   }
 
+  /**
+   * Force quitter vocal + stream (session stale / erreur 4006).
+   * @param {import('../../structures/VoiceChannel') | import('../../structures/StageChannel')} channel
+   * @returns {Promise<void>}
+   */
+  resetVoiceSession(channel) {
+    return new Promise(resolve => {
+      if (this.connection) {
+        if (this.connection.streamConnection) {
+          this.connection.streamConnection.disconnect();
+          this.connection.streamConnection = null;
+        }
+        this.connection.disconnect();
+        this.connection = null;
+      }
+
+      const guild = channel.guild;
+      if (!guild) {
+        setTimeout(resolve, 1000).unref();
+        return;
+      }
+
+      const userId = this.client.user?.id;
+      const voiceState = guild.voiceStates.cache.get(userId);
+      const channelId = voiceState?.channelId ?? channel.id;
+      const streamKey = `guild:${guild.id}:${channelId}:${userId}`;
+
+      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,
+        },
+      });
+
+      this.client.emit('debug', '[VOICE] resetVoiceSession: vocal et stream réinitialisés');
+      setTimeout(resolve, 2500).unref();
+    });
+  }
+
+  /**
+   * @param {import('../../structures/VoiceChannel') | import('../../structures/StageChannel')} channel
+   * @param {object} [config]
+   * @param {number} [maxAttempts=3]
+   * @returns {Promise<VoiceConnection>}
+   */
+  async joinChannelWithRetry(channel, config = {}, maxAttempts = 3) {
+    let lastError;
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+      try {
+        if (attempt > 1) {
+          console.log(`[stream] reconnexion vocale (${attempt}/${maxAttempts})…`);
+          await this.resetVoiceSession(channel);
+        }
+        return await this.joinChannel(channel, config);
+      } catch (err) {
+        lastError = err;
+        const expired =
+          err?.code === 'VOICE_SESSION_EXPIRED' ||
+          String(err?.message ?? '').includes('4006') ||
+          String(err?.message ?? '').includes('VOICE_SESSION_EXPIRED');
+        if (!expired || attempt === maxAttempts) throw err;
+        await this.resetVoiceSession(channel);
+      }
+    }
+    throw lastError;
+  }
+
   /**
    * Sets up a request to join a voice channel.
    * @param {VoiceChannel | StageChannel | DMChannel | GroupDMChannel | Snowflake} channel The voice channel to join

package/src/client/voice/StreamSession.js

@@ -4,6 +4,7 @@ const fs = require('node:fs');
 const os = require('node:os');
 const path = require('node:path');
 const { EventEmitter } = require('events');
+const StageChannel = require('../../structures/StageChannel');
 
 /**
  * Active screenshare session returned by {@link Client#startStream}.
@@ -53,16 +54,27 @@ class StreamSession extends EventEmitter {
     return Math.max(0, this.videoDispatcher.totalStreamTime - this.videoDispatcher.pausedTime);
   }
 
+  /**
+   * Starts playback on the stream connection.
+   */
+  start() {
+    if (this.client.user?.voice?.channel instanceof StageChannel) {
+      void this.client.user.voice.setSuppressed(false);
+    }
+    return this._play();
+  }
+
   _play(seek = 0) {
     const { url, fps, height, width, bitrate, audioBitrate } = this.options;
+    const streamFps = fps ?? 30;
     const streamHeight = height ?? 720;
     this.streamConnection.videoAttributes = {
       width: width ?? Math.round((streamHeight * 16) / 9),
       height: streamHeight,
-      fps: fps ?? 30,
+      fps: streamFps,
     };
     const videoOptions = {
-      fps,
+      fps: streamFps,
       bitrate,
       seek,
       presetH26x: this.options.preset || 'ultrafast',
@@ -70,9 +82,9 @@ class StreamSession extends EventEmitter {
         '-pix_fmt',
         'yuv420p',
         '-g',
-        String(fps),
+        String(streamFps),
         '-keyint_min',
-        String(fps),
+        String(streamFps),
         '-sc_threshold',
         '0',
         '-force_key_frames',
@@ -90,6 +102,8 @@ class StreamSession extends EventEmitter {
       videoOptions.inputFFmpegArgs = ['-reconnect', '1', '-reconnect_at_eof', '1', '-reconnect_streamed', '1'];
     }
 
+    console.log(`[stream] lecture ${width ?? '?'}x${streamHeight} @ ${streamFps}fps (UDP)`);
+
     this.videoDispatcher = this.streamConnection.playVideo(url, videoOptions);
 
     if (this.options.audio !== false) {
@@ -190,4 +204,9 @@ module.exports = StreamSession;
  * @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)
+ * @property {'auto' | 'amf' | 'nvenc' | 'qsv' | 'software'} [encoder='auto'] Video encoder
+ * @property {boolean} [hardwareAcceleratedDecoding=true] Use GPU decoding (-hwaccel auto)
+ * @property {string} [nvencPreset='p1'] NVENC preset (p1 = lowest latency)
+ * @property {boolean} [preEncode=true] Pré-encode en local avant lecture (fluidité)
+ * @property {boolean} [goLive=false] WebRTC Go Live (sinon UDP classique, plus stable)
  */

package/src/client/voice/WebRtcStreamSession.js

@@ -1,9 +1,17 @@
 'use strict';
 
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
 const { EventEmitter } = require('events');
-const { PassThrough } = require('stream');
+const { spawn } = require('child_process');
 const ffmpeg = require('fluent-ffmpeg');
-const { Streamer, playStream } = require('@dank074/discord-video-stream');
+const {
+  Streamer,
+  prepareStream,
+  playStream,
+  Encoders,
+} = require('@dank074/discord-video-stream');
 const StreamSession = require('./StreamSession');
 const StageChannel = require('../../structures/StageChannel');
 
@@ -11,31 +19,55 @@ if (typeof globalThis.WebSocket === 'undefined') {
   globalThis.WebSocket = require('ws');
 }
 
-let _ffmpegPathReady = null;
+const sleep = ms => new Promise(resolve => setTimeout(resolve, ms));
 
-/** 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;
+/** @type {'amf' | 'nvenc' | 'software' | null} */
+let _cachedEncoder = null;
+
+function detectHwEncoder() {
+  if (_cachedEncoder) return Promise.resolve(_cachedEncoder);
+  return new Promise(resolve => {
+    ffmpeg.getAvailableEncoders((err, encoders) => {
+      if (err || !encoders) {
+        _cachedEncoder = 'software';
+        resolve('software');
+        return;
+      }
+      if (encoders.h264_amf) {
+        _cachedEncoder = 'amf';
+        resolve('amf');
+        return;
       }
-      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;
+      if (encoders.h264_nvenc) {
+        const proc = spawn('ffmpeg', [
+          '-hide_banner', '-loglevel', 'error',
+          '-f', 'lavfi', '-i', 'color=c=black:s=64x64:d=0.04',
+          '-c:v', 'h264_nvenc', '-f', 'null', '-',
+        ]);
+        proc.on('close', code => {
+          if (code === 0) {
+            _cachedEncoder = 'nvenc';
+            resolve('nvenc');
+          } else {
+            _cachedEncoder = 'software';
+            resolve('software');
+          }
+        });
+        proc.on('error', () => {
+          _cachedEncoder = 'software';
+          resolve('software');
+        });
+        return;
+      }
+      _cachedEncoder = 'software';
+      resolve('software');
     });
-  return _ffmpegPathReady;
+  });
 }
 
 /**
- * Go Live via WebRTC — ffmpeg custom (sans azmq) + playStream de la librairie.
+ * Go Live WebRTC — même approche que discord-livestream-selfbot :
+ * Streamer.joinVoice + prepareStream + playStream
  * @extends {EventEmitter}
  */
 class WebRtcStreamSession extends EventEmitter {
@@ -51,152 +83,192 @@ class WebRtcStreamSession extends EventEmitter {
     this.options = options;
     this.streamer = new Streamer(client);
     this._abort = new AbortController();
+    this._ffmpegCommand = null;
     this._playPromise = null;
-    this._command = null;
-    this._ffmpegProc = null;
     this._started = false;
     this._running = false;
     this._paused = false;
     this._stopped = false;
     this._positionMs = 0;
     this._runStartWall = 0;
-    this._pausedAt = 0;
-    this._pausedTotalMs = 0;
   }
 
   _getPositionMs() {
     if (!this._running) return this._positionMs;
-    if (this._paused) return this._positionMs;
-    return this._positionMs + (Date.now() - this._runStartWall - this._pausedTotalMs);
+    return this._positionMs + (Date.now() - this._runStartWall);
   }
 
-  _resetRunClock() {
-    this._runStartWall = Date.now();
-    this._pausedAt = 0;
-    this._pausedTotalMs = 0;
-  }
-
-  _signalFfmpeg(signal) {
-    const pid = this._ffmpegProc?.pid;
-    if (!pid) return;
-    try {
-      process.kill(pid, signal);
-    } catch {
-      // process already exited
+  async _pickEncoder() {
+    const { preset = 'ultrafast', encoder = 'auto' } = this.options;
+    let mode = encoder;
+    if (encoder === 'auto') mode = await detectHwEncoder();
+
+    if (mode === 'nvenc') {
+      console.log('[stream] encodeur: h264_nvenc (p1 ll)');
+      const llOpts = [
+        '-preset', 'p1',
+        '-tune', 'll',
+        '-delay', '0',
+        '-rc-lookahead', '0',
+        '-no-scenecut', '1',
+        '-zerolatency', '1',
+      ];
+      return () => ({
+        H264: { name: 'h264_nvenc', options: llOpts },
+        H265: { name: 'hevc_nvenc', options: llOpts },
+        AV1: { name: 'av1_nvenc', options: llOpts },
+      });
     }
+    if (mode === 'amf') {
+      console.log('[stream] encodeur: h264_amf (ultra low latency)');
+      return () => ({
+        H264: {
+          name: 'h264_amf',
+          options: ['-usage', 'ultralowlatency', '-quality', 'speed', '-preanalysis', 'false'],
+        },
+        H265: {
+          name: 'hevc_amf',
+          options: ['-usage', 'ultralowlatency', '-quality', 'speed', '-preanalysis', 'false'],
+        },
+      });
+    }
+    console.log('[stream] encodeur: libx264');
+    return Encoders.software({
+      x264: { preset, tune: 'zerolatency' },
+    });
   }
 
-  /**
-   * Construit la commande ffmpeg : transcode en H264 + Opus, sortie nut.
-   * Pas de filtre azmq (compatibilité ffmpeg sans libzmq).
-   */
-  _buildFfmpeg(url, seekSec = 0) {
+  async _buildPrepareOptions(seekSec = 0) {
     const {
-      fps,
-      height = 720,
-      width = -2,
-      bitrate = 5000,
+      fps = 60,
+      height,
+      width,
+      bitrate = 4500,
       bitrateMax,
       audioBitrate = 128,
-      preset = 'superfast',
-      tune = 'film',
+      hardwareAcceleratedDecoding = true,
       audio,
+      noTranscoding = false,
     } = this.options;
 
-    const maxRate = bitrateMax ?? Math.round(bitrate * 1.5);
-    const includeAudio = audio !== false;
-    const output = new PassThrough();
-    const command = ffmpeg(url);
-
-    if (seekSec > 0) command.seekInput(seekSec);
-
-    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',
-      ]);
+    if (noTranscoding) {
+      console.log('[stream] mode copie vidéo (pas de ré-encodage)');
+      return {
+        noTranscoding: true,
+        bitrateAudio: audioBitrate,
+        includeAudio: audio !== false,
+        hardwareAcceleratedDecoding: false,
+        minimizeLatency: true,
+        customInputOptions: seekSec > 0 ? [`-ss ${String(seekSec)}`] : [],
+        customFfmpegFlags: [],
+      };
+    }
+
+    const gop = String(fps * 2);
+    const is720 = Number(height) >= 720;
+    const videoBufK = Math.max(Math.round(bitrate * 1.25), is720 ? 3500 : 1200);
+
+    return {
+      encoder: await this._pickEncoder(),
+      height,
+      width: width || (is720 ? 1280 : Math.round((height * 16) / 9 / 2) * 2),
+      frameRate: fps,
+      bitrateVideo: bitrate,
+      bitrateVideoMax: bitrateMax ?? Math.round(bitrate * 1.3),
+      bitrateAudio: audioBitrate,
+      includeAudio: audio !== false,
+      hardwareAcceleratedDecoding,
+      minimizeLatency: !is720,
+      customInputOptions: seekSec > 0 ? [`-ss ${String(seekSec)}`] : [],
+      customFfmpegFlags: [
+        '-g', gop,
+        '-keyint_min', gop,
+        '-sc_threshold', '0',
+        '-threads', '0',
+        '-bufsize:v', `${videoBufK}k`,
+        '-maxrate:v', `${bitrateMax ?? Math.round(bitrate * 1.3)}k`,
+        '-force_key_frames', 'expr:gte(t,n_forced*2)',
+        '-max_muxing_queue_size', '1024',
+        '-flush_packets', '1',
+      ],
+    };
+  }
+
+  async _disconnectLegacyVoice() {
+    const conn = this.client.voice?.connection;
+    if (conn) {
+      conn.disconnect();
+      this.client.voice.connection = null;
+      await sleep(800);
+    }
+  }
+
+  async _joinVoice() {
+    const { guildId, channelId } = this.options;
+
+    if (this.streamer.voiceConnection) {
+      this.streamer.leaveVoice();
+      await sleep(1000);
     }
 
-    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');
+    await this._disconnectLegacyVoice();
+
+    const vc = this.streamer.voiceConnection;
+    if (
+      !vc ||
+      vc.guildId !== guildId ||
+      vc.channelId !== channelId
+    ) {
+      await this.streamer.joinVoice(guildId, channelId);
     }
 
-    return { command, output };
+    if (this.client.user?.voice?.channel instanceof StageChannel) {
+      await this.client.user.voice.setSuppressed(false);
+    }
   }
 
   async _run(url, signal, seekSec = 0) {
-    await ensureFfmpegPath();
+    const prepareOpts = await this._buildPrepareOptions(seekSec);
+    const { command, output } = prepareStream(url, prepareOpts, signal);
+    this._ffmpegCommand = command;
 
-    const { command, output } = this._buildFfmpeg(url, seekSec);
-    this._command = command;
-    this._ffmpegProc = null;
-    this._running = true;
-    this._paused = false;
-    this._stopped = false;
-    this._resetRunClock();
-
-    command.on('start', cmd => {
-      this._ffmpegProc = command.ffmpegProc ?? null;
-      this.emit('debug', `[cmd] ${cmd}`);
-    });
+    command.on('start', cmd => this.emit('debug', `[ffmpeg] ${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));
+      this.emit('error', new Error(stderr ? `${err.message}\n${stderr}` : err.message));
     });
 
-    const onAbort = () => {
-      this._running = false;
-      this._ffmpegProc = null;
-      command.kill('SIGTERM');
-    };
-    signal.addEventListener('abort', onAbort, { once: true });
-    command.run();
+    this._running = true;
+    this._paused = false;
+    this._stopped = false;
+    this._runStartWall = Date.now();
 
-    const { livestream } = this.options;
-    const playOptions = { type: 'go-live' };
-    if (livestream) playOptions.readrateInitialBurst = 10;
+    let playOptions;
+    if (this.options.noTranscoding) {
+      console.log('[stream] envoi à la résolution/fps natifs de la source (WebRTC)');
+      playOptions = {};
+    } else {
+      const { height = 720, width: optWidth, fps = 60, bitrate } = this.options;
+      const width = optWidth || (height >= 720 ? 1280 : Math.round((height * 16) / 9 / 2) * 2);
+      console.log(
+        `[stream] envoi ${width}x${height} @ ${fps}fps, ${bitrate ?? '?'}kbps (WebRTC)`,
+      );
+      playOptions = {
+        width,
+        height,
+        frameRate: fps,
+        readrateInitialBurst: 1,
+      };
+    }
+    this.emit('playing');
 
     this._playPromise = playStream(output, this.streamer, playOptions, signal);
 
     this._playPromise
       .then(() => {
         this._running = false;
-        this._ffmpegProc = null;
+        this._ffmpegCommand = null;
         if (!signal.aborted) {
           this._positionMs = 0;
           this.emit('finish');
@@ -204,7 +276,7 @@ class WebRtcStreamSession extends EventEmitter {
       })
       .catch(err => {
         this._running = false;
-        this._ffmpegProc = null;
+        this._ffmpegCommand = null;
         if (signal.aborted || err?.name === 'AbortError') return;
         this.emit('error', err);
       });
@@ -213,66 +285,62 @@ class WebRtcStreamSession extends EventEmitter {
   }
 
   async start() {
-    const { guildId, channelId, url } = this.options;
-    await ensureFfmpegPath();
-    await this.streamer.joinVoice(guildId, channelId);
+    const { url } = this.options;
+    await this._joinVoice();
+    this._started = true;
 
-    if (this.client.user?.voice?.channel instanceof StageChannel) {
-      await this.client.user.voice.setSuppressed(false);
-    }
+    const playing = new Promise((resolve, reject) => {
+      this.once('playing', resolve);
+      this.once('error', reject);
+    });
 
-    this._started = true;
-    void this._run(url, this._abort.signal);
+    void this._run(url, this._abort.signal).catch(err => this.emit('error', err));
+    await playing;
   }
 
-  /**
-   * Met en pause la lecture (ffmpeg suspendu, connexion vocale conservée).
-   */
   pause() {
     if (!this._running || this._paused || this._stopped) return;
     this._positionMs = this._getPositionMs();
-    this._pausedAt = Date.now();
-    this._signalFfmpeg('SIGSTOP');
     this._paused = true;
+    this._running = false;
+    this._ffmpegCommand?.kill?.('SIGTERM');
+    this._ffmpegCommand = null;
+    this.streamer.stopStream();
+    this._abort.abort();
+    this._abort = new AbortController();
+    console.log(`[stream] pause à ${(this._positionMs / 1000).toFixed(1)}s`);
   }
 
-  /**
-   * Reprend la lecture (après pause ou stop).
-   */
   async resume() {
     if (this._stopped) {
-      const seekSec = this._positionMs / 1000;
       this._stopped = false;
-      await this._run(this.options.url, this._abort.signal, seekSec);
+      await this._run(this.options.url, this._abort.signal, this._positionMs / 1000);
       return;
     }
-    if (!this._running || !this._paused) return;
-    this._pausedTotalMs += Date.now() - this._pausedAt;
-    this._pausedAt = 0;
-    this._signalFfmpeg('SIGCONT');
+    if (!this._paused) return;
     this._paused = false;
+    const seekSec = this._positionMs / 1000;
+    console.log(`[stream] reprise à ${seekSec.toFixed(1)}s`);
+    await this._run(this.options.url, this._abort.signal, seekSec);
   }
 
-  /**
-   * Arrête la lecture en conservant la position et la connexion vocale.
-   */
   stop() {
-    if (!this._running) return;
+    if (!this._running && !this._paused) return;
     this._positionMs = this._getPositionMs();
     this._stopped = true;
     this._paused = false;
     this._running = false;
-    this._ffmpegProc = null;
+    this._ffmpegCommand?.kill?.('SIGTERM');
+    this._ffmpegCommand = null;
+    this.streamer.stopStream();
     this._abort.abort();
     this._abort = new AbortController();
+    console.log(`[stream] stop à ${(this._positionMs / 1000).toFixed(1)}s`);
   }
 
-  /**
-   * Relance depuis la dernière position enregistrée.
-   */
   async replay() {
     const seekSec = (this._running ? this._getPositionMs() : this._positionMs) / 1000;
-    if (this._running) this.stop();
+    if (this._running || this._paused) this.stop();
     this._stopped = false;
     await this._run(this.options.url, this._abort.signal, seekSec);
   }

package/typings/index.d.ts

@@ -1215,6 +1215,16 @@ export interface StartStreamOptions {
   livestream?: boolean;
   /** Low-latency encoding and playback. Default true. */
   lowLatency?: boolean;
+  /** Video encoder. Default 'auto' (NVENC if available). */
+  encoder?: 'auto' | 'amf' | 'nvenc' | 'qsv' | 'software';
+  /** GPU decoding via -hwaccel auto. Default true. */
+  hardwareAcceleratedDecoding?: boolean;
+  /** NVENC preset (p1 = lowest latency). Default 'p1'. */
+  nvencPreset?: string;
+  /** Pre-encode locally before playback for smooth speed. Default true. */
+  preEncode?: boolean;
+  /** WebRTC Go Live. Default false (UDP classic, more stable). */
+  goLive?: boolean;
 }
 
 /** Session Go Live WebRTC retournée par {@link Client#startStream}. */