aqualink 3.0.0 → 3.2.0

package/build/structures/Player.js

@@ -35,6 +35,7 @@ const EVENT_HANDLERS = Object.freeze({
   PlayerDestroyedEvent: 'playerDestroyed',
   LyricsNotFoundEvent: 'lyricsNotFound',
   MixStartedEvent: 'mixStarted',
+  PlayerReconnectingEvent: 'PlayerReconnectingEvent',
   MixEndedEvent: 'mixEnded'
 })
 
@@ -122,7 +123,8 @@ class MicrotaskUpdateBatcher {
     const { player: p, updates: u } = this
     this.updates = null
     this.scheduled = false
-    if (!u || !p) return Promise.resolve()
+    if (!u || !p || p.destroyed || p.state === PLAYER_STATE.DISCONNECTING)
+      return Promise.resolve()
     return p.updatePlayer(u).catch((err) => {
       _functions.emitAquaError(
         p.aqua,
@@ -296,7 +298,9 @@ class Player extends EventEmitter {
   }
 
   _isVoiceRecoveryActive(token) {
-    return !!token && !this.destroyed && this._activeVoiceRecoveryToken === token
+    return (
+      !!token && !this.destroyed && this._activeVoiceRecoveryToken === token
+    )
   }
 
   _clearVoiceRecovery(token = this._activeVoiceRecoveryToken, reason = null) {
@@ -352,6 +356,11 @@ class Player extends EventEmitter {
 
   async play(track, options = {}) {
     if (this.destroyed || !this.queue) return this
+    if (options != null && typeof options !== 'object') {
+      throw new TypeError(
+        `Player.play(): options must be an object, got ${typeof options}`
+      )
+    }
 
     let item = track
     if (!item) {
@@ -484,7 +493,8 @@ class Player extends EventEmitter {
   }
 
   connect(options = {}) {
-    if (this.destroyed) throw new Error('Cannot connect destroyed player')
+    if (this.destroyed)
+      throw new Error(`Cannot connect destroyed player (guild=${this.guildId})`)
 
     const voiceChannel = _functions.toId(
       options.voiceChannel || this.voiceChannel
@@ -542,38 +552,29 @@ class Player extends EventEmitter {
   }
 
   destroy(options = {}) {
+    if (this.destroyed) return this
+
     const {
       preserveClient = true,
       skipRemote = false,
       preserveMessage = false,
       preserveReconnecting = false,
-      preserveTracks = false
+      preserveTracks = false,
+      abortSignal = null
     } = options
-    if (this.destroyed && !this.queue) {
-      this._reconnectNonce++
-      if (this._reconnectTimers) {
-        _functions.clearTimers(this._reconnectTimers)
-        this._reconnectTimers = null
-      }
-      this._reconnecting = false
-      this._isActivelyReconnecting = false
-      return this
-    }
 
-    if (!this.destroyed) {
-      this._reconnectNonce++
-      this.destroyed = true
-      this._clearVoiceRecovery(undefined, 'destroyed')
-      if (this.aqua?.debugTrace) {
-        this.aqua._trace('player.destroy', {
-          guildId: this.guildId,
-          skipRemote: !!skipRemote,
-          preserveTracks: !!preserveTracks,
-          preserveReconnecting: !!preserveReconnecting
-        })
-      }
-      this.emit('destroy')
+    this._reconnectNonce++
+    this.destroyed = true
+    this._clearVoiceRecovery(undefined, 'destroyed')
+    if (this.aqua?.debugTrace) {
+      this.aqua._trace('player.destroy', {
+        guildId: this.guildId,
+        skipRemote: !!skipRemote,
+        preserveTracks: !!preserveTracks,
+        preserveReconnecting: !!preserveReconnecting
+      })
     }
+    this.emit('destroy')
 
     if (this._voiceWatchdogTimer) {
       clearInterval(this._voiceWatchdogTimer)
@@ -583,7 +584,6 @@ class Player extends EventEmitter {
     _functions.clearTimers(this._pendingTimers)
     this._pendingTimers = null
 
-    // Clear reconnection timers to prevent memory leaks when destroyed externally
     if (this._reconnectTimers) {
       _functions.clearTimers(this._reconnectTimers)
       this._reconnectTimers = null
@@ -633,8 +633,23 @@ class Player extends EventEmitter {
     this.previousTracks = null
     this.previousIdentifiers?.clear()
     this.previousIdentifiers = null
-    this.queue?.clear()
+    if (this.queue) {
+      for (
+        let i = this.queue._head || 0;
+        i < (this.queue._items?.length || 0);
+        i++
+      ) {
+        const t = this.queue._items[i]
+        if (t && typeof t.dispose === 'function') {
+          try {
+            t.dispose()
+          } catch {}
+        }
+      }
+      this.queue.clear()
+    }
     this.queue = null
+    // ML-1: Clear _dataStore to prevent unbounded growth
     this._dataStore?.clear()
     this._dataStore = null
 
@@ -662,14 +677,25 @@ class Player extends EventEmitter {
 
     if (!skipRemote) {
       try {
-        this.send({ guild_id: this.guildId, channel_id: null })
-        this.aqua?.destroyPlayer?.(this.guildId)
-        if (this.nodes?.connected)
-          this.nodes.rest?.destroyPlayer(this.guildId).catch((error) =>
-            reportSuppressedError(this, 'player.destroy.remote', error, {
-              guildId: this.guildId
+        if (abortSignal?.aborted) {
+          if (this.aqua?.debugTrace) {
+            this.aqua._trace('player.destroy.aborted', {
+              guildId: this.guildId,
+              reason: 'abort_signal_already_set'
             })
-          )
+          }
+        } else {
+          this.send({ guild_id: this.guildId, channel_id: null })
+          this.aqua?.destroyPlayer?.(this.guildId)
+          if (this.nodes?.connected)
+            this.nodes.rest
+              ?.destroyPlayer(this.guildId, abortSignal)
+              .catch((error) => {
+                reportSuppressedError(this, 'player.destroy.remote', error, {
+                  guildId: this.guildId
+                })
+              })
+        }
       } catch (error) {
         reportSuppressedError(this, 'player.destroy.gateway', error, {
           guildId: this.guildId
@@ -677,12 +703,23 @@ class Player extends EventEmitter {
       }
     }
 
-    if (!preserveClient) this.aqua = this.nodes = null
+    if (!preserveClient) {
+      try {
+        this.aqua?.removeListener?.('playerUpdate', this._boundPlayerUpdate)
+      } catch {}
+      this.aqua = this.nodes = null
+    }
     return this
   }
 
   pause(paused) {
-    if (this.destroyed || this.paused === !!paused) return this
+    if (this.destroyed) return this
+    if (paused != null && typeof paused !== 'boolean') {
+      throw new TypeError(
+        `Player.pause(): paused must be a boolean, got ${typeof paused}`
+      )
+    }
+    if (this.paused === !!paused) return this
     this.paused = !!paused
     this.batchUpdatePlayer({ paused: this.paused }, true).catch((error) =>
       reportSuppressedError(this, 'player.pause', error, {
@@ -694,8 +731,12 @@ class Player extends EventEmitter {
   }
 
   seek(position) {
-    if (this.destroyed || !this.playing || !_functions.isNum(position))
-      return this
+    if (position == null || !_functions.isNum(position)) {
+      throw new TypeError(
+        `Player.seek(): position must be a non-negative number, got ${typeof position}`
+      )
+    }
+    if (this.destroyed || !this.playing) return this
     const len = this.current?.info?.length || 0
     const clamped = len
       ? Math.min(Math.max(position, 0), len)
@@ -769,6 +810,14 @@ class Player extends EventEmitter {
   }
 
   setVolume(volume) {
+    if (
+      volume == null ||
+      (typeof volume !== 'number' && typeof volume !== 'string')
+    ) {
+      throw new TypeError(
+        `Player.setVolume(): volume must be a number, got ${typeof volume}`
+      )
+    }
     const vol = _functions.clamp(volume)
     if (this.destroyed || this.volume === vol) return this
     this.volume = vol
@@ -909,22 +958,24 @@ class Player extends EventEmitter {
     const prev = this.previous
     const info = prev?.info
     if (!info?.sourceName || !info.identifier) return this
-    const { sourceName, identifier, uri, author } = info
+    const { sourceName, identifier, uri, author, title } = info
     this.isAutoplay = true
 
-    if (sourceName === 'spotify' && info.identifier) {
-      this.previousIdentifiers.add(info.identifier)
-      if (this.previousIdentifiers.size > PREVIOUS_IDS_MAX) {
-        this.previousIdentifiers.delete(
-          this.previousIdentifiers.values().next().value
-        )
-      }
-      if (!this.autoplaySeed) {
-        this.autoplaySeed = {
-          trackId: identifier,
-          artistIds: Array.isArray(author) ? author.join(',') : author
+    if (sourceName === 'spotify') {
+      if (info.identifier && info.identifier !== 'local') {
+        this.previousIdentifiers.add(info.identifier)
+        if (this.previousIdentifiers.size > PREVIOUS_IDS_MAX) {
+          this.previousIdentifiers.delete(
+            this.previousIdentifiers.values().next().value
+          )
         }
       }
+      this.autoplaySeed = {
+        trackId: identifier,
+        isrc: prev.isrc || null,
+        title: title || null,
+        author: author || null
+      }
     }
 
     for (
@@ -972,27 +1023,45 @@ class Player extends EventEmitter {
   }
 
   async _getAutoplayTrack(sourceName, identifier, uri, requester) {
+    const seen = new Set(this.previousIdentifiers)
+    const prevId = this.current?.identifier
+    if (prevId) seen.add(prevId)
+
     if (sourceName === 'youtube' || sourceName === 'ytmusic') {
       const res = await this.aqua.resolve({
         query: `https://www.youtube.com/watch?v=${identifier}&list=RD${identifier}`,
         source: 'ytmsearch',
         requester
       })
-      return _functions.isInvalidLoad(res)
-        ? null
+      if (_functions.isInvalidLoad(res) || !res.tracks?.length) return null
+      const candidates = res.tracks.filter(
+        (t) => t.identifier && !seen.has(t.identifier)
+      )
+      return candidates.length
+        ? candidates[_functions.randIdx(candidates.length)]
         : res.tracks[_functions.randIdx(res.tracks.length)]
     }
     if (sourceName === 'soundcloud') {
-      const scRes = await scAutoPlay(uri)
+      const scRes = await scAutoPlay(uri, this.nodes?.rest?._autoplayAgent)
       if (!scRes?.length) return null
-      const res = await this.aqua.resolve({
-        query: scRes[0],
-        source: 'scsearch',
-        requester
-      })
-      return _functions.isInvalidLoad(res)
-        ? null
-        : res.tracks[_functions.randIdx(res.tracks.length)]
+
+      let anyValid = null
+      for (const link of scRes) {
+        const res = await this.aqua.resolve({
+          query: link,
+          source: 'scsearch',
+          requester
+        })
+        if (_functions.isInvalidLoad(res) || !res.tracks?.length) continue
+        if (!anyValid)
+          anyValid = res.tracks[_functions.randIdx(res.tracks.length)]
+        const candidates = res.tracks.filter(
+          (t) => t.identifier && !seen.has(t.identifier)
+        )
+        if (candidates.length)
+          return candidates[_functions.randIdx(candidates.length)]
+      }
+      return anyValid
     }
     if (sourceName === 'spotify') {
       const res = await spAutoPlay(
@@ -1029,6 +1098,7 @@ class Player extends EventEmitter {
     const isReplaced = reason === 'replaced'
 
     if (track) this.previousTracks.push(track)
+    if (isReplaced) return
     if (this.shouldDeleteMessage && !this._reconnecting && !this._resuming)
       _functions.safeDel(this.nowPlayingMessage)
     if (!isReplaced) this.current = null
@@ -1122,9 +1192,19 @@ class Player extends EventEmitter {
   mixEnded(_p, t, payload) {
     _functions.emitIfActive(this, AqualinkEvents.MixEnded, t, payload)
   }
+  PlayerReconnectingEvent(_p, _t, payload) {
+    this._resuming = true
+    _functions.emitIfActive(
+      this,
+      AqualinkEvents.PlayerReconnectingEvent,
+      payload
+    )
+    this.connection?.resendVoiceUpdate?.(true)
+    this.aqua.emit(AqualinkEvents.PlayerReconnect, this, { resuming: true })
+  }
 
-  async _attemptVoiceResume() {
-    return this._lifecycleController.attemptVoiceResume()
+  async _attemptVoiceResume(abortSignal) {
+    return this._lifecycleController.attemptVoiceResume(abortSignal)
   }
 
   async socketClosed(_player, _track, payload) {
@@ -1142,7 +1222,7 @@ class Player extends EventEmitter {
     } catch (err) {
       _functions.emitAquaError(
         this.aqua,
-        new Error(`Send fail: ${err.message}`)
+        new Error(`Send fail (guild=${this.guildId}): ${err.message}`)
       )
       return false
     }

package/build/structures/PlayerLifecycle.js

@@ -30,6 +30,8 @@ class PlayerLifecycle {
     player.ping = this._functions.isNum(s.ping) ? s.ping : 0
     player.timestamp = this._functions.isNum(s.time) ? s.time : Date.now()
 
+    if (player.destroyed) return
+
     if (!player.connected) {
       if (wasConnected || !player._voiceDownSince) {
         if (player.aqua?.debugTrace) {
@@ -148,7 +150,9 @@ class PlayerLifecycle {
     if (!hasVoiceData) {
       const downFor = Date.now() - player._voiceDownSince
       if (downFor > this.VOICE_DOWN_THRESHOLD * this.VOICE_ABANDON_MULTIPLIER) {
-        const recoveryToken = player._claimVoiceRecovery('watchdog_voice_refresh')
+        const recoveryToken = player._claimVoiceRecovery(
+          'watchdog_voice_refresh'
+        )
         if (player._isVoiceRecoveryActive(recoveryToken))
           player.connection?._requestVoiceState?.()
         if (player._isVoiceRecoveryActive(recoveryToken))
@@ -215,11 +219,15 @@ class PlayerLifecycle {
     }
   }
 
-  async attemptVoiceResume() {
+  async attemptVoiceResume(abortSignal) {
     const player = this.player
-    if (!player.connection?.sessionId) throw new Error('No session')
+    if (!player.connection?.sessionId)
+      throw new Error(`No session (guild=${player.guildId})`)
+    if (abortSignal?.aborted) throw new Error('Resume aborted by signal')
     if (!(await player.connection.attemptResume()))
-      throw new Error('Resume failed')
+      throw new Error(
+        `Resume failed (guild=${player.guildId}, endpoint=${player.connection.endpoint || 'none'})`
+      )
   }
 
   async socketClosed(_player, _track, payload) {
@@ -233,6 +241,11 @@ class PlayerLifecycle {
     }
 
     const code = payload?.code
+    if (code === 4014) {
+      await player._delay(150)
+      if (player.destroyed) return
+    }
+
     if (code === 4006 && player._resuming) {
       if (player.aqua?.debugTrace) {
         player.aqua._trace('player.socketClosed.ignored', {
@@ -245,7 +258,10 @@ class PlayerLifecycle {
     }
 
     let isRecoverable = [4015, 4009, 4006, 4014, 4022].includes(code)
-    if (code === 4014 && player.connection?.isWaitingForDisconnect)
+    if (
+      code === 4014 &&
+      (player.connection?.isWaitingForDisconnect || !player.voiceChannel)
+    )
       isRecoverable = false
 
     if (code === 4015 && !player.nodes?.info?.isNodelink) {
@@ -342,7 +358,8 @@ class PlayerLifecycle {
           return false
         })
       }
-      if (resumed) player._clearVoiceRecovery(recoveryToken, 'socket_soft_resumed')
+      if (resumed)
+        player._clearVoiceRecovery(recoveryToken, 'socket_soft_resumed')
       if (
         resumed ||
         player.connected ||
@@ -443,6 +460,7 @@ class PlayerLifecycle {
         if (
           latestActivePlayer &&
           latestActivePlayer !== player &&
+          latestActivePlayer !== np &&
           !latestActivePlayer.destroyed
         ) {
           try {

package/build/structures/Queue.js

@@ -2,6 +2,7 @@ class Queue {
   constructor() {
     this._items = []
     this._head = 0
+    this._compactThreshold = 64
   }
 
   get size() {
@@ -40,13 +41,16 @@ class Queue {
 
   _compact(force = false) {
     if (this._head <= 0) return
-    if (!force && this._head <= this._items.length / 2) return
+    if (!force && this._head < this._compactThreshold) 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
+    if (this._compactThreshold < len) {
+      this._compactThreshold = Math.min(len * 2, 1024)
+    }
   }
 
   shuffle() {

package/build/structures/Reporting.js

@@ -26,7 +26,19 @@ function reportSuppressedError(target, scope, error, data = null) {
   return err
 }
 
+function emitOperationalError(target, source, error) {
+  const aqua = getAqua(target)
+  const err = normalizeError(error)
+  if (aqua?.listenerCount?.(AqualinkEvents.Error) > 0) {
+    aqua.emit(AqualinkEvents.Error, source, err)
+  } else if (aqua?.debugTrace) {
+    aqua._trace('aqua.error.unhandled', { error: err.message })
+  }
+  return err
+}
+
 module.exports = {
+  emitOperationalError,
   normalizeError,
   reportSuppressedError
 }