aqualink 2.17.2 → 2.17.3

package/build/structures/Aqua.js

@@ -2,12 +2,12 @@
 
 const fs = require('node:fs')
 const readline = require('node:readline')
-const {EventEmitter} = require('tseep')
-const {AqualinkEvents} = require('./AqualinkEvents')
+const { EventEmitter } = require('tseep')
+const { AqualinkEvents } = require('./AqualinkEvents')
 const Node = require('./Node')
 const Player = require('./Player')
 const Track = require('./Track')
-const {version: pkgVersion} = require('../../package.json')
+const { version: pkgVersion } = require('../../package.json')
 
 const SEARCH_PREFIX = ':'
 const EMPTY_ARRAY = Object.freeze([])
@@ -33,7 +33,6 @@ const MAX_REBUILD_LOCKS = 100
 const WRITE_BUFFER_SIZE = 100
 const MAX_QUEUE_SAVE = 10
 const MAX_TRACKS_RESTORE = 20
-const URL_PATTERN = /^https?:\/\//i
 
 const DEFAULT_OPTIONS = Object.freeze({
   shouldDeleteMessage: false,
@@ -56,11 +55,17 @@ const DEFAULT_OPTIONS = Object.freeze({
   })
 })
 
-// Shared helper functions
 const _functions = {
-  delay: ms => new Promise(r => setTimeout(r, ms)),
-  noop: () => {},
-  isUrl: query => typeof query === 'string' && query.length > 8 && URL_PATTERN.test(query),
+  delay: ms => new Promise(r => {
+    const t = setTimeout(r, ms)
+    t.unref?.()
+  }),
+  noop: () => { },
+  isUrl: query => {
+    if (typeof query !== 'string' || query.length <= 8) return false
+    const q = query.trimStart()
+    return q.startsWith('http://') || q.startsWith('https://')
+  },
   formatQuery(query, source) {
     return this.isUrl(query) ? query : `${source}${SEARCH_PREFIX}${query}`
   },
@@ -69,12 +74,17 @@ const _functions = {
     try {
       const result = fn()
       return result?.then ? result.catch(this.noop) : result
-    } catch {}
+    } catch { }
   },
   parseRequester(str) {
     if (!str || typeof str !== 'string') return null
     const i = str.indexOf(':')
-    return i > 0 ? {id: str.substring(0, i), username: str.substring(i + 1)} : null
+    return i > 0 ? { id: str.substring(0, i), username: str.substring(i + 1) } : null
+  },
+  unrefTimeout: (fn, ms) => {
+    const t = setTimeout(fn, ms)
+    t.unref?.()
+    return t
   }
 }
 
@@ -92,9 +102,9 @@ class Aqua extends EventEmitter {
     this.initiated = false
     this.version = pkgVersion
 
-    const merged = {...DEFAULT_OPTIONS, ...options}
+    const merged = { ...DEFAULT_OPTIONS, ...options }
     this.options = merged
-    this.failoverOptions = {...DEFAULT_OPTIONS.failoverOptions, ...options.failoverOptions}
+    this.failoverOptions = { ...DEFAULT_OPTIONS.failoverOptions, ...options.failoverOptions }
 
     this.shouldDeleteMessage = merged.shouldDeleteMessage
     this.defaultSearchPlatform = merged.defaultSearchPlatform
@@ -149,13 +159,13 @@ class Aqua extends EventEmitter {
           this._performCleanup()
         })
       },
-      onNodeReady: (node, {resumed}) => {
+      onNodeReady: (node, { resumed }) => {
         if (!resumed) return
         const batch = []
         for (const player of this.players.values()) {
           if (player.nodes === node && player.connection) batch.push(player)
         }
-        if (batch.length) queueMicrotask(() => batch.forEach(p => p.connection.resendVoiceUpdate({resume: true})))
+        if (batch.length) queueMicrotask(() => batch.forEach(p => p.connection.resendVoiceUpdate()))
       }
     }
     this.on(AqualinkEvents.NodeConnect, this._eventHandlers.onNodeConnect)
@@ -171,8 +181,10 @@ class Aqua extends EventEmitter {
       this._eventHandlers = null
     }
     this.removeAllListeners()
-    this.nodeMap.forEach(node => this._destroyNode(node.name || node.host))
-    this.players.forEach(player => _functions.safeCall(() => player.destroy()))
+
+    for (const id of Array.from(this.nodeMap.keys())) this._destroyNode(id)
+    for (const player of Array.from(this.players.values())) _functions.safeCall(() => player.destroy())
+
     this.players.clear()
     this._nodeStates.clear()
     this._failoverQueue.clear()
