aqualink 3.0.0 → 3.2.0

package/build/index.js

@@ -51,9 +51,9 @@ const VoiceRegion = Object.freeze({
   CanadaToronto: 'yyz',
   CanadaMontreal: 'ymq',
 
-  Brazil: 'gru' || 'brazil', // i only know this endpoint lol.
-  Chile: 'scl' || 'chile',
-  Argentina: 'eze' || 'argentina'
+  Brazil: 'gru', // i only know this endpoint lol.
+  Chile: 'scl',
+  Argentina: 'eze'
 })
 
 module.exports = {

package/build/structures/Aqua.js

@@ -7,7 +7,7 @@ const AquaRecovery = require('./AquaRecovery')
 const Node = require('./Node')
 const Player = require('./Player')
 const Track = require('./Track')
-const { reportSuppressedError } = require('./Reporting')
+const { emitOperationalError, reportSuppressedError } = require('./Reporting')
 const { version: pkgVersion } = require('../../package.json')
 
 const SEARCH_PREFIX = ':'
@@ -73,10 +73,12 @@ const _functions = {
   isUrl: (query) => {
     if (typeof query !== 'string' || query.length <= 8) return false
     const q = query.trimStart()
-    return q.startsWith('http://') || q.startsWith('https://')
+    return (
+      q.startsWith('http://') || q.startsWith('https://') || q.includes(':')
+    )
   },
   formatQuery(query, source) {
-    return this.isUrl(query) ? query : `${source}${SEARCH_PREFIX}${query}`
+    return _functions.isUrl(query) ? query : `${source}${SEARCH_PREFIX}${query}`
   },
   makeTrack: (t, requester, node) => new Track(t, requester, node),
   safeCall(fn) {
@@ -191,7 +193,10 @@ class Aqua extends EventEmitter {
 
   _trace(event, data = null) {
     if (!this.debugTrace) return
-    if (!this._traceBuffer || this._traceBuffer.length !== this.traceMaxEntries) {
+    if (
+      !this._traceBuffer ||
+      this._traceBuffer.length !== this.traceMaxEntries
+    ) {
       this._traceBuffer = new Array(this.traceMaxEntries)
       this._traceBufferCount = 0
       this._traceBufferIndex = 0
@@ -346,9 +351,14 @@ class Aqua extends EventEmitter {
         this._invalidateCache()
         queueMicrotask(() => {
           this._storeBrokenPlayers(node).catch((error) =>
-            reportSuppressedError(this, 'aqua.nodeDisconnect.storeBrokenPlayers', error, {
-              node: node?.name || node?.host
-            })
+            reportSuppressedError(
+              this,
+              'aqua.nodeDisconnect.storeBrokenPlayers',
+              error,
+              {
+                node: node?.name || node?.host
+              }
+            )
           )
           this._performCleanup()
         })
@@ -484,12 +494,7 @@ class Aqua extends EventEmitter {
       (stats.memory ? stats.memory.used / reservable : 0) * 40 +
       (node.rest?.calls || 0) * 0.001
     if (this._nodeLoadCache.size >= MAX_CACHE_SIZE) {
-      const iterator = this._nodeLoadCache.keys()
-      while (this._nodeLoadCache.size >= MAX_CACHE_SIZE) {
-        const oldest = iterator.next().value
-        if (!oldest) break
-        this._nodeLoadCache.delete(oldest)
-      }
+      this._nodeLoadCache.delete(this._nodeLoadCache.keys().next().value)
     }
     this._nodeLoadCache.set(id, { load, time: now })
     return load
@@ -541,17 +546,12 @@ class Aqua extends EventEmitter {
       attempts: 0,
       lastAttempt: 0
     }
-    try {
-      await node.connect()
-      this._failoverState[id].connected = true
-      this._failoverState[id].failoverInProgress = false
-      this._invalidateCache()
-      this.emit(AqualinkEvents.NodeCreate, node)
-      return node
-    } catch (error) {
-      this._cleanupNode(id)
-      throw error
-    }
+    await node.connect()
+    this._failoverState[id].connected = true
+    this._failoverState[id].failoverInProgress = false
+    this._invalidateCache()
+    this.emit(AqualinkEvents.NodeCreate, node)
+    return node
   }
 
   _destroyNode(id) {
@@ -754,9 +754,8 @@ class Aqua extends EventEmitter {
       query,
       source || this.defaultSearchPlatform
     )
-    const endpoint = `/${this.restVersion}/loadtracks?identifier=${encodeURIComponent(formatted)}`
     try {
-      const response = await node.rest.makeRequest('GET', endpoint)
+      const response = await node.rest.loadTracks(formatted)
       if (
         !response ||
         response.loadType === 'empty' ||
@@ -765,11 +764,13 @@ class Aqua extends EventEmitter {
         return EMPTY_TRACKS_RESPONSE
       return this._constructResponse(response, requester, node)
     } catch (error) {
-      throw new Error(
-        error?.name === 'AbortError'
-          ? 'Request timeout'
-          : `Resolve failed: ${error?.message || error}`
-      )
+      if (error?.name === 'AbortError') throw new Error('Request timeout')
+      const err = new Error(`Resolve failed: ${error?.message || error}`)
+      if (error?.statusCode != null) err.statusCode = error.statusCode
+      if (error?.body) err.body = error.body
+      if (error?.url) err.url = error.url
+      err.cause = error
+      throw err
     }
   }
 
@@ -874,11 +875,35 @@ class Aqua extends EventEmitter {
     const lockFile = `${filePath}.lock`
     const tempFile = `${filePath}.tmp`
     let ws = null
+    let lockAcquired = false
     try {
       await fs.promises.writeFile(lockFile, String(process.pid), { flag: 'wx' })
+      lockAcquired = true
       ws = fs.createWriteStream(tempFile, { encoding: 'utf8', flags: 'w' })
+      let streamError = null
+      ws.on('error', (error) => {
+        streamError = error
+      })
       const buffer = []
-      let drainPromise = Promise.resolve()
+      const write = (chunk) => {
+        if (ws.write(chunk)) return Promise.resolve()
+        return new Promise((resolve, reject) => {
+          const onDrain = () => {
+            cleanup()
+            resolve()
+          }
+          const onError = (error) => {
+            cleanup()
+            reject(error)
+          }
+          const cleanup = () => {
+            ws.off('drain', onDrain)
+            ws.off('error', onError)
+          }
+          ws.once('drain', onDrain)
+          ws.once('error', onError)
+        })
+      }
 
       const nodeSessions = {}
       for (const node of this.nodeMap.values()) {
@@ -910,29 +935,36 @@ class Aqua extends EventEmitter {
         if (buffer.length >= WRITE_BUFFER_SIZE) {
           const chunk = `${buffer.join('\n')}\n`
           buffer.length = 0
-          if (!ws.write(chunk)) {
-            drainPromise = drainPromise.then(
-              () => new Promise((r) => ws.once('drain', r))
-            )
-          }
+          await write(chunk)
         }
       }
 
-      if (buffer.length) ws.write(`${buffer.join('\n')}\n`)
-      await drainPromise
-      await new Promise((resolve, reject) =>
-        ws.end((err) => (err ? reject(err) : resolve()))
-      )
+      if (buffer.length) await write(`${buffer.join('\n')}\n`)
+      if (streamError) throw streamError
+      await new Promise((resolve, reject) => {
+        const onError = (error) => {
+          ws.off('finish', onFinish)
+          reject(error)
+        }
+        const onFinish = () => {
+          ws.off('error', onError)
+          resolve()
+        }
+        ws.once('error', onError)
+        ws.once('finish', onFinish)
+        ws.end()
+      })
       ws = null
       await fs.promises.rename(tempFile, filePath)
     } catch (error) {
       console.error(`[Aqua/Autoresume]Error saving players:`, error)
-      this.emit(AqualinkEvents.Error, null, error)
+      emitOperationalError(this, null, error)
       if (ws) _functions.safeCall(() => ws.destroy())
       await fs.promises.unlink(tempFile).catch(_functions.noop)
     } finally {
       if (ws) _functions.safeCall(() => ws.destroy())
-      await fs.promises.unlink(lockFile).catch(_functions.noop)
+      if (lockAcquired)
+        await fs.promises.unlink(lockFile).catch(_functions.noop)
     }
   }
 

package/build/structures/AquaRecovery.js

@@ -2,7 +2,7 @@ const fs = require('node:fs')
 const path = require('node:path')
 const readline = require('node:readline')
 const { AqualinkEvents } = require('./AqualinkEvents')
-const { reportSuppressedError } = require('./Reporting')
+const { emitOperationalError, reportSuppressedError } = require('./Reporting')
 
 class AquaRecovery {
   constructor(aqua, deps) {
@@ -112,7 +112,10 @@ class AquaRecovery {
       const batch = rebuilds.slice(i, i + this.MAX_CONCURRENT_OPS)
       const results = await Promise.allSettled(
         batch.map((state) =>
-          this.restorePlayer(state, node).then((ok) => ({ ok, guildId: state.g }))
+          this.restorePlayer(state, node).then((ok) => ({
+            ok,
+            guildId: state.g
+          }))
         )
       )
       for (let j = 0; j < results.length; j++) {
@@ -218,7 +221,7 @@ class AquaRecovery {
         this.performCleanup()
       }
     } catch (error) {
-      this.aqua.emit(AqualinkEvents.Error, null, error)
+      emitOperationalError(this.aqua, null, error)
     } finally {
       state.failoverInProgress = false
     }
@@ -264,12 +267,32 @@ class AquaRecovery {
       async () => {
         const state = this.capturePlayerState(player)
         if (!state) throw new Error('Failed to capture state')
+        const oldMessage = player.nowPlayingMessage || null
+        const oldVoice = player.connection
+          ? {
+              sid: player.connection.sessionId,
+              ep: player.connection.endpoint,
+              tok: player.connection.token,
+              reg: player.connection.region,
+              cid: player.connection.channelId
+            }
+          : null
+        player.destroy({
+          preserveClient: true,
+          skipRemote: true,
+          preserveMessage: true,
+          preserveTracks: true,
+          preserveReconnecting: true
+        })
         const { maxRetries, retryDelay } = this.aqua.failoverOptions
         for (let retry = 0; retry < maxRetries; retry++) {
+          let newPlayer = null
           try {
             const targetNode = pickNode()
-            const newPlayer = this.createPlayerOnNode(targetNode, state)
+            newPlayer = this.createPlayerOnNode(targetNode, state)
+            this._applyVoiceBootstrap(newPlayer, oldVoice)
             await this.restorePlayerState(newPlayer, state)
+            if (oldMessage) newPlayer.nowPlayingMessage = oldMessage
             this.aqua.emit(
               AqualinkEvents.PlayerMigrated,
               player,
@@ -278,6 +301,13 @@ class AquaRecovery {
             )
             return newPlayer
           } catch (error) {
+            newPlayer?.destroy?.({
+              preserveClient: true,
+              skipRemote: true,
+              preserveMessage: true,
+              preserveTracks: true,
+              preserveReconnecting: true
+            })
             if (retry === maxRetries - 1) throw error
             await this._functions.delay(retryDelay * 1.5 ** retry)
           }
@@ -443,12 +473,13 @@ class AquaRecovery {
     if (!player || !guildId || !(position > 0)) return
     const seekOnce = (startedPlayer) => {
       if (startedPlayer.guildId !== guildId) return
+      this.aqua.off(AqualinkEvents.TrackStart, seekOnce)
+      player.removeListener('destroy', cleanup)
       this._functions.unrefTimeout(() => player.seek?.(position), delay)
     }
-    this.aqua.once(AqualinkEvents.TrackStart, seekOnce)
-    player.once('destroy', () =>
-      this.aqua.off(AqualinkEvents.TrackStart, seekOnce)
-    )
+    const cleanup = () => this.aqua.off(AqualinkEvents.TrackStart, seekOnce)
+    this.aqua.on(AqualinkEvents.TrackStart, seekOnce)
+    player.once('destroy', cleanup)
   }
 
   async restorePlayerState(newPlayer, state) {
@@ -484,10 +515,12 @@ class AquaRecovery {
     this.aqua._loading = true
     const lockFile = `${filePath}.lock`
     let stream = null,
-      rl = null
+      rl = null,
+      lockAcquired = false
     try {
       await fs.promises.access(filePath)
       await fs.promises.writeFile(lockFile, String(process.pid), { flag: 'wx' })
+      lockAcquired = true
       await this.waitForFirstNode()
 
       stream = fs.createReadStream(filePath, { encoding: 'utf8' })
@@ -533,13 +566,14 @@ class AquaRecovery {
     } catch (error) {
       if (error.code !== 'ENOENT') {
         console.error(`[Aqua/Autoresume]Error loading players:`, error)
-        this.aqua.emit(AqualinkEvents.Error, null, error)
+        emitOperationalError(this.aqua, null, error)
       }
     } finally {
       this.aqua._loading = false
       if (rl) this._functions.safeCall(() => rl.close())
       if (stream) this._functions.safeCall(() => stream.destroy())
-      await fs.promises.unlink(lockFile).catch(this._functions.noop)
+      if (lockAcquired)
+        await fs.promises.unlink(lockFile).catch(this._functions.noop)
     }
   }
 
@@ -551,8 +585,9 @@ class AquaRecovery {
         if (existing?.playing && !existing.destroyed) return true
         if (existing?.destroyed) this.aqua.players.delete(gId)
 
-        const targetNode =
-          preferredNode?.connected ? preferredNode : this.aqua.leastUsedNodes[0]
+        const targetNode = preferredNode?.connected
+          ? preferredNode
+          : this.aqua.leastUsedNodes[0]
         if (!targetNode?.connected) {
           throw new Error(`No connected node available to restore guild ${gId}`)
         }

package/build/structures/AqualinkEvents.js

@@ -36,6 +36,8 @@ const AqualinkEvents = {
   PlayerDestroyed: 'playerDestroy',
   PlayerMigrated: 'playerMigrated',
   PauseEvent: 'pauseEvent',
+  PlayerReconnectingEvent: 'PlayerReconnectingEvent',
+  PlayerReconnect: 'playerReconnect',
   MixStarted: 'mixStarted',
   MixEnded: 'mixEnded'
 }

package/build/structures/Connection.js

@@ -76,6 +76,7 @@ const _functions = {
     v.endpoint = conn.endpoint
     v.sessionId = conn.sessionId
     v.channelId = player.voiceChannel
+    v.resuming = player?._resuming ?? false
     payload.data.volume = player?.volume ?? 100
     return payload
   }
@@ -168,7 +169,8 @@ class Connection {
       STATE,
       RECONNECT_DELAY,
       MAX_RECONNECT_ATTEMPTS,
-      RESUME_BACKOFF_MAX
+      RESUME_BACKOFF_MAX,
+      sharedPool
     })
   }
 
@@ -240,6 +242,12 @@ class Connection {
         })
       }
       this.isWaitingForDisconnect = true
+      if (this.voiceChannel !== null) {
+        const oldChannel = this.voiceChannel
+        this.voiceChannel = null
+        if (p) p.voiceChannel = null
+        this._aqua.emit(AqualinkEvents.PlayerMove, p, oldChannel, null)
+      }
       if (!this._nullChannelTimer) {
         this._nullChannelTimer = setTimeout(() => {
           this._nullChannelTimer = null
@@ -321,7 +329,9 @@ class Connection {
     } catch (e) {
       this._aqua?.emit?.(
         AqualinkEvents.Debug,
-        new Error(`Player destroy failed: ${e?.message || e}`)
+        new Error(
+          `Player destroy failed (guild=${this._guildId}, sessionId=${this.sessionId || 'none'}): ${e?.message || e}`
+        )
       )
     } finally {
       this._stateFlags &= ~STATE.DISCONNECTING
@@ -452,6 +462,15 @@ class Connection {
 
   _executeVoiceUpdate() {
     if (this._destroyed) return
+    if (this._stateFlags & STATE.DISCONNECTING) {
+      this._stateFlags &= ~STATE.UPDATE_SCHEDULED
+      this._voiceFlushTimer = null
+      if (this._pendingUpdate) {
+        sharedPool.release(this._pendingUpdate.payload)
+        this._pendingUpdate = null
+      }
+      return
+    }
     this._stateFlags &= ~STATE.UPDATE_SCHEDULED
     this._voiceFlushTimer = null
 

package/build/structures/ConnectionRecovery.js

@@ -9,6 +9,7 @@ class ConnectionRecovery {
     this.RECONNECT_DELAY = deps.RECONNECT_DELAY
     this.MAX_RECONNECT_ATTEMPTS = deps.MAX_RECONNECT_ATTEMPTS
     this.RESUME_BACKOFF_MAX = deps.RESUME_BACKOFF_MAX
+    this.sharedPool = deps.sharedPool
   }
 
   setServerUpdate(data) {
@@ -153,7 +154,7 @@ class ConnectionRecovery {
       `Attempt resume: guild=${conn._guildId} endpoint=${conn.endpoint} session=${conn.sessionId}`
     )
 
-    const payload = sharedPool.acquire()
+    const payload = this.sharedPool.acquire()
     try {
       this._functions.fillVoicePayload(
         payload,
@@ -163,6 +164,14 @@ class ConnectionRecovery {
         true
       )
 
+      if (conn._destroyed || !conn._player || conn._player.destroyed) {
+        conn._aqua.emit(
+          AqualinkEvents.Debug,
+          `Resume aborted: player destroyed during attempt for guild ${conn._guildId}`
+        )
+        return false
+      }
+
       if (conn._stateGeneration !== currentGen) {
         conn._aqua.emit(
           AqualinkEvents.Debug,
@@ -178,6 +187,10 @@ class ConnectionRecovery {
         })
       }
 
+      if (conn._destroyed || conn._player?.destroyed) {
+        return false
+      }
+
       conn._reconnectAttempts = 0
       conn._consecutiveFailures = 0
       if (conn._player) conn._player._resuming = false
@@ -189,10 +202,17 @@ class ConnectionRecovery {
       return true
     } catch (error) {
       if (conn._destroyed || !conn._aqua) throw error
+      if (conn._player?.destroyed) {
+        conn._aqua.emit(
+          AqualinkEvents.Debug,
+          `Resume aborted: player destroyed during retry for guild ${conn._guildId}`
+        )
+        return false
+      }
       conn._consecutiveFailures++
       conn._aqua.emit(
         AqualinkEvents.Debug,
-        `Resume failed for guild ${conn._guildId}: ${error?.message || error}`
+        `Resume failed for guild ${conn._guildId} (sessionId=${conn.sessionId || 'none'}, endpoint=${conn.endpoint || 'none'}): ${error?.message || error}`
       )
       if (conn._aqua?.debugTrace) {
         conn._aqua._trace('connection.resume.error', {
@@ -204,7 +224,8 @@ class ConnectionRecovery {
       if (
         conn._reconnectAttempts < this.MAX_RECONNECT_ATTEMPTS &&
         !conn._destroyed &&
-        conn._consecutiveFailures < 5
+        conn._consecutiveFailures < 5 &&
+        !conn._player?.destroyed
       ) {
         const delay = Math.min(
           this.RECONNECT_DELAY * (1 << (conn._reconnectAttempts - 1)),
@@ -222,7 +243,7 @@ class ConnectionRecovery {
       return false
     } finally {
       conn._stateFlags &= ~this.STATE.ATTEMPTING_RESUME
-      sharedPool.release(payload)
+      this.sharedPool.release(payload)
     }
   }
 
@@ -265,7 +286,10 @@ class ConnectionRecovery {
         return false
       })
       if (resumed) {
-        conn._player?._clearVoiceRecovery?.(recoveryToken, 'missing_player_resumed')
+        conn._player?._clearVoiceRecovery?.(
+          recoveryToken,
+          'missing_player_resumed'
+        )
       } else if (conn._player?._isVoiceRecoveryActive?.(recoveryToken)) {
         conn.resendVoiceUpdate(true)
       }
@@ -306,8 +330,12 @@ class ConnectionRecovery {
 
   async sendUpdate(payload) {
     const conn = this.connection
-    if (conn._destroyed) throw new Error('Connection destroyed')
-    if (!conn._rest) throw new Error('REST interface unavailable')
+    if (conn._destroyed)
+      throw new Error(`Connection destroyed (guild=${conn._guildId})`)
+    if (!conn._rest)
+      throw new Error(
+        `REST interface unavailable (guild=${conn._guildId}, sessionId=${conn.sessionId || 'none'})`
+      )
 
     try {
       if (conn._aqua?.debugTrace) {
@@ -342,7 +370,7 @@ class ConnectionRecovery {
         if (conn._aqua) {
           conn._aqua.emit(
             AqualinkEvents.Debug,
-            `[Aqua/Connection] Player ${conn._guildId} not found (404)${isSessionError ? ' - Session invalid' : ''}. Recovery failed, destroying.`
+            `[Aqua/Connection] Player ${conn._guildId} not found (404, sessionId=${conn.sessionId || 'none'}, endpoint=${conn.endpoint || 'none'})${isSessionError ? ' - Session invalid' : ''}. Recovery failed, destroying.`
           )
           await conn._aqua.destroyPlayer(conn._guildId)
         }
@@ -359,40 +387,4 @@ class ConnectionRecovery {
   }
 }
 
-class PayloadPool {
-  constructor() {
-    this._pool = []
-    this._size = 0
-  }
-
-  _create() {
-    return {
-      guildId: null,
-      data: {
-        voice: {
-          token: null,
-          endpoint: null,
-          sessionId: null
-        },
-        volume: null
-      }
-    }
-  }
-
-  acquire() {
-    return this._size > 0 ? this._pool[--this._size] : this._create()
-  }
-
-  release(payload) {
-    if (!payload || this._size >= 12) return
-    payload.guildId = null
-    const v = payload.data.voice
-    v.token = v.endpoint = v.sessionId = null
-    payload.data.volume = null
-    this._pool[this._size++] = payload
-  }
-}
-
-const sharedPool = new PayloadPool()
-
 module.exports = ConnectionRecovery

package/build/structures/Filters.js

@@ -202,7 +202,8 @@ class Filters {
   }
 
   _scheduleUpdate() {
-    if (this._pendingUpdate || !this.player) return this
+    if (this._pendingUpdate || !this.player || this.player.destroyed)
+      return this
     this._pendingUpdate = true
     queueMicrotask(() => {
       this._pendingUpdate = false
@@ -398,6 +399,7 @@ class Filters {
   }
 
   async updateFilters() {
+    this._pendingUpdate = false
     if (!this.player || !this._dirty.size) return this
 
     const dirtyKeys = [...this._dirty]