aqualink 2.17.3 → 2.18.0

package/build/structures/Aqua.js

@@ -52,7 +52,9 @@ const DEFAULT_OPTIONS = Object.freeze({
     resumePlayback: true,
     cooldownTime: 5000,
     maxFailoverAttempts: 5
-  })
+  }),
+  maxQueueSave: 10,
+  maxTracksRestore: 20
 })
 
 const _functions = {
@@ -118,6 +120,8 @@ class Aqua extends EventEmitter {
     this.allowedDomains = merged.allowedDomains || []
     this.loadBalancer = merged.loadBalancer
     this.useHttp2 = merged.useHttp2
+    this.maxQueueSave = merged.maxQueueSave
+    this.maxTracksRestore = merged.maxTracksRestore
     this.send = merged.send || this._createDefaultSend()
 
     this._nodeStates = new Map()
@@ -489,13 +493,18 @@ class Aqua extends EventEmitter {
   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
+    if (!player) return
+
+    d.txId = player.txId
     if (t === 'VOICE_STATE_UPDATE') {
       if (d.user_id !== this.clientId) return
-      if (!d.channel_id) return void this.destroyPlayer(d.guild_id)
       if (player.connection) {
-        player.connection.sessionId = d.session_id
-        player.connection.setStateUpdate(d)
+        if (!d.channel_id && player.connection.voiceChannel) {
+          player.connection.setStateUpdate(d)
+        } else {
+          player.connection.sessionId = d.session_id
+          player.connection.setStateUpdate(d)
+        }
       }
     } else {
       player.connection?.setServerUpdate(d)
@@ -515,7 +524,7 @@ class Aqua extends EventEmitter {
   createConnection(options) {
     if (!this.initiated) throw new Error('Aqua not initialized')
     const existing = this.players.get(options.guildId)
-    if (existing) {
+    if (existing && !existing.destroyed) {
       if (options.voiceChannel && existing.voiceChannel !== options.voiceChannel) {
         _functions.safeCall(() => existing.connect(options))
       }
@@ -528,7 +537,12 @@ class Aqua extends EventEmitter {
 
   createPlayer(node, options) {
     const existing = this.players.get(options.guildId)
-    if (existing) _functions.safeCall(() => existing.destroy())
+    if (existing) {
+      _functions.safeCall(() => existing.destroy({
+        preserveMessage: options.preserveMessage || !!options.resuming || false,
+        preserveTracks: !!options.resuming || false
+      }))
+    }
     const player = new Player(this, node, options)
     this.players.set(options.guildId, player)
     node?.players?.add?.(player)
@@ -654,7 +668,7 @@ class Aqua extends EventEmitter {
           u: player.current?.uri || null,
           p: player.position || 0,
           ts: player.timestamp || 0,
-          q: player.queue.slice(0, MAX_QUEUE_SAVE).map(tr => tr.uri),
+          q: player.queue.slice(0, this.maxQueueSave).map(tr => tr.uri),
           r: requester ? `${requester.id}:${requester.username}` : null,
           vol: player.volume,
           pa: player.paused,
@@ -730,7 +744,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 tracksToResolve = [p.u, ...(p.q || [])].filter(Boolean).slice(0, this.maxTracksRestore)
       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) {

package/build/structures/Connection.js

@@ -122,6 +122,7 @@ class Connection {
     this.token = null
     this.region = null
     this.sequence = 0
+    this.txId = 0
 
     this._lastEndpoint = null
     this._stateFlags = 0
@@ -136,6 +137,7 @@ class Connection {
     this._lastSentVoiceKey = ''
 
     this._nullChannelTimer = null
+    this.isWaitingForDisconnect = false
 
     this._lastStateReqAt = 0
     this._stateGeneration = 0
@@ -178,6 +180,8 @@ class Connection {
 
     if (this._lastEndpoint === endpoint && this.token === data.token) return
 
+    if (data.txId && data.txId < this.txId) return
+
     this._stateGeneration++
 
     if (this._lastEndpoint !== endpoint) {
@@ -212,12 +216,10 @@ class Connection {
 
     if (channelId) this._clearNullChannelTimer()
 
-    const reqCh = p?._voiceRequestChannel
-    const reqFresh = !!(reqCh && (Date.now() - (p._voiceRequestAt || 0)) < 5000)
+    if (data.txId && data.txId < this.txId) return
 
     if (!channelId) {
-      if (reqFresh) return
-
+      this.isWaitingForDisconnect = true
       if (!this._nullChannelTimer) {
         this._nullChannelTimer = setTimeout(() => {
           this._nullChannelTimer = null
@@ -228,16 +230,16 @@ class Connection {
       return
     }
 
-    if (reqFresh && channelId !== reqCh) return
+    this.isWaitingForDisconnect = false
 
-    if (reqCh && channelId === reqCh) {
-      p._voiceRequestChannel = null
-    }
+    if (p && p.txId > this.txId) this.txId = p.txId
 
     let needsUpdate = false
 
     if (this.voiceChannel !== channelId) {
-      this._aqua.emit(AqualinkEvents.PlayerMove, this.voiceChannel, channelId)
+      p._reconnecting = true
+      p._resuming = true
+      this._aqua.emit(AqualinkEvents.PlayerMove, p, this.voiceChannel, channelId)
       this.voiceChannel = channelId
       p.voiceChannel = channelId
       needsUpdate = true
@@ -313,6 +315,7 @@ class Connection {
       return false
     }
 
+    this.txId = this._player.txId || this.txId
     this._stateFlags |= STATE.ATTEMPTING_RESUME
     this._reconnectAttempts++
     this._aqua.emit(AqualinkEvents.Debug, `Attempt resume: guild=${this._guildId} endpoint=${this.endpoint} session=${this.sessionId}`)

package/build/structures/Filters.js

@@ -60,6 +60,7 @@ class Filters {
     if (!player) throw new Error('Player instance is required')
     this.player = player
     this._pendingUpdate = false
+    this._dirty = new Set()
 
 
     this.filters = {
@@ -102,6 +103,7 @@ class Filters {
     if (current && _utils.shallowEqual(current, defaults, options, keys)) return this
 
     this.filters[filterName] = Object.assign({}, defaults, options)
+    this._dirty.add(filterName)
     return this._scheduleUpdate()
   }
 
@@ -122,6 +124,7 @@ class Filters {
     const next = bands ?? EMPTY_ARRAY
     if (_utils.equalizerEqual(this.filters.equalizer, next)) return this
     this.filters.equalizer = next
+    this._dirty.add('equalizer')
     return this._scheduleUpdate()
   }
 
@@ -147,7 +150,17 @@ class Filters {
 
     this.presets.bassboost = value
     const gain = (value - 1) * (1.25 / 9) - 0.25
-    return this.setEqualizer(_utils.makeEqArray(13, gain))
+
+    const current = Array.isArray(this.filters.equalizer) ? [...this.filters.equalizer] : []
+    const bands = _utils.makeEqArray(13, gain)
+
+    for (const b of bands) {
+      const idx = current.findIndex(e => e.band === b.band)
+      if (idx !== -1) current[idx] = b
+      else current.push(b)
+    }
+
+    return this.setEqualizer(current)
   }
 
   setSlowmode(enabled, options = {}) {
@@ -182,14 +195,23 @@ class Filters {
     const f = this.filters
     let changed = false
 
-    if (f.volume !== 1) { f.volume = 1; changed = true }
-    if (!_utils.eqIsEmpty(f.equalizer)) { f.equalizer = EMPTY_ARRAY; changed = true }
+    if (f.volume !== 1) {
+      f.volume = 1
+      this._dirty.add('volume')
+      changed = true
+    }
+    if (!_utils.eqIsEmpty(f.equalizer)) {
+      f.equalizer = EMPTY_ARRAY
+      this._dirty.add('equalizer')
+      changed = true
+    }
 
     const filterNames = Object.keys(FILTER_DEFAULTS)
     for (let i = 0; i < filterNames.length; i++) {
       const key = filterNames[i]
       if (f[key] !== null) {
         f[key] = null
+        this._dirty.add(key)
         changed = true
       }
     }
@@ -202,10 +224,18 @@ class Filters {
   }
 
   async updateFilters() {
-    if (!this.player) return this
+    if (!this.player || !this._dirty.size) return this
+
+    const payload = {}
+    for (const key of this._dirty) {
+      payload[key] = this.filters[key]
+    }
+
+    this._dirty.clear()
+
     await this.player.nodes.rest.updatePlayer({
       guildId: this.player.guildId,
-      data: { filters: this.filters }
+      data: { filters: payload }
     })
     return this
   }

package/build/structures/Node.js

@@ -1,11 +1,16 @@
 'use strict'
 
-const WebSocket = require('ws')
+const IS_BUN = !!(process?.isBun || process?.versions?.bun || globalThis.Bun)
+if (process && typeof process.isBun !== 'boolean') process.isBun = IS_BUN
+
+const WebSocketImpl = process.isBun ? globalThis.WebSocket : require('ws')
+
 const Rest = require('./Rest')
 const { AqualinkEvents } = require('./AqualinkEvents')
 
 const privateData = new WeakMap()
 
+const NODE_STATE = Object.freeze({ IDLE: 0, CONNECTING: 1, READY: 2, DISCONNECTING: 3, RECONNECTING: 4 })
 const WS_STATES = Object.freeze({ CONNECTING: 0, OPEN: 1, CLOSING: 2, CLOSED: 3 })
 const FATAL_CLOSE_CODES = Object.freeze([4003, 4004, 4010, 4011, 4012, 4015])
 const WS_PATH = '/v4/websocket'
@@ -15,11 +20,12 @@ const OPS_READY = 'ready'
 const OPS_PLAYER_UPDATE = 'playerUpdate'
 const OPS_EVENT = 'event'
 
+const unrefTimer = (t) => { try { t?.unref?.() } catch {} }
+
 const _functions = {
   buildWsUrl(host, port, ssl) {
     const needsBrackets = host.includes(':') && !host.startsWith('[')
-    const h = needsBrackets ? `[${host}]` : host
-    return `ws${ssl ? 's' : ''}://${h}:${port}${WS_PATH}`
+    return `ws${ssl ? 's' : ''}://${needsBrackets ? `[${host}]` : host}:${port}${WS_PATH}`
   },
 
   isLyricsOp(op) {
@@ -30,8 +36,13 @@ const _functions = {
     if (!reason) return 'No reason provided'
     if (typeof reason === 'string') return reason
     if (Buffer.isBuffer(reason)) {
-      try { return reason.toString('utf8') }
-      catch { return String(reason) }
+      try { return reason.toString('utf8') } catch { return String(reason) }
+    }
+    if (reason instanceof ArrayBuffer) {
+      try { return Buffer.from(reason).toString('utf8') } catch { return String(reason) }
+    }
+    if (ArrayBuffer.isView(reason)) {
+      try { return Buffer.from(reason.buffer, reason.byteOffset, reason.byteLength).toString('utf8') } catch { return String(reason) }
     }
     if (typeof reason === 'object') return reason.message || reason.code || JSON.stringify(reason)
     return String(reason)
@@ -79,6 +90,7 @@ class Node {
     this.skipUTF8Validation = options.skipUTF8Validation ?? true
 
     this.connected = false
+    this.state = NODE_STATE.IDLE
     this.info = null
     this.ws = null
     this.reconnectAttempted = 0
@@ -87,6 +99,9 @@ class Node {
     this._isConnecting = false
     this.isNodelink = false
 
+    this._wsIsBun = !!process.isBun
+    this._bunCleanup = null
+
     this.stats = {
       players: 0,
       playingPlayers: 0,
@@ -113,13 +128,11 @@ class Node {
 
   _buildHeaders() {
     const headers = {
-      'Authorization': this.auth,
+      Authorization: this.auth,
       'User-Id': this.aqua.clientId,
       'Client-Name': this._clientName
     }
-    if (this.sessionId) {
-      headers['Session-Id'] = this.sessionId
-    }
+    if (this.sessionId) headers['Session-Id'] = this.sessionId
     return headers
   }
 
@@ -139,6 +152,7 @@ class Node {
 
   async _handleOpen() {
     this.connected = true
+    this.state = NODE_STATE.READY
     this._isConnecting = false
     this.reconnectAttempted = 0
     this._emitDebug('WebSocket connection established')
@@ -147,11 +161,11 @@ class Node {
       const timeoutId = setTimeout(() => {
         if (!this.isDestroyed) this._emitError('Node info fetch timeout')
       }, Node.INFO_FETCH_TIMEOUT)
-      timeoutId.unref?.()
+      unrefTimer(timeoutId)
 
       try {
         this.info = await this.rest.makeRequest('GET', '/v4/info')
-        this.isNodelink = !!this.info?.isNodelink;
+        this.isNodelink = !!this.info?.isNodelink
       } catch (err) {
         this.info = null
         this._emitError(`Failed to fetch node info: ${_functions.errMsg(err)}`)
@@ -171,12 +185,9 @@ class Node {
   _handleMessage(data, isBinary) {
     if (isBinary) return
 
-    const str = Buffer.isBuffer(data) ? data.toString('utf8') : data
-    if (!str || typeof str !== 'string') return
-
     let payload
     try {
-      payload = JSON.parse(str)
+      payload = JSON.parse(data)
     } catch (err) {
       this._emitDebug(() => `Invalid JSON from Lavalink: ${err.message}`)
       return
@@ -195,7 +206,6 @@ class Node {
   _emitToPlayer(eventName, payload) {
     const player = this._getPlayer(payload?.guildId)
     if (!player?.emit) return
-
     try {
       player.emit(eventName, payload)
     } catch (err) {
@@ -214,9 +224,14 @@ class Node {
 
   _handleClose(code, reason) {
     this.connected = false
+    const wasReady = this.state === NODE_STATE.READY
+    this.state = this.isDestroyed ? NODE_STATE.IDLE : NODE_STATE.RECONNECTING
     this._isConnecting = false
 
-    this.aqua.emit(AqualinkEvents.NodeDisconnect, this, { code, reason: _functions.reasonToString(reason) })
+    this.aqua.emit(AqualinkEvents.NodeDisconnect, this, {
+      code,
+      reason: _functions.reasonToString(reason)
+    })
 
     if (this.isDestroyed) return
 
@@ -244,9 +259,13 @@ class Node {
     const attempt = ++this.reconnectAttempted
 
     if (this.infiniteReconnects) {
-      this.aqua.emit(AqualinkEvents.NodeReconnect, this, { infinite: true, attempt, backoffTime: Node.INFINITE_BACKOFF })
+      this.aqua.emit(AqualinkEvents.NodeReconnect, this, {
+        infinite: true,
+        attempt,
+        backoffTime: Node.INFINITE_BACKOFF
+      })
       this.reconnectTimeoutId = setTimeout(this._boundHandlers.connect, Node.INFINITE_BACKOFF)
-      this.reconnectTimeoutId.unref?.()
+      unrefTimer(this.reconnectTimeoutId)
       return
     }
 
@@ -259,7 +278,7 @@ class Node {
     const backoffTime = this._calcBackoff(attempt)
     this.aqua.emit(AqualinkEvents.NodeReconnect, this, { infinite: false, attempt, backoffTime })
     this.reconnectTimeoutId = setTimeout(this._boundHandlers.connect, backoffTime)
-    this.reconnectTimeoutId.unref?.()
+    unrefTimer(this.reconnectTimeoutId)
   }
 
   _calcBackoff(attempt) {
@@ -269,30 +288,70 @@ class Node {
   }
 
   _clearReconnectTimeout() {
-    if (this.reconnectTimeoutId) {
-      clearTimeout(this.reconnectTimeoutId)
-      this.reconnectTimeoutId = null
-    }
+    if (!this.reconnectTimeoutId) return
+    clearTimeout(this.reconnectTimeoutId)
+    this.reconnectTimeoutId = null
   }
 
   connect() {
     if (this.isDestroyed || this._isConnecting) return
 
-    const currentState = this.ws?.readyState
-    if (currentState === WS_STATES.OPEN) {
+    const state = this.ws?.readyState
+    if (state === WS_STATES.OPEN) {
       this._emitDebug('WebSocket already connected')
       return
     }
-    if (currentState === WS_STATES.CONNECTING || currentState === WS_STATES.CLOSING) {
+    if (state === WS_STATES.CONNECTING || state === WS_STATES.CLOSING) {
       this._emitDebug('WebSocket is connecting/closing; skipping new connect')
       return
     }
 
     this._isConnecting = true
+    this.state = NODE_STATE.CONNECTING
     this._cleanup()
 
     try {
-      const ws = new WebSocket(this.wsUrl, {
+      const h = this._boundHandlers
+
+      if (this._wsIsBun) {
+        const ws = new WebSocketImpl(this.wsUrl, { headers: this._headers })
+        ws.binaryType = 'arraybuffer'
+
+        const offs = []
+        const add = (type, fn, once = false) => {
+          const wrapped = once
+            ? (ev) => { try { ws.removeEventListener(type, wrapped) } catch {} ; fn(ev) }
+            : fn
+          ws.addEventListener(type, wrapped)
+          offs.push(() => { try { ws.removeEventListener(type, wrapped) } catch {} })
+        }
+
+        add('open', () => h.open(), true)
+
+        add('error', (event) => {
+          const err = event?.error
+          h.error(err instanceof Error ? err : new Error('WebSocket error'))
+        }, true)
+
+        add('message', (event) => {
+          const data = event?.data
+          if (typeof data === 'string') h.message(data, false)
+          else h.message(data, true)
+        })
+
+        add('close', (event) => {
+          h.close(
+            typeof event?.code === 'number' ? event.code : Node.WS_CLOSE_NORMAL,
+            typeof event?.reason === 'string' ? event.reason : ''
+          )
+        }, true)
+
+        this._bunCleanup = () => { for (let i = 0; i < offs.length; i++) offs[i]() }
+        this.ws = ws
+        return
+      }
+
+      const ws = new WebSocketImpl(this.wsUrl, {
         headers: this._headers,
         perMessageDeflate: true,
         handshakeTimeout: this.timeout,
@@ -302,7 +361,6 @@ class Node {
 
       ws.binaryType = 'nodebuffer'
 
-      const h = this._boundHandlers
       ws.once('open', h.open)
       ws.once('error', h.error)
       ws.on('message', h.message)
@@ -320,12 +378,20 @@ class Node {
     const ws = this.ws
     if (!ws) return
 
-    ws.removeAllListeners()
+    if (this._wsIsBun) {
+      try { this._bunCleanup?.() } catch {}
+      this._bunCleanup = null
+    } else {
+      ws.removeAllListeners?.()
+    }
 
     try {
       const state = ws.readyState
-      if (state === WS_STATES.OPEN) ws.close(Node.WS_CLOSE_NORMAL)
-      else if (state !== WS_STATES.CLOSED) ws.terminate()
+      if (state === WS_STATES.OPEN || state === WS_STATES.CONNECTING) {
+        ws.close(Node.WS_CLOSE_NORMAL)
+      } else if (!this._wsIsBun && state !== WS_STATES.CLOSED) {
+        ws.terminate?.()
+      }
     } catch (err) {
       this._emitError(`WebSocket cleanup error: ${_functions.errMsg(err)}`)
     }
@@ -337,6 +403,7 @@ class Node {
     if (this.isDestroyed) return
 
     this.isDestroyed = true
+    this.state = NODE_STATE.IDLE
     this._isConnecting = false
     this._clearReconnectTimeout()
     this._cleanup()
@@ -415,7 +482,6 @@ class Node {
     this._headers['Session-Id'] = sessionId
 
     this.aqua.emit(AqualinkEvents.NodeReady, this, { resumed: !!payload.resumed })
-    this.aqua.emit(AqualinkEvents.NodeConnect, this)
 
     if (this.autoResume) {
       setImmediate(() => {
@@ -427,9 +493,7 @@ class Node {
   }
 
   async _resumePlayers() {
-    if (!this.sessionId) {
-      return
-    }
+    if (!this.sessionId) return
 
     try {
       await this.rest.makeRequest('PATCH', `/v4/sessions/${this.sessionId}`, {
@@ -452,7 +516,11 @@ class Node {
 
   _emitDebug(message) {
     if (!this.aqua?.listenerCount?.(AqualinkEvents.Debug)) return
-    this.aqua.emit(AqualinkEvents.Debug, this.name, typeof message === 'function' ? message() : message)
+    this.aqua.emit(
+      AqualinkEvents.Debug,
+      this.name,
+      typeof message === 'function' ? message() : message
+    )
   }
 }
 

package/build/structures/Player.js

@@ -7,6 +7,7 @@ const Filters = require('./Filters')
 const { spAutoPlay, scAutoPlay } = require('../handlers/autoplay')
 const Queue = require('./Queue')
 
+const PLAYER_STATE = Object.freeze({ IDLE: 0, CONNECTING: 1, READY: 2, DISCONNECTING: 3, DESTROYED: 4 })
 const LOOP_MODES = Object.freeze({ NONE: 0, TRACK: 1, QUEUE: 2 })
 const LOOP_MODE_NAMES = Object.freeze(['none', 'track', 'queue'])
 const EVENT_HANDLERS = Object.freeze({
@@ -166,6 +167,8 @@ class Player extends EventEmitter {
     this.textChannel = options.textChannel
     this.voiceChannel = options.voiceChannel
     this.playing = this.paused = this.connected = this.destroyed = false
+    this.state = PLAYER_STATE.IDLE
+    this.txId = 0
     this.isAutoplayEnabled = this.isAutoplay = false
     this.autoplaySeed = this.current = this.nowPlayingMessage = null
     this.position = this.timestamp = this.ping = 0
@@ -244,12 +247,12 @@ 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)
       }
     } else {
       this._voiceDownSince = 0
+      this.state = PLAYER_STATE.READY
     }
 
     this.aqua.emit(AqualinkEvents.PlayerUpdate, this, packet)
@@ -291,37 +294,9 @@ class Player extends EventEmitter {
     return this
   }
 
-  async _waitForConnection(timeout = RESUME_TIMEOUT) {
-    if (this.destroyed) return
-    if (this.connected) return
-    return new Promise((resolve, reject) => {
-      let timer
-      const cleanup = () => {
-        if (timer) { this._pendingTimers?.delete(timer); clearTimeout(timer) }
-        this.off('playerUpdate', onUpdate)
-      }
-      const onUpdate = payload => {
-        if (this.destroyed) { cleanup(); return reject(new Error('Player destroyed')) }
-        if (payload?.state?.connected || _functions.isNum(payload?.state?.time)) {
-          cleanup()
-          return resolve()
-        }
-      }
-      this.on('playerUpdate', onUpdate)
-      timer = this._createTimer(() => { cleanup(); reject(new Error('No connection confirmation')) }, timeout)
-    })
-  }
 
   async play() {
     if (this.destroyed || !this.queue.size) return this
-    if (!this.connected) {
-      try {
-        await this._waitForConnection(RESUME_TIMEOUT)
-        if (!this.connected || this.destroyed) return this
-      } catch {
-        return this
-      }
-    }
 
     const item = this.queue.dequeue()
     if (!item) return this
@@ -348,8 +323,9 @@ class Player extends EventEmitter {
     this.deaf = options.deaf !== undefined ? !!options.deaf : true
     this.mute = !!options.mute
     this.destroyed = false
+    this.state = PLAYER_STATE.CONNECTING
 
-    this._voiceRequestAt = Date.now()
+    this.txId++
     this._voiceRequestChannel = voiceChannel
 
     this.voiceChannel = voiceChannel
@@ -399,7 +375,11 @@ class Player extends EventEmitter {
   }
 
   destroy(options = {}) {
-    const { preserveClient = true, skipRemote = false } = options
+    const {
+      preserveClient = true, skipRemote = false,
+      preserveMessage = false, preserveReconnecting = false,
+      preserveTracks = false
+    } = options
     if (this.destroyed && !this.queue) return this
 
     if (!this.destroyed) {
@@ -416,12 +396,13 @@ class Player extends EventEmitter {
     this._pendingTimers = null
 
     this.connected = this.playing = this.paused = this.isAutoplay = false
+    this.state = PLAYER_STATE.DESTROYED
     this.autoplayRetries = this.reconnectionRetries = 0
-    this._reconnecting = false
+    if (!preserveReconnecting) this._reconnecting = false
     this._lastVoiceChannel = this.voiceChannel
     this.voiceChannel = null
 
-    if (this.shouldDeleteMessage && this.nowPlayingMessage) {
+    if (this.shouldDeleteMessage && this.nowPlayingMessage && !preserveMessage) {
       _functions.safeDel(this.nowPlayingMessage)
       this.nowPlayingMessage = null
     }
@@ -446,7 +427,7 @@ class Player extends EventEmitter {
     this._dataStore?.clear()
     this._dataStore = null
 
-    if (this.current?.dispose && !this.aqua?.options?.autoResume) this.current.dispose()
+    if (this.current?.dispose && !this.aqua?.options?.autoResume && !preserveTracks) this.current.dispose()
     if (this.connection) {
       try { this.connection.destroy() } catch { }
     }
@@ -677,11 +658,12 @@ class Player extends EventEmitter {
     return null
   }
 
-  trackStart() {
+  trackStart(player, track, payload = {}) {
     if (this.destroyed) return
     this.playing = true
     this.paused = false
-    this.aqua.emit(AqualinkEvents.TrackStart, this, this.current)
+    this.aqua.emit(AqualinkEvents.TrackStart, this, this.current, { ...payload, resumed: this._resuming })
+    this._resuming = false
   }
 
   async trackEnd(player, track, payload) {
@@ -692,12 +674,12 @@ class Player extends EventEmitter {
     const isReplaced = reason === 'replaced'
 
     if (track) this.previousTracks.push(track)
-    if (this.shouldDeleteMessage) _functions.safeDel(this.nowPlayingMessage)
+    if (this.shouldDeleteMessage && !this._reconnecting && !this._resuming) _functions.safeDel(this.nowPlayingMessage)
     this.current = null
 
     if (isFailure) {
       if (!this.queue.size) {
-        this.clearData()
+        this.clearData({ preserveTracks: this._reconnecting || this._resuming })
         this.aqua.emit(AqualinkEvents.QueueEnd, this)
       } else {
         this.aqua.emit(AqualinkEvents.TrackEnd, this, track, reason)
@@ -718,7 +700,7 @@ class Player extends EventEmitter {
     } else {
       this.playing = false
       if (this.leaveOnEnd && !this.destroyed) {
-        this.clearData()
+        this.clearData({ preserveTracks: this._reconnecting || this._resuming })
         this.destroy()
       }
       this.aqua.emit(AqualinkEvents.QueueEnd, this)
@@ -751,51 +733,33 @@ class Player extends EventEmitter {
   mixStarted(p, t, payload) { _functions.emitIfActive(this, AqualinkEvents.MixStarted, t, payload) }
   mixEnded(p, t, payload) { _functions.emitIfActive(this, AqualinkEvents.MixEnded, t, payload) }
 
+
   async _attemptVoiceResume() {
     if (!this.connection?.sessionId) throw new Error('No session')
     if (!await this.connection.attemptResume()) throw new Error('Resume failed')
-    return new Promise((resolve, reject) => {
-      let timeout
-      const cleanup = () => {
-        if (timeout) { this._pendingTimers?.delete(timeout); clearTimeout(timeout) }
-        this.off('playerUpdate', onUpdate)
-      }
-      const onUpdate = payload => {
-        if (payload?.state?.connected || _functions.isNum(payload?.state?.time)) {
-          cleanup()
-          resolve()
-        }
-      }
-      timeout = this._createTimer(() => { cleanup(); reject(new Error('No confirmation')) }, RESUME_TIMEOUT)
-      this.on('playerUpdate', onUpdate)
-    })
   }
 
   async socketClosed(player, track, payload) {
     if (this.destroyed) return
     const code = payload?.code
-
-    if (code === 4014 || code === 4022) {
-      this.aqua.emit(AqualinkEvents.SocketClosed, this, payload)
-
-      this.connected = false
-      if (!this._voiceDownSince) this._voiceDownSince = Date.now()
-
-      if (code !== 4014) {
-        this._suppressResumeUntil = Date.now() + 3000
-      }
-      return
-    }
+    let isRecoverable = [4015, 4009, 4006, 4014, 4022].includes(code)
+    if (code === 4014 && this.connection?.isWaitingForDisconnect) isRecoverable = false
 
     if (code === 4015 && !this.nodes?.info?.isNodelink) {
       try { await this._attemptVoiceResume(); return } catch { /* ignore */ }
     }
 
-    if (![4015, 4009, 4006].includes(code)) {
+    if (!isRecoverable) {
       this.aqua.emit(AqualinkEvents.SocketClosed, this, payload)
       return
     }
 
+    if (code === 4014 || code === 4022) {
+      this.connected = false
+      if (!this._voiceDownSince) this._voiceDownSince = Date.now()
+      if (code === 4022) this._suppressResumeUntil = Date.now() + 3000
+    }
+
     if (this._reconnecting) return
 
     const aqua = this.aqua
@@ -817,18 +781,25 @@ class Player extends EventEmitter {
       currentTrack: this.current,
       queue: this.queue?.toArray() || [],
       previousIdentifiers: Array.from(this.previousIdentifiers),
-      autoplaySeed: this.autoplaySeed
+      autoplaySeed: this.autoplaySeed,
+      nowPlayingMessage: this.nowPlayingMessage
     }
 
     this._reconnecting = true
-    this.destroy({ preserveClient: true, skipRemote: true })
+    this.destroy({
+      preserveClient: true, skipRemote: true,
+      preserveMessage: true, preserveReconnecting: true,
+      preserveTracks: true
+    })
 
     const reconnectTimers = new Set()
     const tryReconnect = async attempt => {
       if (aqua?.destroyed) { _functions.clearTimers(reconnectTimers); return }
       try {
         const np = await aqua.createConnection({
-          guildId, voiceChannel: vcId, textChannel: tcId, deaf, mute, defaultVolume: state.volume
+          guildId, voiceChannel: vcId, textChannel: tcId, deaf, mute, defaultVolume: state.volume,
+          preserveMessage: true,
+          resuming: true
         })
         if (!np) throw new Error('Failed to create player')
 
@@ -837,6 +808,7 @@ class Player extends EventEmitter {
         np.isAutoplayEnabled = state.isAutoplayEnabled
         np.autoplaySeed = state.autoplaySeed
         np.previousIdentifiers = new Set(state.previousIdentifiers)
+        np.nowPlayingMessage = state.nowPlayingMessage
 
         const ct = state.currentTrack
         if (ct) np.queue.add(ct)
@@ -894,11 +866,12 @@ class Player extends EventEmitter {
     return this._dataStore?.get(key)
   }
 
-  clearData() {
+  clearData(options = {}) {
+    const { preserveTracks = false } = options
     this.previousTracks?.clear()
     this._dataStore?.clear()
     this.previousIdentifiers?.clear()
-    if (this.current?.dispose) this.current.dispose()
+    if (this.current?.dispose && !preserveTracks) this.current.dispose()
     this.current = null
     this.position = this.timestamp = 0
     this.queue?.clear()

package/build/structures/Queue.js

@@ -1,65 +1,86 @@
-class Queue extends Array {
+'use strict'
+
+class Queue {
+  constructor() {
+    this._items = []
+  }
+
   get size() {
-    return this.length
+    return this._items.length
   }
 
   get first() {
-    return this[0] || null
+    return this._items[0] || null
   }
 
   get last() {
-    return this[this.length - 1] || null
+    return this._items[this._items.length - 1] || null
   }
 
-  add(track) {
-    this.push(track)
+  add(...tracks) {
+    this._items.push(...tracks)
     return this
   }
 
   remove(track) {
-    const idx = this.indexOf(track)
+    const idx = this._items.indexOf(track)
     if (idx === -1) return false
-    const removed = this[idx]
-    this.splice(idx, 1)
+    const removed = this._items[idx]
+    this._items.splice(idx, 1)
     if (removed?.dispose) removed.dispose()
     return true
   }
 
   clear() {
-    for (let i = 0; i < this.length; i++) {
-      if (this[i]?.dispose) this[i].dispose()
+    for (let i = 0; i < this._items.length; i++) {
+      if (this._items[i]?.dispose) this._items[i].dispose()
     }
-    this.length = 0
+    this._items.length = 0
   }
 
   shuffle() {
-    for (let i = this.length - 1; i > 0; i--) {
+    for (let i = this._items.length - 1; i > 0; i--) {
       const j = Math.floor(Math.random() * (i + 1))
-      const temp = this[i]
-      this[i] = this[j]
-      this[j] = temp
+      const temp = this._items[i]
+      this._items[i] = this._items[j]
+      this._items[j] = temp
     }
     return this
   }
 
+  move(from, to) {
+    if (from < 0 || from >= this._items.length || to < 0 || to >= this._items.length) return this
+    const [item] = this._items.splice(from, 1)
+    this._items.splice(to, 0, item)
+    return this
+  }
+
+  swap(index1, index2) {
+    if (index1 < 0 || index1 >= this._items.length || index2 < 0 || index2 >= this._items.length) return this
+    const temp = this._items[index1]
+    this._items[index1] = this._items[index2]
+    this._items[index2] = temp
+    return this
+  }
+
   peek() {
     return this.first
   }
 
   toArray() {
-    return this.slice()
+    return [...this._items]
   }
 
   at(index) {
-    return this[index] || null
+    return this._items[index] || null
   }
 
   dequeue() {
-    return this.shift()
+    return this._items.shift()
   }
 
   isEmpty() {
-    return this.length === 0
+    return this._items.length === 0
   }
 
   enqueue(track) {
@@ -67,4 +88,4 @@ class Queue extends Array {
   }
 }
 
-module.exports = Queue
+module.exports = Queue

package/build/structures/Rest.js

@@ -1,8 +1,21 @@
+'use strict'
+
 const { Buffer } = require('buffer')
 const { Agent: HttpsAgent, request: httpsRequest } = require('https')
 const { Agent: HttpAgent, request: httpRequest } = require('http')
 const http2 = require('http2')
-const { createBrotliDecompress, createUnzip, brotliDecompressSync, unzipSync } = require('zlib')
+const {
+  createBrotliDecompress,
+  createUnzip,
+  brotliDecompressSync,
+  unzipSync,
+  createZstdDecompress,
+  zstdDecompressSync
+} = require('zlib')
+
+const unrefTimer = (t) => { try { t?.unref?.() } catch {} }
+
+const HAS_ZSTD = typeof createZstdDecompress === 'function' && typeof zstdDecompressSync === 'function'
 
 const BASE64_LOOKUP = new Uint8Array(256)
 for (let i = 65; i <= 90; i++) BASE64_LOOKUP[i] = 1
@@ -10,9 +23,8 @@ for (let i = 97; i <= 122; i++) BASE64_LOOKUP[i] = 1
 for (let i = 48; i <= 57; i++) BASE64_LOOKUP[i] = 1
 BASE64_LOOKUP[43] = BASE64_LOOKUP[47] = BASE64_LOOKUP[61] = BASE64_LOOKUP[95] = BASE64_LOOKUP[45] = 1
 
-const ENCODING_NONE = 0, ENCODING_BR = 1, ENCODING_GZIP = 2, ENCODING_DEFLATE = 3
+const ENCODING_NONE = 0, ENCODING_BR = 1, ENCODING_GZIP = 2, ENCODING_DEFLATE = 3, ENCODING_ZSTD = 4
 const MAX_RESPONSE_SIZE = 10485760
-const SMALL_RESPONSE_THRESHOLD = 512
 const COMPRESSION_MIN_SIZE = 1024
 const API_VERSION = 'v4'
 const UTF8 = 'utf8'
@@ -43,6 +55,10 @@ const _functions = {
   getEncodingType(header) {
     if (!header) return ENCODING_NONE
     const c = header.charCodeAt(0)
+
+    if (c === 122 && header.startsWith('zstd')) return ENCODING_ZSTD
+    if (c === 120 && header.startsWith('x-zstd')) return ENCODING_ZSTD
+
     if (c === 98 && header.startsWith('br')) return ENCODING_BR
     if (c === 103 && header.startsWith('gzip')) return ENCODING_GZIP
     if (c === 100 && header.startsWith('deflate')) return ENCODING_DEFLATE
@@ -53,8 +69,13 @@ const _functions = {
     return ct && ct.charCodeAt(0) === 97 && ct.includes(JSON_CT)
   },
 
-  parseBody(text, contentType, forceJson) {
-    return (forceJson || this.isJsonContent(contentType)) ? JSON.parse(text) : text
+  parseBody(data, contentType, forceJson) {
+    const isJson = forceJson || this.isJsonContent(contentType)
+    if (isJson) {
+      if (typeof data === 'string') return JSON.parse(data)
+      return JSON.parse(data)
+    }
+    return typeof data === 'string' ? data : data.toString(UTF8)
   },
 
   createHttpError(status, method, url, headers, body, statusMessage) {
@@ -68,10 +89,18 @@ const _functions = {
   },
 
   createDecompressor(type) {
+    if (type === ENCODING_ZSTD) {
+      if (!HAS_ZSTD) throw new Error('Unsupported content-encoding: zstd (zlib zstd APIs not available in this Node runtime)')
+      return createZstdDecompress()
+    }
     return type === ENCODING_BR ? createBrotliDecompress() : createUnzip()
   },
 
   decompressSync(buf, type) {
+    if (type === ENCODING_ZSTD) {
+      if (!HAS_ZSTD) throw new Error('Unsupported content-encoding: zstd (zlib zstd APIs not available in this Node runtime)')
+      return zstdDecompressSync(buf)
+    }
     return type === ENCODING_BR ? brotliDecompressSync(buf) : unzipSync(buf)
   }
 }
@@ -103,14 +132,17 @@ class Rest {
       lyrics: `${this._apiBase}/lyrics`
     })
 
+    const acceptEncoding = HAS_ZSTD ? 'zstd, br, gzip, deflate' : 'br, gzip, deflate'
+
     this.defaultHeaders = Object.freeze({
       Authorization: String(node.auth || node.password || ''),
       Accept: 'application/json, */*;q=0.5',
-      'Accept-Encoding': 'br, gzip, deflate',
+      'Accept-Encoding': acceptEncoding,
       'User-Agent': `Aqualink/${aqua?.version || '1.0'} (Node.js ${process.version})`
     })
 
     this._headerPool = []
+    this._tlsOptions = null
     this._setupAgent(node)
     this.useHttp2 = !!(aqua?.options?.useHttp2)
     this._h2 = null
@@ -130,11 +162,13 @@ class Rest {
 
     if (node.ssl) {
       opts.maxCachedSessions = node.maxCachedSessions || 200
-      if (node.rejectUnauthorized !== undefined) opts.rejectUnauthorized = node.rejectUnauthorized
-      if (node.ca) opts.ca = node.ca
-      if (node.cert) opts.cert = node.cert
-      if (node.key) opts.key = node.key
-      if (node.passphrase) opts.passphrase = node.passphrase
+      this._tlsOptions = Object.create(null)
+      if (node.rejectUnauthorized !== undefined) this._tlsOptions.rejectUnauthorized = opts.rejectUnauthorized = node.rejectUnauthorized
+      if (node.ca) this._tlsOptions.ca = opts.ca = node.ca
+      if (node.cert) this._tlsOptions.cert = opts.cert = node.cert
+      if (node.key) this._tlsOptions.key = opts.key = node.key
+      if (node.passphrase) this._tlsOptions.passphrase = opts.passphrase = node.passphrase
+      if (node.servername) this._tlsOptions.servername = node.servername
     }
 
     this.agent = new (node.ssl ? HttpsAgent : HttpAgent)(opts)
@@ -160,7 +194,7 @@ class Rest {
 
   _buildHeaders(hasPayload, payloadLength) {
     if (!hasPayload) return this.defaultHeaders
-    let h = this._headerPool.pop() || Object.create(null)
+    const h = this._headerPool.pop() || Object.create(null)
     h.Authorization = this.defaultHeaders.Authorization
     h.Accept = this.defaultHeaders.Accept
     h['Accept-Encoding'] = this.defaultHeaders['Accept-Encoding']
@@ -194,7 +228,8 @@ class Rest {
 
   _h1Request(method, url, headers, payload) {
     return new Promise((resolve, reject) => {
-      let req, timer, done = false, chunks = [], size = 0, prealloc = null
+      let req, timer, done = false
+      let chunks = null, size = 0, prealloc = null
 
       const finish = (ok, val) => {
         if (done) return
@@ -208,7 +243,7 @@ class Rest {
       req = this.request(url, { method, headers, agent: this.agent, timeout: this.timeout }, (res) => {
         if (timer) { clearTimeout(timer); timer = null }
 
-        const status = res.statusCode
+        const status = res.statusCode || 0
         const cl = res.headers['content-length']
         const contentType = res.headers['content-type'] || ''
 
@@ -226,9 +261,10 @@ class Rest {
         const encoding = _functions.getEncodingType(res.headers['content-encoding'])
 
         const handleResponse = (buffer) => {
-          const text = buffer.toString(UTF8)
+          if (buffer.length > MAX_RESPONSE_SIZE) return finish(false, ERRORS.RESPONSE_TOO_LARGE)
+
           try {
-            const result = _functions.parseBody(text, contentType, false)
+            const result = _functions.parseBody(buffer, contentType, false)
             if (status >= 400) {
               finish(false, _functions.createHttpError(status, method, url, res.headers, result, res.statusMessage))
             } else {
@@ -239,15 +275,15 @@ class Rest {
           }
         }
 
-        if (clInt > 0 && clInt < SMALL_RESPONSE_THRESHOLD && encoding === ENCODING_NONE) {
-          res.once('data', handleResponse)
-          res.once('error', (e) => finish(false, e))
-          return
-        }
-
         if (encoding !== ENCODING_NONE && clInt > 0 && clInt < COMPRESSION_MIN_SIZE) {
           const compressed = []
-          res.on('data', (c) => compressed.push(c))
+          let csize = 0
+
+          res.on('data', (c) => {
+            csize += c.length
+            if (csize > MAX_RESPONSE_SIZE) return finish(false, ERRORS.RESPONSE_TOO_LARGE)
+            compressed.push(c)
+          })
           res.once('end', () => {
             try {
               handleResponse(_functions.decompressSync(Buffer.concat(compressed), encoding))
@@ -255,12 +291,16 @@ class Rest {
               finish(false, e)
             }
           })
+          res.once('aborted', () => finish(false, ERRORS.RESPONSE_ABORTED))
           res.once('error', (e) => finish(false, e))
           return
         }
 
-        if (clInt > 0 && clInt <= MAX_RESPONSE_SIZE) prealloc = Buffer.allocUnsafe(clInt)
-        chunks = []
+        if (encoding === ENCODING_NONE && clInt > 0 && clInt <= MAX_RESPONSE_SIZE) {
+          prealloc = Buffer.allocUnsafe(clInt)
+        } else {
+          chunks = []
+        }
 
         let stream = res
         if (encoding !== ENCODING_NONE) {
@@ -286,12 +326,17 @@ class Rest {
 
         stream.once('end', () => {
           if (size === 0) return finish(true, null)
-          handleResponse(prealloc ? prealloc.slice(0, size) : (chunks.length === 1 ? chunks[0] : Buffer.concat(chunks, size)))
+          handleResponse(
+            prealloc
+              ? prealloc.slice(0, size)
+              : (chunks.length === 1 ? chunks[0] : Buffer.concat(chunks, size))
+          )
         })
       })
 
       req.once('error', (e) => finish(false, e))
       timer = setTimeout(() => finish(false, new Error(`Request timeout: ${this.timeout}ms`)), this.timeout)
+      unrefTimer(timer)
       payload ? req.end(payload) : req.end()
     })
   }
@@ -299,9 +344,9 @@ class Rest {
   _getH2Session() {
     if (!this._h2 || this._h2.closed || this._h2.destroyed) {
       this._clearH2()
-      this._h2 = http2.connect(this.baseUrl)
-      this._h2Timer = setTimeout(() => this._closeH2(), H2_TIMEOUT)
-      this._h2Timer.unref()
+      this._h2 = http2.connect(this.baseUrl, this._tlsOptions || undefined)
+      this._resetH2Timer()
+
       const onEnd = () => this._clearH2()
       this._h2.once('error', onEnd)
       this._h2.once('close', onEnd)
@@ -310,6 +355,14 @@ class Rest {
     return this._h2
   }
 
+  _resetH2Timer() {
+    if (this._h2Timer) { clearTimeout(this._h2Timer); this._h2Timer = null }
+    if (this._h2 && !this._h2.closed && !this._h2.destroyed) {
+      this._h2Timer = setTimeout(() => this._closeH2(), H2_TIMEOUT)
+      unrefTimer(this._h2Timer)
+    }
+  }
+
   _clearH2() {
     if (this._h2Timer) { clearTimeout(this._h2Timer); this._h2Timer = null }
     this._h2 = null
@@ -317,14 +370,18 @@ class Rest {
 
   _closeH2() {
     if (this._h2Timer) { clearTimeout(this._h2Timer); this._h2Timer = null }
-    if (this._h2) { try { this._h2.close() } catch { } this._h2 = null }
+    if (this._h2) {
+      try { this._h2.close() } catch {}
+      this._h2 = null
+    }
   }
 
   _h2Request(method, path, headers, payload) {
     const session = this._getH2Session()
 
     return new Promise((resolve, reject) => {
-      let req, timer, done = false, chunks = [], size = 0, prealloc = null
+      let req, timer, done = false
+      let chunks = null, size = 0, prealloc = null
 
       const finish = (ok, val) => {
         if (done) return
@@ -347,12 +404,14 @@ class Rest {
       if (headers['Content-Length']) h2h['Content-Length'] = headers['Content-Length']
 
       req = session.request(h2h)
+      this._resetH2Timer()
 
       req.once('response', (rh) => {
         if (timer) { clearTimeout(timer); timer = null }
 
         const status = rh[':status'] || 0
         const cl = rh['content-length']
+        const contentType = rh['content-type'] || ''
 
         if (status === 204 || cl === '0') {
           req.resume()
@@ -365,9 +424,14 @@ class Rest {
           return finish(false, ERRORS.RESPONSE_TOO_LARGE)
         }
 
-        if (clInt > 0 && clInt <= MAX_RESPONSE_SIZE) prealloc = Buffer.allocUnsafe(clInt)
-
         const encoding = _functions.getEncodingType(rh['content-encoding'])
+
+        if (encoding === ENCODING_NONE && clInt > 0 && clInt <= MAX_RESPONSE_SIZE) {
+          prealloc = Buffer.allocUnsafe(clInt)
+        } else {
+          chunks = []
+        }
+
         const decomp = encoding !== ENCODING_NONE ? _functions.createDecompressor(encoding) : null
         const stream = decomp ? req.pipe(decomp) : req
 
@@ -387,9 +451,13 @@ class Rest {
 
         stream.once('end', () => {
           if (size === 0) return finish(true, null)
-          const buffer = prealloc ? prealloc.slice(0, size) : (chunks.length === 1 ? chunks[0] : Buffer.concat(chunks, size))
+
+          const buffer = prealloc
+            ? prealloc.slice(0, size)
+            : (chunks.length === 1 ? chunks[0] : Buffer.concat(chunks, size))
+
           try {
-            const result = JSON.parse(buffer.toString(UTF8))
+            const result = _functions.parseBody(buffer, contentType, false)
             if (status >= 400) {
               finish(false, _functions.createHttpError(status, method, this.baseUrl + path, rh, result))
             } else {
@@ -402,6 +470,7 @@ class Rest {
       })
 
       timer = setTimeout(() => finish(false, new Error(`Request timeout: ${this.timeout}ms`)), this.timeout)
+      unrefTimer(timer)
       payload ? req.end(payload) : req.end()
     })
   }
@@ -480,22 +549,23 @@ class Rest {
       try {
         const lyrics = await this.makeRequest('GET', `${this._getSessionPath()}/players/${guildId}/track/lyrics?skipTrackSource=${skip}`)
         if (this._validLyrics(lyrics)) return lyrics
-      } catch { }
+      } catch {}
     }
 
     if (hasEncoded) {
       try {
         const lyrics = await this.makeRequest('GET', `${this._endpoints.lyrics}?track=${encodeURIComponent(encoded)}&skipTrackSource=${skip}`)
         if (this._validLyrics(lyrics)) return lyrics
-      } catch { }
+      } catch {}
     }
 
     if (title) {
-      const query = track?.info?.author ? `${title} ${track.info.author}` : title
+      const info = track.info || {}
+      const query = info.author ? `${title} ${info.author}` : title
       try {
         const lyrics = await this.makeRequest('GET', `${this._endpoints.lyrics}/search?query=${encodeURIComponent(query)}`)
         if (this._validLyrics(lyrics)) return lyrics
-      } catch { }
+      } catch {}
     }
 
     return null
@@ -510,7 +580,10 @@ class Rest {
 
   async subscribeLiveLyrics(guildId, skipTrackSource = false) {
     try {
-      return await this.makeRequest('POST', `${this._getSessionPath()}/players/${guildId}/lyrics/subscribe?skipTrackSource=${skipTrackSource ? 'true' : 'false'}`) === null
+      return await this.makeRequest(
+        'POST',
+        `${this._getSessionPath()}/players/${guildId}/lyrics/subscribe?skipTrackSource=${skipTrackSource ? 'true' : 'false'}`
+      ) === null
     } catch {
       return false
     }
@@ -538,12 +611,12 @@ class Rest {
       volume: options.volume !== undefined ? options.volume : 0.8
     }
 
-    return await this.makeRequest("POST", `/v4/sessions/${this.sessionId}/players/${guildId}/mix`, payload)
+    return this.makeRequest('POST', `/v4/sessions/${this.sessionId}/players/${guildId}/mix`, payload)
   }
 
   async getActiveMixer(guildId) {
     if (!this.node.isNodelink) throw new Error('Mixer endpoints are only available on Nodelink nodes')
-    const response = await this.makeRequest("GET", `/v4/sessions/${this.sessionId}/players/${guildId}/mix`)
+    const response = await this.makeRequest('GET', `/v4/sessions/${this.sessionId}/players/${guildId}/mix`)
     return response?.mixes || []
   }
 
@@ -551,17 +624,16 @@ class Rest {
     if (!this.node.isNodelink) throw new Error('Mixer endpoints are only available on Nodelink nodes')
     if (!guildId || !mix || typeof volume !== 'number') throw new Error('You forget to set the guild_id, mix or volume options')
 
-    return await this.makeRequest("PATCH", `/v4/sessions/${this.sessionId}/players/${guildId}/mix/${mix}`, { volume })
+    return this.makeRequest('PATCH', `/v4/sessions/${this.sessionId}/players/${guildId}/mix/${mix}`, { volume })
   }
 
   async removeMixer(guildId, mix) {
     if (!this.node.isNodelink) throw new Error('Mixer endpoints are only available on Nodelink nodes')
     if (!guildId || !mix) throw new Error('You forget to set the guild_id and/or mix options')
 
-    return await this.makeRequest("DELETE", `/v4/sessions/${this.sessionId}/players/${guildId}/mix/${mix}`)
+    return this.makeRequest('DELETE', `/v4/sessions/${this.sessionId}/players/${guildId}/mix/${mix}`)
   }
 
-
   destroy() {
     if (this.agent) { this.agent.destroy(); this.agent = null }
     this._closeH2()

package/build/structures/Track.js

@@ -117,8 +117,12 @@ class Track {
   }
 
   _computeArtwork() {
+    if (this.artworkUrl) return this.artworkUrl
     const id = this.identifier || (this.uri && YT_ID_REGEX.exec(this.uri)?.[1])
-    return id ? `https://i.ytimg.com/vi/${id}/hqdefault.jpg` : null
+    if (id && this.sourceName?.includes('youtube')) {
+      return `https://i.ytimg.com/vi/${id}/hqdefault.jpg`
+    }
+    return null
   }
 }
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "aqualink",
-  "version": "2.17.3",
-  "description": "An Lavalink client, focused in pure performance and features",
+  "version": "2.18.0",
+  "description": "An Lavalink/Nodelink client, focused in pure performance and features",
   "main": "./build/index.js",
   "types": "./build/index.d.ts",
   "scripts": {
@@ -25,7 +25,7 @@
     "discord-integration",
     "high-performance",
     "scalable",
-    "lavalink",
+    "nodelink",
     "api",
     "discord",
     "lavalink.js",
@@ -68,4 +68,4 @@
       "url": "https://github.com/ToddyTheNoobDud"
     }
   ]
-}
+}