@@ -220,7 +232,7 @@ class Aqua extends EventEmitter {
       (stats.playingPlayers || 0) * 0.75 +
       (stats.memory ? stats.memory.used / reservable : 0) * 40 +
       (node.rest?.calls || 0) * 0.001
-    this._nodeLoadCache.set(id, {load, time: now})
+    this._nodeLoadCache.set(id, { load, time: now })
     if (this._nodeLoadCache.size > MAX_CACHE_SIZE) {
       const first = this._nodeLoadCache.keys().next().value
       this._nodeLoadCache.delete(first)
@@ -233,7 +245,7 @@ class Aqua extends EventEmitter {
     this.clientId = clientId
     if (!this.clientId) return this
     const results = await Promise.allSettled(
-      this.nodes.map(n => Promise.race([this._createNode(n), _functions.delay(NODE_TIMEOUT).then(() => {throw new Error('Timeout')})]))
+      this.nodes.map(n => Promise.race([this._createNode(n), _functions.delay(NODE_TIMEOUT).then(() => { throw new Error('Timeout') })]))
     )
     if (!results.some(r => r.status === 'fulfilled')) throw new Error('No nodes connected')
     if (this.plugins?.length) {
@@ -249,10 +261,10 @@ class Aqua extends EventEmitter {
     const node = new Node(this, options, this.options)
     node.players = new Set()
     this.nodeMap.set(id, node)
-    this._nodeStates.set(id, {connected: false, failoverInProgress: false})
+    this._nodeStates.set(id, { connected: false, failoverInProgress: false })
     try {
       await node.connect()
-      this._nodeStates.set(id, {connected: true, failoverInProgress: false})
+      this._nodeStates.set(id, { connected: true, failoverInProgress: false })
       this._invalidateCache()
       this.emit(AqualinkEvents.NodeCreate, node)
       return node
@@ -304,7 +316,7 @@ class Aqua extends EventEmitter {
     const now = Date.now()
     for (const [guildId, state] of this._brokenPlayers) {
       if (state.originalNodeId === id && (now - state.brokenAt) < BROKEN_PLAYER_TTL) {
-        rebuilds.push({guildId, state})
+        rebuilds.push({ guildId, state })
       }
     }
     if (!rebuilds.length) return
@@ -312,7 +324,7 @@ class Aqua extends EventEmitter {
     for (let i = 0; i < rebuilds.length; i += MAX_CONCURRENT_OPS) {
       const batch = rebuilds.slice(i, i + MAX_CONCURRENT_OPS)
       const results = await Promise.allSettled(
-        batch.map(({guildId, state}) => this._rebuildPlayer(state, node).then(() => guildId))
+        batch.map(({ guildId, state }) => this._rebuildPlayer(state, node).then(() => guildId))
       )
       for (const r of results) {
         if (r.status === 'fulfilled') successes.push(r.value)
@@ -324,7 +336,7 @@ class Aqua extends EventEmitter {
   }
 
   async _rebuildPlayer(state, targetNode) {
-    const {guildId, textChannel, voiceChannel, current, volume = 65, deaf = true} = state
+    const { guildId, textChannel, voiceChannel, current, volume = 65, deaf = true } = state
     const lockKey = `rebuild_${guildId}`
     if (this._rebuildLocks.has(lockKey)) return
     this._rebuildLocks.add(lockKey)
@@ -333,11 +345,11 @@ class Aqua extends EventEmitter {
         await this.destroyPlayer(guildId)
         await _functions.delay(RECONNECT_DELAY)
       }
-      const player = this.createPlayer(targetNode, {guildId, textChannel, voiceChannel, defaultVolume: volume, deaf})
+      const player = this.createPlayer(targetNode, { guildId, textChannel, voiceChannel, defaultVolume: volume, deaf })
       if (current && player?.queue?.add) {
         player.queue.add(current)
         await player.play()
-        if (state.position > 0) setTimeout(() => player.seek?.(state.position), SEEK_DELAY)
+        if (state.position > 0) _functions.unrefTimeout(() => player.seek?.(state.position), SEEK_DELAY)
         if (state.paused) player.pause(true)
       }
       return player
@@ -357,7 +369,7 @@ class Aqua extends EventEmitter {
     const attempts = this._failoverQueue.get(id) || 0
     if (attempts >= this.failoverOptions.maxFailoverAttempts) return
 
-    this._nodeStates.set(id, {connected: false, failoverInProgress: true})
+    this._nodeStates.set(id, { connected: false, failoverInProgress: true })
     this._lastFailoverAttempt.set(id, now)
     this._failoverQueue.set(id, attempts + 1)
 
@@ -379,7 +391,7 @@ class Aqua extends EventEmitter {
     } catch (error) {
       this.emit(AqualinkEvents.Error, null, error)
     } finally {
-      this._nodeStates.set(id, {connected: false, failoverInProgress: false})
+      this._nodeStates.set(id, { connected: false, failoverInProgress: false })
     }
   }
 
@@ -403,7 +415,7 @@ class Aqua extends EventEmitter {
     for (let i = 0; i < players.length; i += MAX_CONCURRENT_OPS) {
       const batch = players.slice(i, i + MAX_CONCURRENT_OPS)
       const batchResults = await Promise.allSettled(batch.map(p => this._migratePlayer(p, pickNode)))
-      for (const r of batchResults) results.push({success: r.status === 'fulfilled', error: r.reason})
+      for (const r of batchResults) results.push({ success: r.status === 'fulfilled', error: r.reason })
     }
     return results
   }
@@ -411,7 +423,7 @@ class Aqua extends EventEmitter {
   async _migratePlayer(player, pickNode) {
     const state = this._capturePlayerState(player)
     if (!state) throw new Error('Failed to capture state')
-    const {maxRetries, retryDelay} = this.failoverOptions
+    const { maxRetries, retryDelay } = this.failoverOptions
     for (let retry = 0; retry < maxRetries; retry++) {
       try {
         const targetNode = pickNode()
@@ -462,10 +474,10 @@ class Aqua extends EventEmitter {
     }
     if (state.queue?.length && newPlayer.queue?.add) newPlayer.queue.add(...state.queue)
     if (state.current && this.failoverOptions.preservePosition) {
-      newPlayer.queue?.add?.(state.current, {toFront: true})
+      newPlayer.queue?.add?.(state.current, { toFront: true })
       if (this.failoverOptions.resumePlayback) {
         ops.push(newPlayer.play())
-        if (state.position > 0) setTimeout(() => newPlayer.seek?.(state.position), SEEK_DELAY)
+        if (state.position > 0) _functions.unrefTimeout(() => newPlayer.seek?.(state.position), SEEK_DELAY)
         if (state.paused) ops.push(newPlayer.pause(true))
       }
     }
@@ -474,7 +486,7 @@ class Aqua extends EventEmitter {
     await Promise.allSettled(ops)
   }
 
-  updateVoiceState({d, t}) {
+  updateVoiceState({ d, t }) {
     if (!d?.guild_id || (t !== 'VOICE_STATE_UPDATE' && t !== 'VOICE_SERVER_UPDATE')) return
     const player = this.players.get(d.guild_id)
     if (!player || !player.nodes?.connected) return
@@ -540,7 +552,7 @@ class Aqua extends EventEmitter {
     await _functions.safeCall(() => player.destroy())
   }
 
-  async resolve({query, source, requester, nodes}) {
+  async resolve({ query, source, requester, nodes }) {
     if (!this.initiated) throw new Error('Aqua not initialized')
     const node = this._getRequestNode(nodes)
     if (!node) throw new Error('No nodes available')
@@ -581,8 +593,8 @@ class Aqua extends EventEmitter {
   }
 
   _constructResponse(response, requester, node) {
-    const {loadType, data, pluginInfo: rootPlugin} = response || {}
-    const base = {loadType, exception: null, playlistInfo: null, pluginInfo: rootPlugin || {}, tracks: []}
+    const { loadType, data, pluginInfo: rootPlugin } = response || {}
+    const base = { loadType, exception: null, playlistInfo: null, pluginInfo: rootPlugin || {}, tracks: [] }
     if (loadType === 'error' || loadType === 'LOAD_FAILED') {
       base.exception = data || response.exception || null
       return base
@@ -599,7 +611,7 @@ class Aqua extends EventEmitter {
           ...info
         }
       }
-      base.pluginInfo = data.pluginInfo || base.pluginInfo
+      base.pluginInfo = data.pluginInfo || rootPlugin || base.pluginInfo
       base.tracks = Array.isArray(data.tracks) ? data.tracks.map(t => _functions.makeTrack(t, requester, node)) : []
     } else if (loadType === 'search') {
       base.tracks = Array.isArray(data) ? data.map(t => _functions.makeTrack(t, requester, node)) : []
@@ -616,7 +628,7 @@ class Aqua extends EventEmitter {
   async search(query, requester, source) {
     if (!query || !requester) return null
     try {
-      const {tracks} = await this.resolve({query, source: source || this.defaultSearchPlatform, requester})
+      const { tracks } = await this.resolve({ query, source: source || this.defaultSearchPlatform, requester })
       return tracks || null
     } catch {
       return null
@@ -628,8 +640,8 @@ class Aqua extends EventEmitter {
     const tempFile = `${filePath}.tmp`
     let ws = null
     try {
-      await fs.promises.writeFile(lockFile, String(process.pid), {flag: 'wx'})
-      ws = fs.createWriteStream(tempFile, {encoding: 'utf8', flags: 'w'})
+      await fs.promises.writeFile(lockFile, String(process.pid), { flag: 'wx' })
+      ws = fs.createWriteStream(tempFile, { encoding: 'utf8', flags: 'w' })
       const buffer = []
       let drainPromise = Promise.resolve()
 
@@ -680,11 +692,11 @@ class Aqua extends EventEmitter {
     let stream = null, rl = null
     try {
       await fs.promises.access(filePath)
-      await fs.promises.writeFile(lockFile, String(process.pid), {flag: 'wx'})
+      await fs.promises.writeFile(lockFile, String(process.pid), { flag: 'wx' })
       await this._waitForFirstNode()
 
-      stream = fs.createReadStream(filePath, {encoding: 'utf8'})
-      rl = readline.createInterface({input: stream, crlfDelay: Infinity})
+      stream = fs.createReadStream(filePath, { encoding: 'utf8' })
+      rl = readline.createInterface({ input: stream, crlfDelay: Infinity })
 
       const batch = []
       for await (const line of rl) {
@@ -719,7 +731,7 @@ class Aqua extends EventEmitter {
       player._resuming = !!p.resuming
       const requester = _functions.parseRequester(p.r)
       const tracksToResolve = [p.u, ...(p.q || [])].filter(Boolean).slice(0, MAX_TRACKS_RESTORE)
-      const resolved = await Promise.all(tracksToResolve.map(uri => this.resolve({query: uri, requester}).catch(() => null)))
+      const resolved = await Promise.all(tracksToResolve.map(uri => this.resolve({ query: uri, requester }).catch(() => null)))
       const validTracks = resolved.flatMap(r => r?.tracks || [])
       if (validTracks.length && player.queue?.add) {
         if (player.queue.length <= 2) player.queue.length = 0
@@ -731,14 +743,14 @@ class Aqua extends EventEmitter {
           else player.volume = p.vol
         }
         await player.play()
-        if (p.p > 0) setTimeout(() => player.seek?.(p.p), SEEK_DELAY)
+        if (p.p > 0) _functions.unrefTimeout(() => player.seek?.(p.p), SEEK_DELAY)
         if (p.pa) await player.pause(true)
       }
       if (p.nw && p.t) {
         const channel = this.client.channels?.cache?.get(p.t)
         if (channel?.messages) player.nowPlayingMessage = await channel.messages.fetch(p.nw).catch(() => null)
       }
-    } catch {}
+    } catch { }
   }
 
   async _waitForFirstNode(timeout = NODE_TIMEOUT) {
@@ -756,6 +768,7 @@ class Aqua extends EventEmitter {
         if (this.leastUsedNodes.length) { cleanup(); resolve() }
       }
       const timer = setTimeout(() => { cleanup(); reject(new Error('Timeout waiting for first node')) }, timeout)
+      timer.unref?.()
       this.on(AqualinkEvents.NodeConnect, onReady)
       this.on(AqualinkEvents.NodeCreate, onReady)
       onReady()

package/build/structures/Connection.js

@@ -4,11 +4,17 @@ const { AqualinkEvents } = require('./AqualinkEvents')
 
 const POOL_SIZE = 12
 const UPDATE_TIMEOUT = 4000
+
 const RECONNECT_DELAY = 1000
 const MAX_RECONNECT_ATTEMPTS = 3
 const RESUME_BACKOFF_MAX = 8000
+
 const VOICE_DATA_TIMEOUT = 30000
 
+const VOICE_FLUSH_DELAY = 50
+
+const NULL_CHANNEL_GRACE_MS = 1500
+
 const STATE = {
   CONNECTED: 1,
   UPDATE_SCHEDULED: 64,
@@ -53,6 +59,7 @@ const _functions = {
     v.token = conn.token
     v.endpoint = conn.endpoint
     v.sessionId = conn.sessionId
+    v.channelId = player.voiceChannel
     v.resume = resume ? true : undefined
     v.sequence = resume ? conn.sequence : undefined
     payload.data.volume = player?.volume ?? 100
@@ -110,19 +117,28 @@ class Connection {
 
     this.voiceChannel = player.voiceChannel
     this.sessionId = null
+    this.channelId = null
     this.endpoint = null
     this.token = null
     this.region = null
     this.sequence = 0
 
     this._lastEndpoint = null
-    this._pendingUpdate = null
     this._stateFlags = 0
     this._reconnectAttempts = 0
     this._destroyed = false
     this._reconnectTimer = null
     this._lastVoiceDataUpdate = 0
     this._consecutiveFailures = 0
+
+    this._voiceFlushTimer = null
+    this._pendingUpdate = null
+    this._lastSentVoiceKey = ''
+
+    this._nullChannelTimer = null
+
+    this._lastStateReqAt = 0
+    this._stateGeneration = 0
   }
 
   _hasValidVoiceData() {
@@ -134,10 +150,17 @@ class Connection {
     return true
   }
 
-  _canAttemptResume() {
-    if (this._destroyed || this._reconnectAttempts >= MAX_RECONNECT_ATTEMPTS) return false
+  _clearNullChannelTimer() {
+    if (!this._nullChannelTimer) return
+    clearTimeout(this._nullChannelTimer)
+    this._nullChannelTimer = null
+  }
+
+  _canAttemptResumeCore() {
+    if (this._destroyed) return false
+    if (this._reconnectAttempts >= MAX_RECONNECT_ATTEMPTS) return false
     if (this._stateFlags & (STATE.ATTEMPTING_RESUME | STATE.DISCONNECTING)) return false
-    return this._hasValidVoiceData() || !!this._player?._resuming
+    return true
   }
 
   _setReconnectTimer(delay) {
@@ -148,12 +171,15 @@ class Connection {
   }
 
   setServerUpdate(data) {
-    if (this._destroyed || !data?.endpoint || !data.token) return
+    if (this._destroyed || !data?.token) return
 
     const endpoint = typeof data.endpoint === 'string' ? data.endpoint.trim() : ''
-    if (!endpoint || typeof data.token !== 'string' || !data.token) return
+    if (!endpoint) return
+
     if (this._lastEndpoint === endpoint && this.token === data.token) return
 
+    this._stateGeneration++
+
     if (this._lastEndpoint !== endpoint) {
       this.sequence = 0
       this._lastEndpoint = endpoint
@@ -164,10 +190,11 @@ class Connection {
     this.endpoint = endpoint
     this.region = _functions.extractRegion(endpoint)
     this.token = data.token
+    this.channelId = data.channel_id || this.channelId || this.voiceChannel
     this._lastVoiceDataUpdate = Date.now()
     this._stateFlags &= ~STATE.VOICE_DATA_STALE
 
-    if (this._player.paused) this._player.pause(false)
+    if (this._player?.paused) this._player.pause(false)
     this._scheduleVoiceUpdate()
   }
 
@@ -181,15 +208,38 @@ class Connection {
     if (this._destroyed || !data || data.user_id !== this._clientId) return
 
     const { session_id: sessionId, channel_id: channelId, self_deaf: selfDeaf, self_mute: selfMute } = data
+    const p = this._player
 
-    if (!channelId) return this._handleDisconnect()
+    if (channelId) this._clearNullChannelTimer()
+
+    const reqCh = p?._voiceRequestChannel
+    const reqFresh = !!(reqCh && (Date.now() - (p._voiceRequestAt || 0)) < 5000)
+
+    if (!channelId) {
+      if (reqFresh) return
+
+      if (!this._nullChannelTimer) {
+        this._nullChannelTimer = setTimeout(() => {
+          this._nullChannelTimer = null
+          this._handleDisconnect()
+        }, NULL_CHANNEL_GRACE_MS)
+        _functions.safeUnref(this._nullChannelTimer)
+      }
+      return
+    }
+
+    if (reqFresh && channelId !== reqCh) return
+
+    if (reqCh && channelId === reqCh) {
+      p._voiceRequestChannel = null
+    }
 
     let needsUpdate = false
 
     if (this.voiceChannel !== channelId) {
       this._aqua.emit(AqualinkEvents.PlayerMove, this.voiceChannel, channelId)
       this.voiceChannel = channelId
-      this._player.voiceChannel = channelId
+      p.voiceChannel = channelId
       needsUpdate = true
     }
 
@@ -202,30 +252,29 @@ class Connection {
       needsUpdate = true
     }
 
-    this._player.connection.sessionId = sessionId || this._player.connection.sessionId
-    this._player.self_deaf = this._player.selfDeaf = !!selfDeaf
-    this._player.self_mute = this._player.selfMute = !!selfMute
-    this._player.connected = true
+    p.self_deaf = p.selfDeaf = !!selfDeaf
+    p.self_mute = p.selfMute = !!selfMute
     this._stateFlags |= STATE.CONNECTED
 
     if (needsUpdate) this._scheduleVoiceUpdate()
   }
 
   _handleDisconnect() {
-    if (this._destroyed || !(this._stateFlags & STATE.CONNECTED)) return
+    if (this._destroyed) return
 
     this._stateFlags = (this._stateFlags | STATE.DISCONNECTING) & ~STATE.CONNECTED
-    this._player.connected = false
+    this._clearNullChannelTimer()
     this._clearPendingUpdate()
     this._clearReconnectTimer()
 
-    this.voiceChannel = this.sessionId = null
+    this.voiceChannel = null
+    this.sessionId = null
     this.sequence = 0
     this._lastVoiceDataUpdate = 0
     this._stateFlags |= STATE.VOICE_DATA_STALE
 
     try {
-      this._player.destroy?.()
+      this._player?.destroy?.()
     } catch (e) {
       this._aqua.emit(AqualinkEvents.Debug, new Error(`Player destroy failed: ${e?.message || e}`))
     } finally {
@@ -235,6 +284,10 @@ class Connection {
 
   _requestVoiceState() {
     try {
+      const now = Date.now()
+      if (now - (this._lastStateReqAt || 0) < 1500) return false
+      this._lastStateReqAt = now
+
       if (typeof this._player?.send !== 'function' || !this._player.voiceChannel) return false
       this._player.send({
         guild_id: this._guildId,
@@ -242,7 +295,6 @@ class Connection {
         self_deaf: this._player.deaf,
         self_mute: this._player.mute
       })
-      this._setReconnectTimer(1500)
       return true
     } catch {
       return false
@@ -250,47 +302,38 @@ class Connection {
   }
 
   async attemptResume() {
-    if (!this._canAttemptResume()) {
-      this._aqua.emit(
-        AqualinkEvents.Debug,
-        `Resume blocked: destroyed=${this._destroyed}, hasValidData=${this._hasValidVoiceData()}, attempts=${this._reconnectAttempts}/${MAX_RECONNECT_ATTEMPTS}`
-      )
-
-      const isResuming = this._player?._resuming
-      const isStale = this._stateFlags & STATE.VOICE_DATA_STALE
-      const needsVoiceData = !this.sessionId || !this.endpoint || !this.token
-
-      if ((isStale || needsVoiceData) && isResuming) {
-        this._aqua.emit(AqualinkEvents.Debug, `Requesting fresh voice state for guild ${this._guildId}`)
-        this._requestVoiceState()
-      } else if (this._reconnectAttempts >= MAX_RECONNECT_ATTEMPTS) {
-        this._handleDisconnect()
-      }
-      return false
-    }
+    if (!this._canAttemptResumeCore()) return false
+
+    const currentGen = this._stateGeneration
 
-    if ((!this.sessionId || !this.endpoint || !this.token) && this._player?._resuming) {
-      this._aqua.emit(AqualinkEvents.Debug, `Resuming player but voice data missing for guild ${this._guildId}`)
+
+    if (!this.sessionId || !this.endpoint || !this.token || (this._stateFlags & STATE.VOICE_DATA_STALE)) {
+      this._aqua.emit(AqualinkEvents.Debug, `Resume blocked: missing voice data for guild ${this._guildId}, requesting voice state`)
       this._requestVoiceState()
       return false
     }
 
     this._stateFlags |= STATE.ATTEMPTING_RESUME
     this._reconnectAttempts++
-    this._aqua.emit(
-      AqualinkEvents.Debug,
-      `Attempt resume: guild=${this._guildId} endpoint=${this.endpoint} session=${this.sessionId}`
-    )
+    this._aqua.emit(AqualinkEvents.Debug, `Attempt resume: guild=${this._guildId} endpoint=${this.endpoint} session=${this.sessionId}`)
 
     const payload = sharedPool.acquire()
     try {
       _functions.fillVoicePayload(payload, this._guildId, this, this._player, true)
+
+      if (this._stateGeneration !== currentGen) {
+        this._aqua.emit(AqualinkEvents.Debug, `Resume aborted: State changed during attempt for guild ${this._guildId}`)
+        return false
+      }
+
+
       await this._sendUpdate(payload)
 
       this._reconnectAttempts = 0
       this._consecutiveFailures = 0
       if (this._player) this._player._resuming = false
-      this._aqua.emit(AqualinkEvents.Debug, `Resume successful for guild ${this._guildId}`)
+
+      this._aqua.emit(AqualinkEvents.Debug, `Resume PATCH sent for guild ${this._guildId}`)
       return true
     } catch (e) {
       this._consecutiveFailures++
@@ -300,7 +343,7 @@ class Connection {
         const delay = Math.min(RECONNECT_DELAY * (1 << (this._reconnectAttempts - 1)), RESUME_BACKOFF_MAX)
         this._setReconnectTimer(delay)
       } else {
-        this._aqua.emit(AqualinkEvents.Debug, `Max reconnect attempts or failures reached for guild ${this._guildId}`)
+        this._aqua.emit(AqualinkEvents.Debug, `Max reconnect attempts/failures reached for guild ${this._guildId}`)
         if (this._player) this._player._resuming = false
         this._handleDisconnect()
       }
@@ -330,36 +373,64 @@ class Connection {
     this._stateFlags &= ~STATE.UPDATE_SCHEDULED
     if (this._pendingUpdate?.payload) sharedPool.release(this._pendingUpdate.payload)
     this._pendingUpdate = null
+    if (this._voiceFlushTimer) {
+      clearTimeout(this._voiceFlushTimer)
+      this._voiceFlushTimer = null
+    }
   }
 
-  _scheduleVoiceUpdate() {
-    if (this._destroyed || !this._hasValidVoiceData() || (this._stateFlags & STATE.UPDATE_SCHEDULED)) return
-
-    this._clearPendingUpdate()
+  _makeVoiceKey() {
+    const p = this._player
+    const vol = p?.volume ?? 100
+    return (this.sessionId || '') + '|' +
+      (this.token || '') + '|' +
+      (this.endpoint || '') + '|' +
+      (p?.voiceChannel || '') + '|' +
+      vol
+  }
 
-    const payload = sharedPool.acquire()
-    _functions.fillVoicePayload(payload, this._guildId, this, this._player, false)
+  _scheduleVoiceUpdate() {
+    if (this._destroyed) return
+    if (!this._hasValidVoiceData()) return
+
+    if (!this._pendingUpdate) {
+      const payload = sharedPool.acquire()
+      _functions.fillVoicePayload(payload, this._guildId, this, this._player, false)
+      this._pendingUpdate = { payload, timestamp: Date.now() }
+    } else {
+      this._pendingUpdate.timestamp = Date.now()
+      _functions.fillVoicePayload(this._pendingUpdate.payload, this._guildId, this, this._player, false)
+    }
 
-    this._pendingUpdate = { payload, timestamp: Date.now() }
+    if (this._stateFlags & STATE.UPDATE_SCHEDULED) return
     this._stateFlags |= STATE.UPDATE_SCHEDULED
-    queueMicrotask(() => this._executeVoiceUpdate())
+
+    this._voiceFlushTimer = setTimeout(() => this._executeVoiceUpdate(), VOICE_FLUSH_DELAY)
+    _functions.safeUnref(this._voiceFlushTimer)
   }
 
   _executeVoiceUpdate() {
     if (this._destroyed) return
     this._stateFlags &= ~STATE.UPDATE_SCHEDULED
+    this._voiceFlushTimer = null
 
     const pending = this._pendingUpdate
-    if (!pending) return
     this._pendingUpdate = null
 
+    if (!pending) return
     if (Date.now() - pending.timestamp > UPDATE_TIMEOUT) {
       sharedPool.release(pending.payload)
       return
     }
 
-    const payload = pending.payload
-    this._sendUpdate(payload).finally(() => sharedPool.release(payload))
+    const key = this._makeVoiceKey()
+    if (key === this._lastSentVoiceKey) {
+      sharedPool.release(pending.payload)
+      return
+    }
+    this._lastSentVoiceKey = key
+
+    this._sendUpdate(pending.payload).finally(() => sharedPool.release(pending.payload))
   }
 
   async _sendUpdate(payload) {
@@ -380,6 +451,7 @@ class Connection {
     if (this._destroyed) return
     this._destroyed = true
 
+    this._clearNullChannelTimer()
     this._clearPendingUpdate()
     this._clearReconnectTimer()
 

package/build/structures/Node.js

@@ -456,4 +456,4 @@ class Node {
   }
 }
 
-module.exports = Node
+module.exports = Node

package/build/structures/Player.js

@@ -193,6 +193,9 @@ class Player extends EventEmitter {
     this.previousTracks = new CircularBuffer(PREVIOUS_TRACKS_SIZE)
     this._updateBatcher = batcherPool.acquire(this)
 
+    this._voiceRequestAt = 0
+    this._voiceRequestChannel = null
+    this._suppressResumeUntil = 0
     this._bindEvents()
     this._startWatchdog()
   }
@@ -241,6 +244,7 @@ class Player extends EventEmitter {
         this._voiceDownSince = Date.now()
         this._createTimer(() => {
           if (this.connected || this.destroyed || this.nodes?.info?.isNodelink) return
+          if (Date.now() < (this._suppressResumeUntil || 0)) return
           this.connection.attemptResume()
         }, 1000)
       }
@@ -337,13 +341,24 @@ class Player extends EventEmitter {
 
   connect(options = {}) {
     if (this.destroyed) throw new Error('Cannot connect destroyed player')
+
     const voiceChannel = _functions.toId(options.voiceChannel || this.voiceChannel)
     if (!voiceChannel) throw new TypeError('Voice channel required')
+
     this.deaf = options.deaf !== undefined ? !!options.deaf : true
     this.mute = !!options.mute
     this.destroyed = false
+
+    this._voiceRequestAt = Date.now()
+    this._voiceRequestChannel = voiceChannel
+
     this.voiceChannel = voiceChannel
-    this.send({ guild_id: this.guildId, channel_id: voiceChannel, self_deaf: this.deaf, self_mute: this.mute })
+    this.send({
+      guild_id: this.guildId,
+      channel_id: voiceChannel,
+      self_deaf: this.deaf,
+      self_mute: this.mute
+    })
     return this
   }
 
@@ -432,6 +447,9 @@ class Player extends EventEmitter {
     this._dataStore = null
 
     if (this.current?.dispose && !this.aqua?.options?.autoResume) this.current.dispose()
+    if (this.connection) {
+      try { this.connection.destroy() } catch { }
+    }
     this.connection = this.filters = this.current = this.autoplaySeed = null
 
     if (!skipRemote) {
@@ -757,14 +775,20 @@ class Player extends EventEmitter {
     if (this.destroyed) return
     const code = payload?.code
 
-    if (code === 4022) {
+    if (code === 4014 || code === 4022) {
       this.aqua.emit(AqualinkEvents.SocketClosed, this, payload)
-      this.destroy()
+
+      this.connected = false
+      if (!this._voiceDownSince) this._voiceDownSince = Date.now()
+
+      if (code !== 4014) {
+        this._suppressResumeUntil = Date.now() + 3000
+      }
       return
     }
 
     if (code === 4015 && !this.nodes?.info?.isNodelink) {
-      try { await this._attemptVoiceResume(); return } catch { }
+      try { await this._attemptVoiceResume(); return } catch { /* ignore */ }
     }
 
     if (![4015, 4009, 4006].includes(code)) {
@@ -851,8 +875,6 @@ class Player extends EventEmitter {
   _handleAquaPlayerMove(oldChannel, newChannel) {
     if (_functions.toId(oldChannel) !== _functions.toId(this.voiceChannel)) return
     this.voiceChannel = _functions.toId(newChannel)
-    this.connected = !!newChannel
-    this.send({ guild_id: this.guildId, channel_id: this.voiceChannel, self_deaf: this.deaf, self_mute: this.mute })
   }
 
   send(data) {

package/build/structures/Rest.js

@@ -570,4 +570,4 @@ class Rest {
   }
 }
 
-module.exports = Rest
+module.exports = Rest

package/build/structures/Track.js

@@ -22,6 +22,7 @@ class Track {
     this.uri = _h.str(info.uri)
     this.sourceName = _h.str(info.sourceName)
     this.artworkUrl = _h.str(info.artworkUrl)
+    this.pluginInfo = info.pluginInfo || data.pluginInfo || {}
 
     this.playlist = data.playlist || null
     this.node = node || data.node || null
@@ -92,6 +93,7 @@ class Track {
     this.uri = fi.uri ?? this.uri
     this.sourceName = fi.sourceName ?? this.sourceName
     this.artworkUrl = fi.artworkUrl ?? this.artworkUrl
+    this.pluginInfo = fi.pluginInfo ?? found.pluginInfo ?? this.pluginInfo
     this.isSeekable = fi.isSeekable ?? this.isSeekable
     this.isStream = fi.isStream ?? this.isStream
     this.position = _h.num(fi.position, this.position)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aqualink",
-  "version": "2.17.2",
+  "version": "2.17.3",
   "description": "An Lavalink client, focused in pure performance and features",
   "main": "./build/index.js",
   "types": "./build/index.d.ts",
@@ -45,7 +45,7 @@
   },
   "homepage": "https://aqualink-6006388d.mintlify.app/",
   "dependencies": {
-    "ws": "^8.18.3",
+    "ws": "^8.19.0",
     "tseep": "^1.3.1"
   },
   "contributors": [