aqualink 2.19.1 → 2.20.0

package/build/structures/Player.js

@@ -1,4 +1,4 @@
-const { EventEmitter } = require('tseep')
+const { EventEmitter } = require('node:events')
 const { AqualinkEvents } = require('./AqualinkEvents')
 const Connection = require('./Connection')
 const Filters = require('./Filters')
@@ -42,6 +42,7 @@ const RECONNECT_MAX = 15
 const MUTE_TOGGLE_DELAY = 300
 const SEEK_DELAY = 800
 const PAUSE_DELAY = 1200
+const VOICE_TRACE_INTERVAL = 15000
 const RETRY_BACKOFF_BASE = 1500
 const RETRY_BACKOFF_MAX = 5000
 const PREVIOUS_TRACKS_SIZE = 50
@@ -53,7 +54,7 @@ const INVALID_LOADS = new Set(['error', 'empty', 'LOAD_FAILED', 'NO_MATCHES'])
 const _functions = {
   clamp(v) {
     const n = +v
-    return Number.isNaN(n) ? 100 : n < 0 ? 0 : n > 200 ? 200 : n
+    return Number.isNaN(n) ? 100 : n < 0 ? 0 : n > 1000 ? 1000 : n
   },
   randIdx: (len) => (Math.random() * len) | 0,
   toId: (v) => v?.id || v || null,
@@ -213,6 +214,8 @@ class Player extends EventEmitter {
     this._voiceRequestAt = 0
     this._voiceRequestChannel = null
     this._suppressResumeUntil = 0
+    this._deferredStart = false
+    this._lastVoiceUpTraceAt = 0
     this._bindEvents()
     this._startWatchdog()
   }
@@ -254,13 +257,25 @@ class Player extends EventEmitter {
   _handlePlayerUpdate(packet) {
     if (this.destroyed || !packet?.state) return
     const s = packet.state
+    const wasConnected = this.connected
     this.position = _functions.isNum(s.position) ? s.position : 0
     this.connected = !!s.connected
     this.ping = _functions.isNum(s.ping) ? s.ping : 0
     this.timestamp = _functions.isNum(s.time) ? s.time : Date.now()
 
     if (!this.connected) {
-      if (!this._voiceDownSince && !this._reconnecting && !this._voiceRecovering) {
+      if (wasConnected || !this._voiceDownSince) {
+        this.aqua?._trace?.('player.voice.down', {
+          guildId: this.guildId,
+          reconnecting: !!this._reconnecting,
+          recovering: !!this._voiceRecovering
+        })
+      }
+      if (
+        !this._voiceDownSince &&
+        !this._reconnecting &&
+        !this._voiceRecovering
+      ) {
         this._voiceDownSince = Date.now()
         this._createTimer(() => {
           if (
@@ -277,6 +292,17 @@ class Player extends EventEmitter {
     } else {
       this._voiceDownSince = 0
       this.state = PLAYER_STATE.READY
+      const now = Date.now()
+      if (
+        !wasConnected ||
+        now - this._lastVoiceUpTraceAt >= VOICE_TRACE_INTERVAL
+      ) {
+        this._lastVoiceUpTraceAt = now
+        this.aqua?._trace?.('player.voice.up', {
+          guildId: this.guildId,
+          ping: this.ping
+        })
+      }
     }
 
     this.aqua.emit(AqualinkEvents.PlayerUpdate, this, packet)
@@ -294,7 +320,11 @@ class Player extends EventEmitter {
       return
     }
     try {
-      await this[handler](this, this.current, payload)
+      const trackArg =
+        payload.type === 'TrackStartEvent'
+          ? payload.track || this.current
+          : this.current
+      await this[handler](this, trackArg, payload)
     } catch (error) {
       this.aqua.emit(AqualinkEvents.Error, error)
     }
@@ -334,23 +364,48 @@ class Player extends EventEmitter {
     if (!item) return this
 
     try {
-      this.current = item.track ? item : await item.resolve(this.aqua)
+      let resolvedItem = null
+      if (item?.track) {
+        resolvedItem = item
+      } else if (typeof item?.resolve === 'function') {
+        resolvedItem = await item.resolve(this.aqua)
+      }
+      this.current = resolvedItem
       if (this.destroyed) return this
       if (!this.current?.track) throw new Error('Failed to resolve track')
 
       this.playing = true
       this.paused = !!options.paused
       this.position = options.startTime || 0
+      this.aqua?._trace?.('player.play', {
+        guildId: this.guildId,
+        paused: this.paused,
+        startTime: this.position,
+        hasTrack: !!this.current?.track
+      })
 
       if (this.destroyed || !this._updateBatcher) return this
 
+      if (
+        this.aqua?.autoRegionMigrate &&
+        !this._resuming &&
+        !this.connection?.endpoint
+      ) {
+        this._deferredStart = true
+        this.aqua?._trace?.('player.play.deferred', {
+          guildId: this.guildId,
+          reason: 'awaiting_voice_server_update'
+        })
+        return this
+      }
+
       const updateData = {
-        guildId: this.guildId,
         track: { encoded: this.current.track },
-        paused: this.paused,
+        paused: this.paused
       }
       if (this.position > 0) updateData.position = this.position
 
+      this._deferredStart = false
       await this.batchUpdatePlayer(updateData, true)
     } catch (error) {
       if (!this.destroyed) this.aqua?.emit(AqualinkEvents.Error, error)
@@ -382,6 +437,13 @@ class Player extends EventEmitter {
       self_deaf: this.deaf,
       self_mute: this.mute
     })
+    this.aqua?._trace?.('player.connect.request', {
+      guildId: this.guildId,
+      txId: this.txId,
+      voiceChannel,
+      deaf: this.deaf,
+      mute: this.mute
+    })
     return this
   }
 
@@ -462,6 +524,12 @@ class Player extends EventEmitter {
 
     if (!this.destroyed) {
       this.destroyed = true
+      this.aqua?._trace?.('player.destroy', {
+        guildId: this.guildId,
+        skipRemote: !!skipRemote,
+        preserveTracks: !!preserveTracks,
+        preserveReconnecting: !!preserveReconnecting
+      })
       this.emit('destroy')
     }
 
@@ -480,6 +548,7 @@ class Player extends EventEmitter {
     }
 
     this.connected = this.playing = this.paused = this.isAutoplay = false
+    this._deferredStart = false
     this.state = PLAYER_STATE.DESTROYED
     this.autoplayRetries = this.reconnectionRetries = 0
     if (!preserveReconnecting) this._reconnecting = false
@@ -547,10 +616,7 @@ class Player extends EventEmitter {
   pause(paused) {
     if (this.destroyed || this.paused === !!paused) return this
     this.paused = !!paused
-    this.batchUpdatePlayer(
-      { guildId: this.guildId, paused: this.paused },
-      true
-    ).catch(() => {})
+    this.batchUpdatePlayer({ paused: this.paused }, true).catch(() => {})
     return this
   }
 
@@ -562,10 +628,7 @@ class Player extends EventEmitter {
       ? Math.min(Math.max(position, 0), len)
       : Math.max(position, 0)
     this.position = clamped
-    this.batchUpdatePlayer(
-      { guildId: this.guildId, position: clamped },
-      true
-    ).catch(() => {})
+    this.batchUpdatePlayer({ position: clamped }, true).catch(() => {})
     return this
   }
 
@@ -617,7 +680,7 @@ class Player extends EventEmitter {
     this.playing = this.paused = false
     this.position = 0
     this.batchUpdatePlayer(
-      { guildId: this.guildId, track: { encoded: null, paused: this.paused } },
+      { track: { encoded: null }, paused: this.paused },
       true
     ).catch(() => {})
     return this
@@ -627,9 +690,7 @@ class Player extends EventEmitter {
     const vol = _functions.clamp(volume)
     if (this.destroyed || this.volume === vol) return this
     this.volume = vol
-    this.batchUpdatePlayer({ guildId: this.guildId, volume: vol }).catch(
-      () => {}
-    )
+    this.batchUpdatePlayer({ volume: vol }).catch(() => {})
     return this
   }
 
@@ -646,9 +707,7 @@ class Player extends EventEmitter {
     const id = _functions.toId(channel)
     if (!id) throw new TypeError('Invalid text channel')
     this.textChannel = id
-    this.batchUpdatePlayer({ guildId: this.guildId, text_channel: id }).catch(
-      () => {}
-    )
+    this.batchUpdatePlayer({ text_channel: id }).catch(() => {})
     return this
   }
 
@@ -734,7 +793,7 @@ class Player extends EventEmitter {
       this.destroyed ||
       !this.isAutoplayEnabled ||
       !this.previous ||
-      (this.queue?.size)
+      this.queue?.size
     )
       return this
     const prev = this.previous
@@ -837,22 +896,26 @@ class Player extends EventEmitter {
     return null
   }
 
-  trackStart(player, track, payload = {}) {
+  trackStart(_player, _track, payload = {}) {
     if (this.destroyed) return
+    const startedTrack = this.current || _track
+    if (!startedTrack) return
+    if (!this.current) this.current = startedTrack
     this.playing = true
     this.paused = false
-    this.aqua.emit(AqualinkEvents.TrackStart, this, this.current, {
+    this.aqua.emit(AqualinkEvents.TrackStart, this, startedTrack, {
       ...payload,
       resumed: this._resuming
     })
     this._resuming = false
   }
 
-  async trackEnd(player, track, payload) {
+  async trackEnd(_player, track, payload) {
     if (this.destroyed) return
 
     const reason = payload?.reason
-    const isFailure = reason === 'loadFailed' || reason === 'cleanup'
+    const isFailure = reason === 'loadFailed'
+    const isCleanup = reason === 'cleanup'
     const isReplaced = reason === 'replaced'
 
     if (track) this.previousTracks.push(track)
@@ -860,8 +923,8 @@ class Player extends EventEmitter {
       _functions.safeDel(this.nowPlayingMessage)
     if (!isReplaced) this.current = null
 
-    if (isFailure) {
-      if (!this.queue.size) {
+    if (isFailure || isCleanup) {
+      if (!this.queue.size || isCleanup) {
         this.clearData({ preserveTracks: this._reconnecting || this._resuming })
         this.aqua.emit(AqualinkEvents.QueueEnd, this)
       } else {
@@ -879,8 +942,9 @@ class Player extends EventEmitter {
       this.queue.add(track)
     }
 
-    if (this.queue.size && !isReplaced) {
-      this.aqua.emit(AqualinkEvents.TrackEnd, this, track, reason)
+    if (this.queue.size) {
+      if (!isReplaced)
+        this.aqua.emit(AqualinkEvents.TrackEnd, this, track, reason)
       await this.play()
     } else if (this.isAutoplayEnabled && !isReplaced) {
       await this.autoplay()
@@ -894,55 +958,55 @@ class Player extends EventEmitter {
     }
   }
 
-  trackError(player, track, payload) {
+  trackError(_player, track, payload) {
     if (this.destroyed) return
     this.aqua.emit(AqualinkEvents.TrackError, this, track, payload)
     this.stop()
   }
 
-  trackStuck(player, track, payload) {
+  trackStuck(_player, track, payload) {
     if (this.destroyed) return
     this.aqua.emit(AqualinkEvents.TrackStuck, this, track, payload)
     this.stop()
   }
 
-  trackChange(p, t, payload) {
+  trackChange(_p, t, payload) {
     _functions.emitIfActive(this, AqualinkEvents.TrackChange, t, payload)
   }
-  lyricsLine(p, t, payload) {
+  lyricsLine(_p, t, payload) {
     _functions.emitIfActive(this, AqualinkEvents.LyricsLine, t, payload)
   }
-  volumeChanged(p, t, payload) {
+  volumeChanged(_p, t, payload) {
     _functions.emitIfActive(this, AqualinkEvents.VolumeChanged, t, payload)
   }
-  filtersChanged(p, t, payload) {
+  filtersChanged(_p, t, payload) {
     _functions.emitIfActive(this, AqualinkEvents.FiltersChanged, t, payload)
   }
-  seekEvent(p, t, payload) {
+  seekEvent(_p, t, payload) {
     _functions.emitIfActive(this, AqualinkEvents.Seek, t, payload)
   }
-  lyricsFound(p, t, payload) {
+  lyricsFound(_p, t, payload) {
     _functions.emitIfActive(this, AqualinkEvents.LyricsFound, t, payload)
   }
-  lyricsNotFound(p, t, payload) {
+  lyricsNotFound(_p, t, payload) {
     _functions.emitIfActive(this, AqualinkEvents.LyricsNotFound, t, payload)
   }
-  playerCreated(p, t, payload) {
+  playerCreated(_p, _t, payload) {
     _functions.emitIfActive(this, AqualinkEvents.PlayerCreated, payload)
   }
-  playerConnected(p, t, payload) {
+  playerConnected(_p, _t, payload) {
     _functions.emitIfActive(this, AqualinkEvents.PlayerConnected, payload)
   }
-  playerDestroyed(p, t, payload) {
+  playerDestroyed(_p, _t, payload) {
     _functions.emitIfActive(this, AqualinkEvents.PlayerDestroyed, payload)
   }
-  pauseEvent(p, t, payload) {
+  pauseEvent(_p, _t, payload) {
     _functions.emitIfActive(this, AqualinkEvents.PauseEvent, payload)
   }
-  mixStarted(p, t, payload) {
+  mixStarted(_p, t, payload) {
     _functions.emitIfActive(this, AqualinkEvents.MixStarted, t, payload)
   }
-  mixEnded(p, t, payload) {
+  mixEnded(_p, t, payload) {
     _functions.emitIfActive(this, AqualinkEvents.MixEnded, t, payload)
   }
 
@@ -952,10 +1016,23 @@ class Player extends EventEmitter {
       throw new Error('Resume failed')
   }
 
-  async socketClosed(player, track, payload) {
+  async socketClosed(_player, _track, payload) {
     if (this.destroyed || this._reconnecting) return
+    this.aqua?._trace?.('player.socketClosed', {
+      guildId: this.guildId,
+      code: payload?.code
+    })
 
     const code = payload?.code
+    if (code === 4006 && this._resuming) {
+      this.aqua?._trace?.('player.socketClosed.ignored', {
+        guildId: this.guildId,
+        code,
+        reason: 'transient_while_resuming'
+      })
+      return
+    }
+
     let isRecoverable = [4015, 4009, 4006, 4014, 4022].includes(code)
     if (code === 4014 && this.connection?.isWaitingForDisconnect)
       isRecoverable = false
@@ -1135,6 +1212,27 @@ class Player extends EventEmitter {
     return this.nodes.rest.updatePlayer({ guildId: this.guildId, data })
   }
 
+  _flushDeferredPlay() {
+    if (
+      !this._deferredStart ||
+      this.destroyed ||
+      !this.current?.track ||
+      !this._updateBatcher
+    )
+      return
+    this._deferredStart = false
+    const updateData = {
+      track: { encoded: this.current.track },
+      paused: this.paused
+    }
+    if (this.position > 0) updateData.position = this.position
+    this.aqua?._trace?.('player.play.deferred.flush', {
+      guildId: this.guildId,
+      hasEndpoint: !!this.connection?.endpoint
+    })
+    this.batchUpdatePlayer(updateData, true).catch(() => {})
+  }
+
   cleanup() {
     if (!this.playing && !this.paused && !this.queue?.size) this.destroy()
   }

package/build/structures/Plugins.js

@@ -3,8 +3,8 @@ class Plugin {
     this.name = name
   }
 
-  load(aqua) {}
-  unload(aqua) {}
+  load(_aqua) {}
+  unload(_aqua) {}
 }
 
 module.exports = Plugin

package/build/structures/Queue.js

@@ -38,17 +38,19 @@ class Queue {
     this._head = 0
   }
 
-  shuffle() {
-    if (this._head > 0) {
-      if (this._head > 0) {
-        const len = this._items.length - this._head
-        for (let i = 0; i < len; i++) {
-          this._items[i] = this._items[this._head + i]
-        }
-        this._items.length = len
-        this._head = 0
-      }
+  _compact(force = false) {
+    if (this._head <= 0) return
+    if (!force && this._head <= this._items.length / 2) return
+    const len = this._items.length - this._head
+    for (let i = 0; i < len; i++) {
+      this._items[i] = this._items[this._head + i]
     }
+    this._items.length = len
+    this._head = 0
+  }
+
+  shuffle() {
+    this._compact(true)
     for (let i = this._items.length - 1; i > 0; i--) {
       const j = Math.floor(Math.random() * (i + 1))
       const temp = this._items[i]
@@ -106,14 +108,7 @@ class Queue {
     const item = this._items[this._head]
     this._items[this._head] = undefined // Allow GC
     this._head++
-    if (this._head > 0 && this._head > this._items.length / 2) {
-      const len = this._items.length - this._head
-      for (let i = 0; i < len; i++) {
-        this._items[i] = this._items[this._head + i]
-      }
-      this._items.length = len
-      this._head = 0
-    }
+    this._compact(false)
     return item
   }