rockcord 4.0.0-dev.4 → 4.0.0

package/src/client/voice/receiver/Recorder.js

@@ -4,6 +4,11 @@ const { spawn } = require('child_process');
 const { createSocket } = require('dgram');
 const { EventEmitter } = require('events');
 const { Buffer } = require('node:buffer');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const process = require('node:process');
+const { setTimeout } = require('node:timers');
 const { Writable } = require('stream');
 const kill = require('tree-kill');
 const { RtpPacket } = require('werift-rtp');
@@ -16,9 +21,12 @@ const { StreamOutput } = require('../util/Socket');
  * @extends {EventEmitter}
  */
 class Recorder extends EventEmitter {
-  constructor(receiver, { userId, portUdpH264, portUdpOpus, output } = {}) {
+  constructor(receiver, { userId, codec = 'H264', portUdpVideo, portUdpH264, portUdpOpus, output } = {}) {
     super();
 
+    if (!['H264', 'H265', 'VP8'].includes(codec)) throw new RangeError('Unsupported recording codec');
+    this.codec = codec;
+
     Object.defineProperty(this, 'receiver', { value: receiver });
 
     /**
@@ -27,16 +35,15 @@ class Recorder extends EventEmitter {
      */
     this.userId = userId;
 
-    this.portUdpH264 = portUdpH264 || null;
-    this.portUdpH265 = null;
+    this.portUdpVideo = (portUdpVideo ?? portUdpH264) || null;
     this.portUdpOpus = portUdpOpus || null;
 
     this.promise = null;
 
-    if (!portUdpH264 || !portUdpOpus) {
+    if (!this.portUdpVideo || !portUdpOpus) {
       this.promise = (async () => {
-        const selected = new Set([this.portUdpH264, this.portUdpOpus].filter(Boolean));
-        const missing = Number(!this.portUdpH264) + Number(!this.portUdpOpus);
+        const selected = new Set([this.portUdpVideo, this.portUdpOpus].filter(Boolean));
+        const missing = Number(!this.portUdpVideo) + Number(!this.portUdpOpus);
         const ports = [];
         for (let attempt = 0; ports.length < missing && attempt < 64; attempt++) {
           const port = await randomPort('udp4');
@@ -46,7 +53,7 @@ class Recorder extends EventEmitter {
           }
         }
         if (ports.length < missing) throw new Error('Could not allocate recording ports');
-        this.portUdpH264 ??= ports.shift();
+        this.portUdpVideo ??= ports.shift();
         this.portUdpOpus ??= ports.shift();
       })();
     }
@@ -63,6 +70,8 @@ class Recorder extends EventEmitter {
      */
     this.ready = false;
     this.destroyed = false;
+    this.closed = false;
+    this.completion = new Promise(resolve => (this._resolveCompletion = resolve));
 
     this.socket = createSocket('udp4');
 
@@ -71,6 +80,7 @@ class Recorder extends EventEmitter {
   }
 
   fail(error) {
+    this._error = error;
     if (this.listenerCount('error')) this.emit('error', error);
     else this.emit('debug', error.message);
     this.destroy();
@@ -78,47 +88,75 @@ class Recorder extends EventEmitter {
   async init(output) {
     await this.promise;
     if (this.destroyed) return;
-    const sdpData = Util.getSDPCodecName(this.portUdpH264, this.portUdpH265, this.portUdpOpus);
+    // Keep stdin available for FFmpeg's graceful quit command. Reading SDP from
+    // stdin and closing it leaves no way to write the Matroska trailer on Windows.
+    this.portUdpH264 = this.codec === 'H264' ? this.portUdpVideo : null;
+    this.portUdpH265 = this.codec === 'H265' ? this.portUdpVideo : null;
+    this.portUdpVP8 = this.codec === 'VP8' ? this.portUdpVideo : null;
+    const videoType = Util.getPayloadType(this.codec);
+    const opusType = Util.getPayloadType('opus');
+    const sdpData = [
+      'v=0',
+      'o=- 0 0 IN IP4 127.0.0.1',
+      's=Rockcord recording',
+      'c=IN IP4 127.0.0.1',
+      't=0 0',
+      `m=video ${this.portUdpVideo} RTP/AVP ${videoType}`,
+      `a=rtpmap:${videoType} ${this.codec}/90000`,
+      ...(this.codec === 'H264' ? [`a=fmtp:${videoType} packetization-mode=1`] : []),
+      `m=audio ${this.portUdpOpus} RTP/AVP ${opusType}`,
+      `a=rtpmap:${opusType} opus/48000/2`,
+      `a=fmtp:${opusType} minptime=10;useinbandfec=1`,
+      '',
+    ].join('\r\n');
+    this._directory = fs.mkdtempSync(path.join(os.tmpdir(), 'rockcord-recorder-'));
+    this._sdpPath = path.join(this._directory, 'input.sdp');
+    fs.writeFileSync(this._sdpPath, sdpData);
     const isStream = output instanceof Writable;
     if (isStream) {
       this.outputStream = StreamOutput(output);
     }
-    const stream = spawn('ffmpeg', [
-      '-reorder_queue_size',
-      '500',
-      '-thread_queue_size',
-      '500',
-      '-err_detect',
-      'ignore_err',
-      '-flags2',
-      '+export_mvs',
-      '-fflags',
-      '+genpts+discardcorrupt',
-      '-use_wallclock_as_timestamps',
-      '1',
-      '-f',
-      'sdp',
-      '-analyzeduration',
-      '1M',
-      '-probesize',
-      '1M',
-      '-protocol_whitelist',
-      'file,udp,rtp,pipe,fd',
-      '-i',
-      '-', // Read from stdin
-      '-buffer_size',
-      '4M',
-      '-max_delay',
-      '500000', // 500ms
-      '-rtbufsize',
-      '4M',
-      '-c',
-      'copy',
-      '-y',
-      '-f',
-      'matroska',
-      isStream ? this.outputStream.url : output,
-    ]);
+    const stream = spawn(
+      process.env.FFMPEG_PATH || 'ffmpeg',
+      [
+        '-hide_banner',
+        '-reorder_queue_size',
+        '0',
+        '-thread_queue_size',
+        '500',
+        '-err_detect',
+        'ignore_err',
+        '-flags2',
+        '+export_mvs',
+        '-fflags',
+        '+genpts+discardcorrupt',
+        '-f',
+        'sdp',
+        '-analyzeduration',
+        '5000000',
+        '-probesize',
+        '1M',
+        '-listen_timeout',
+        '0',
+        '-protocol_whitelist',
+        'file,udp,rtp,pipe,fd',
+        '-i',
+        this._sdpPath,
+        '-buffer_size',
+        '4M',
+        '-max_delay',
+        '0',
+        '-rtbufsize',
+        '4M',
+        '-c',
+        'copy',
+        '-y',
+        '-f',
+        'matroska',
+        isStream ? this.outputStream.url : output,
+      ],
+      { windowsHide: true },
+    );
 
     /**
      * The FFmpeg process
@@ -127,15 +165,44 @@ class Recorder extends EventEmitter {
     this.stream = stream;
     stream.on('error', error => this.fail(error));
     stream.stdin.on('error', error => this.fail(error));
-    stream.once('exit', () => this.destroy());
-    this.stream.stdin.write(sdpData);
-    this.stream.stdin.end();
-    this.stream.stderr.once('data', data => {
+    stream.once('close', code => {
+      this.exitCode = code;
+      if (code && !this._error) this._error = new Error(`FFmpeg recording exited with code ${code}`);
+      this.destroy();
+      this._finalize();
+    });
+    this.stream.stdout?.resume();
+    stream.once('spawn', () => this._waitForPorts().catch(error => this.fail(error)));
+    this.stream.stderr.on('data', data => {
       this.emit('debug', `stderr: ${data}`);
-      this.ready = true;
-      this.emit('ready');
     });
   }
+
+  async _waitForPorts() {
+    const bound = port =>
+      new Promise(resolve => {
+        const probe = createSocket('udp4');
+        probe.once('error', error => {
+          try {
+            probe.close();
+          } catch {
+            /* An unsuccessful bind may close the probe. */
+          }
+          resolve(error.code === 'EADDRINUSE');
+        });
+        probe.bind(port, '127.0.0.1', () => probe.close(() => resolve(false)));
+      });
+    for (let attempt = 0; attempt < 120 && !this.destroyed; attempt++) {
+      const ports = await Promise.all([bound(this.portUdpVideo), bound(this.portUdpOpus)]);
+      if (ports.every(Boolean)) {
+        this.ready = true;
+        this.emit('ready', this);
+        return;
+      }
+      await new Promise(resolve => setTimeout(resolve, 25));
+    }
+    if (!this.destroyed) throw new Error('FFmpeg did not open the recording RTP ports');
+  }
   /**
    * Send a payload to FFmpeg via UDP
    * @param {RtpPacket|string|Buffer} payload The payload
@@ -156,15 +223,28 @@ class Recorder extends EventEmitter {
     const message = payload.serialize();
     // Get port from payloadType
     let port;
+    let kind;
     if (payload.header.payloadType === Util.getPayloadType('opus')) {
+      kind = 'audio';
       port = this.portUdpOpus;
-    } else if (payload.header.payloadType === Util.getPayloadType('H264')) {
-      port = this.portUdpH264;
-    } else if (payload.header.payloadType === Util.getPayloadType('H265')) {
-      port = this.portUdpH265;
+      this._lastAudioHeader = payload.header;
+    } else if (payload.header.payloadType === Util.getPayloadType(this.codec)) {
+      kind = 'video';
+      port = this.portUdpVideo;
+      this._lastVideoHeader = payload.header;
     } else {
       return;
     }
+    // FFmpeg's RTP probation starts at sequence zero. Normalize each new local
+    // source to one so the first keyframe's leading fragment is not discarded.
+    // Keep subsequent gaps and wrap intact, and never mutate the caller's packet.
+    const sourceKey = `_${kind}SequenceSource`;
+    const offsetKey = `_${kind}SequenceOffset`;
+    if (this[sourceKey] !== payload.header.ssrc) {
+      this[sourceKey] = payload.header.ssrc;
+      this[offsetKey] = 1 - payload.header.sequenceNumber;
+    }
+    message.writeUInt16BE((payload.header.sequenceNumber + this[offsetKey]) & 65535, 2);
     this.socket.send(message, 0, message.length, port, '127.0.0.1', callback);
   }
 
@@ -172,15 +252,64 @@ class Recorder extends EventEmitter {
     if (this.destroyed) return;
     this.destroyed = true;
     this.ready = false;
+    if (this.receiver?.videoStreams?.get(this.userId) === this) this.receiver.videoStreams.delete(this.userId);
+    if (this.stream?.pid && this.stream.exitCode === null && !this._error) {
+      // RTCP BYE ends both local RTP inputs. Unlike an immediate quit, EOF lets
+      // FFmpeg drain its parser and muxer, preserving the final buffered frame.
+      for (const [port, ssrc] of [
+        [this.portUdpVideo, this._lastVideoHeader?.ssrc ?? 1],
+        [this.portUdpOpus, this._lastAudioHeader?.ssrc ?? 2],
+      ]) {
+        // Include an empty, padded reason: FFmpeg's RTP demuxer requires at
+        // least 12 bytes even though a reason-less BYE may be eight bytes.
+        const bye = Buffer.from([0x81, 203, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0]);
+        bye.writeUInt32BE(ssrc, 4);
+        this.socket.send(bye, port + 1, '127.0.0.1', () => {});
+      }
+      this._quitTimer = setTimeout(() => this.stream.stdin.end('q\n'), 2000).unref();
+      this._killTimer = setTimeout(() => {
+        this._error = new Error('FFmpeg recording did not stop within 5 seconds');
+        kill(this.stream.pid, () => {});
+      }, 5000).unref();
+    } else if (this.stream?.pid && this.stream.exitCode === null) {
+      // Wait for close before removing the SDP: Windows keeps the input file
+      // locked until the failed child has actually exited.
+      kill(this.stream.pid, () => {});
+    } else {
+      this._finalize();
+    }
+  }
+
+  /**
+   * Stop receiving and wait for FFmpeg to finalize the recording.
+   * @returns {Promise<void>}
+   */
+  async stop() {
+    this.destroy();
+    await this.completion;
+    if (this._error) throw this._error;
+  }
+
+  _finalize() {
+    if (this.closed) return;
+    this.closed = true;
+    clearTimeout(this._killTimer);
+    clearTimeout(this._quitTimer);
     try {
       this.socket.close();
     } catch {
       /* Socket may not have bound yet. */
     }
     this.outputStream?.destroy();
-    if (this.stream?.pid) kill(this.stream.pid, () => {});
-    if (this.receiver?.videoStreams?.get(this.userId) === this) this.receiver.videoStreams.delete(this.userId);
-    this.emit('closed');
+    try {
+      if (this._sdpPath) fs.rmSync(this._sdpPath, { force: true });
+      if (this._directory) fs.rmdirSync(this._directory);
+    } catch (error) {
+      this._error ??= error;
+      this.emit('debug', `Recorder temporary-file cleanup failed: ${error.message}`);
+    }
+    this._resolveCompletion();
+    this.emit('closed', this);
   }
 
   /**

package/src/client/voice/util/PlayInterface.js

@@ -91,6 +91,8 @@ class PlayInterface {
    * Ex: ['-config1', 'value1', '-config2', 'value2']
    * @property {number|'auto'} [bitrate=2000] The bitrate (quality) of the video in kbps.
    * If set to 'auto', ffmpeg will automatically select
+   * @property {boolean|Object} [congestionControl=true] Enable loss-based AIMD video pacing.
+   * An object can set bitrate and minBitrate in kbps. Audio playback is unaffected.
    */
 
   /**

package/src/client/voice/util/Secretbox.js

@@ -56,7 +56,7 @@ async function importModule(name, usingImport = false) {
   for (const libName of Object.keys(libs)) {
     try {
       const lib = await importModule(libName);
-      if (libName === 'libsodium-wrappers' && lib.ready) await lib.ready; // eslint-disable-line no-await-in-loop
+      if (libName === 'libsodium-wrappers' && lib.ready) await lib.ready;
       exports.methods = libs[libName](lib);
       break;
     } catch {} // eslint-disable-line no-empty

package/src/client/voice/util/TransportCrypto.js

@@ -0,0 +1,54 @@
+'use strict';
+
+const { Buffer } = require('node:buffer');
+const crypto = require('node:crypto');
+const secretbox = require('./Secretbox');
+
+const states = new WeakMap();
+
+// RTP, RTX and RTCP all share a nonce space for a negotiated session key.
+function encrypt(connection, payload, header) {
+  const { secret_key: key, mode } = connection.authentication;
+  let state = states.get(connection);
+  if (!state || !state.key.equals(Buffer.from(key))) {
+    state = { key: Buffer.from(key), value: 0 };
+    states.set(connection, state);
+  }
+  if (state.value >= 0xffffffff) throw new RangeError('Voice encryption nonce exhausted; establish a new session key');
+  const nonce = Buffer.alloc(mode === 'aead_aes256_gcm_rtpsize' ? 12 : 24);
+  nonce.writeUInt32BE(++state.value);
+  let ciphertext;
+  if (mode === 'aead_aes256_gcm_rtpsize') {
+    const cipher = crypto.createCipheriv('aes-256-gcm', key, nonce);
+    cipher.setAAD(header);
+    ciphertext = Buffer.concat([cipher.update(payload), cipher.final(), cipher.getAuthTag()]);
+  } else if (mode === 'aead_xchacha20_poly1305_rtpsize') {
+    ciphertext = Buffer.from(secretbox.methods.crypto_aead_xchacha20poly1305_ietf_encrypt(payload, header, nonce, key));
+  } else {
+    throw new RangeError(`Unsupported encryption method: ${mode}`);
+  }
+  return [ciphertext, nonce.subarray(0, 4)];
+}
+
+function decrypt(connection, packet, headerSize) {
+  const { secret_key: key, mode } = connection.authentication;
+  if (!key || packet.length < headerSize + 20) throw new RangeError('Truncated encrypted media packet');
+  const header = packet.subarray(0, headerSize);
+  const nonce = Buffer.alloc(mode === 'aead_aes256_gcm_rtpsize' ? 12 : 24);
+  packet.copy(nonce, 0, packet.length - 4);
+  const ciphertext = packet.subarray(headerSize, packet.length - 4);
+  let plain;
+  if (mode === 'aead_aes256_gcm_rtpsize') {
+    const cipher = crypto.createDecipheriv('aes-256-gcm', key, nonce);
+    cipher.setAAD(header);
+    cipher.setAuthTag(ciphertext.subarray(-16));
+    plain = Buffer.concat([cipher.update(ciphertext.subarray(0, -16)), cipher.final()]);
+  } else if (mode === 'aead_xchacha20_poly1305_rtpsize') {
+    plain = Buffer.from(secretbox.methods.crypto_aead_xchacha20poly1305_ietf_decrypt(ciphertext, header, nonce, key));
+  } else {
+    throw new RangeError(`Unsupported decryption method: ${mode}`);
+  }
+  return Buffer.concat([header, plain]);
+}
+
+module.exports = { encrypt, decrypt };

package/src/client/voice/util/VideoFrames.js

@@ -132,7 +132,7 @@ class VideoFrames {
     this.completed = new Map();
   }
 
-  push(packet, codec) {
+  push(packet, codec, validate) {
     const { ssrc, timestamp, sequenceNumber: seq, marker } = packet.header;
     const now = Date.now();
     const key = `${ssrc}:${timestamp}:${codec}`;
@@ -169,6 +169,9 @@ class VideoFrames {
     }
     try {
       const complete = depacketize(payloads, codec);
+      // A marker and contiguous tail do not prove the beginning arrived. DAVE
+      // authentication must succeed before suppressing subsequent RTX fragments.
+      if (validate && !validate(complete)) return null;
       this.frames.delete(key);
       if (this.completed.size >= 128) this.completed.delete(this.completed.keys().next().value);
       this.completed.set(key, now);

package/src/client/websocket/WebSocketShard.js

@@ -605,7 +605,6 @@ class WebSocketShard extends EventEmitter {
       }
 
       this.debug(
-        // eslint-disable-next-line max-len
         `[WebSocket] Close Emitted: ${this.closeEmitted} | did not close properly, assuming a zombie connection.\nEmitting close and reconnecting again.`,
       );
 

package/src/managers/ApplicationCommandManager.js

@@ -55,12 +55,10 @@ class ApplicationCommandManager extends CachedManager {
    * @typedef {ApplicationCommand|Snowflake} ApplicationCommandResolvable
    */
 
-  /* eslint-disable max-len */
   /**
    * Data that resolves to the data of an ApplicationCommand
    * @typedef {ApplicationCommandData|APIApplicationCommand|SlashCommandBuilder|ContextMenuCommandBuilder} ApplicationCommandDataResolvable
    */
-  /* eslint-enable max-len */
 
   /**
    * Options used to fetch data from Discord

package/src/managers/ApplicationCommandPermissionsManager.js

@@ -410,7 +410,6 @@ class ApplicationCommandPermissionsManager extends BaseManager {
 
 module.exports = ApplicationCommandPermissionsManager;
 
-/* eslint-disable max-len */
 /**
  * @external APIApplicationCommandPermissions
  * @see {@link https://discord.com/developers/docs/interactions/application-commands#application-command-permissions-object-application-command-permissions-structure}

package/src/managers/GuildChannelManager.js

@@ -58,7 +58,7 @@ class GuildChannelManager extends CachedManager {
   get channelCountWithoutThreads() {
     return this.cache.reduce((acc, channel) => {
       if (ThreadChannelTypes.includes(channel.type)) return acc;
-      return ++acc;
+      return acc + 1;
     }, 0);
   }
 
@@ -155,7 +155,7 @@ class GuildChannelManager extends CachedManager {
   ) {
     parent &&= this.client.channels.resolveId(parent);
     permissionOverwrites &&= permissionOverwrites.map(o => PermissionOverwrites.resolve(o, this.guild));
-    const intType = typeof type === 'number' ? type : ChannelTypes[type] ?? ChannelTypes.GUILD_TEXT;
+    const intType = typeof type === 'number' ? type : (ChannelTypes[type] ?? ChannelTypes.GUILD_TEXT);
 
     const videoMode = typeof videoQualityMode === 'number' ? videoQualityMode : VideoQualityModes[videoQualityMode];
 
@@ -167,7 +167,6 @@ class GuildChannelManager extends CachedManager {
     if (intType === ChannelTypes.GUILD_STORE && !storeChannelDeprecationEmitted) {
       storeChannelDeprecationEmitted = true;
       process.emitWarning(
-        // eslint-disable-next-line max-len
         'Creating store channels is deprecated by Discord and will stop working in March 2022. Check the docs for more info.',
         'DeprecationWarning',
       );

package/src/managers/GuildMemberManager.js

@@ -1,4 +1,3 @@
-/* eslint-disable newline-per-chained-call */
 'use strict';
 
 const { Buffer } = require('node:buffer');

package/src/managers/GuildTextThreadManager.js

@@ -75,7 +75,7 @@ class GuildTextThreadManager extends ThreadManager {
       if (!startMessageId) throw new TypeError('INVALID_TYPE', 'startMessage', 'MessageResolvable');
       path = path.messages(startMessageId);
     } else if (this.channel.type !== 'GUILD_NEWS') {
-      resolvedType = typeof type === 'string' ? ChannelTypes[type] : type ?? resolvedType;
+      resolvedType = typeof type === 'string' ? ChannelTypes[type] : (type ?? resolvedType);
     }
 
     if (autoArchiveDuration === 'MAX') autoArchiveDuration = resolveAutoArchiveMaxLimit(this.channel.guild);

package/src/managers/MessageManager.js

@@ -139,16 +139,17 @@ class MessageManager extends CachedManager {
 
     const preserveAttachments =
       (options instanceof MessagePayload ? options.options : options)?.attachments === undefined;
-    const { data, files } = await (options instanceof MessagePayload
-      ? options
-      : MessagePayload.create(message instanceof Message ? message : this, options)
+    const { data, files } = await (
+      options instanceof MessagePayload
+        ? options
+        : MessagePayload.create(message instanceof Message ? message : this, options)
     )
       .resolveData()
       .resolveFiles();
 
     if (files.length && preserveAttachments) {
       const original =
-        message instanceof Message ? message : this.cache.get(messageId) ?? (await this.fetch(messageId));
+        message instanceof Message ? message : (this.cache.get(messageId) ?? (await this.fetch(messageId)));
       data.attachments = [...original.attachments.values()].map(attachment => ({ id: attachment.id }));
     }
     data.attachments = await Util.resolveUploadedAttachments(this.client, this.channel.id, files, data.attachments);
@@ -221,7 +222,6 @@ class MessageManager extends CachedManager {
       ? `${emoji.animated ? 'a:' : ''}${emoji.name}:${emoji.id}`
       : encodeURIComponent(emoji.name);
 
-    // eslint-disable-next-line newline-per-chained-call
     await this.client.api
       .channels(this.channel.id)
       .messages(message)

package/src/managers/RoleManager.js

@@ -72,7 +72,7 @@ class RoleManager extends CachedManager {
     const data = await this.client.api.guilds(this.guild.id).roles.get();
     const roles = new Collection();
     for (const role of data) roles.set(role.id, this._add(role, cache));
-    return id ? roles.get(id) ?? null : roles;
+    return id ? (roles.get(id) ?? null) : roles;
   }
 
   /**

package/src/rest/APIRequest.js

@@ -106,7 +106,6 @@ class APIRequest {
           body.append('payload_json', JSON.stringify(this.options.data));
         }
       }
-      // eslint-disable-next-line eqeqeq
     } else if (this.options.data != null) {
       if (this.options.usePayloadJSON) {
         body = new FormData();

package/src/rest/APIRouter.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const noop = () => {}; // eslint-disable-line no-empty-function
+const noop = () => {};
 const methods = ['get', 'post', 'delete', 'patch', 'put'];
 const reflectors = [
   'toString',
@@ -43,7 +43,7 @@ function buildRoute(manager) {
       return new Proxy(noop, handler);
     },
     apply(target, _, args) {
-      route.push(...args.filter(x => x != null)); // eslint-disable-line eqeqeq
+      route.push(...args.filter(x => x != null));
       return new Proxy(noop, handler);
     },
   };

package/src/rest/DiscordAPIError.js

@@ -11,7 +11,7 @@ class DiscordAPIError extends Error {
     super();
     const flattened = this.constructor.flattenErrors(error.errors ?? error).join('\n');
     this.name = 'DiscordAPIError';
-    this.message = error.message && flattened ? `${error.message}\n${flattened}` : error.message ?? flattened;
+    this.message = error.message && flattened ? `${error.message}\n${flattened}` : (error.message ?? flattened);
 
     /**
      * The HTTP method used for the request

package/src/rest/RequestHandler.js

@@ -154,7 +154,7 @@ class RequestHandler {
       }
 
       // Decide before allocating a delay: a rejected limit must not leave an unused promise/timer.
-      await this.onRateLimit(request, limit, timeout, isGlobal); // eslint-disable-line no-await-in-loop
+      await this.onRateLimit(request, limit, timeout, isGlobal);
 
       if (isGlobal) {
         // If this is the first task to reach the global timeout, set the global delay
@@ -168,7 +168,7 @@ class RequestHandler {
       }
 
       // Wait for the timeout to expire in order to avoid an actual 429
-      await delayPromise; // eslint-disable-line no-await-in-loop
+      await delayPromise;
     }
 
     // As the request goes out, update the global usage information
@@ -378,7 +378,7 @@ class RequestHandler {
     rqToken : [REDACTED]`,
           );
           const solved = await this.manager.client.options.captchaSolver(data, request.fullUserAgent);
-          const captcha = typeof solved === 'string' ? solved : solved?.token ?? solved?.data;
+          const captcha = typeof solved === 'string' ? solved : (solved?.token ?? solved?.data);
           if (typeof captcha !== 'string' || !captcha) throw new Error('Captcha solver must return a non-empty token');
           this.manager.client.emit(
             DEBUG,

package/src/sharding/ShardingManager.js

@@ -218,7 +218,7 @@ class ShardingManager extends EventEmitter {
       const shard = this.createShard(shardId);
       promises.push(shard.spawn(timeout));
       if (delay > 0 && this.shards.size !== this.shardList.length) promises.push(sleep(delay));
-      await Promise.all(promises); // eslint-disable-line no-await-in-loop
+      await Promise.all(promises);
     }
 
     return this.shards;
@@ -310,7 +310,7 @@ class ShardingManager extends EventEmitter {
     for (const shard of this.shards.values()) {
       const promises = [shard.respawn({ delay: respawnDelay, timeout })];
       if (++s < this.shards.size && shardDelay > 0) promises.push(sleep(shardDelay));
-      await Promise.all(promises); // eslint-disable-line no-await-in-loop
+      await Promise.all(promises);
     }
     return this.shards;
   }