aqualink 2.19.0 → 2.19.1

package/build/handlers/autoplay.js

@@ -1,14 +1,25 @@
 const https = require('https')
 
+// Default agent config (used only if shared agent not provided)
 const AGENT_CONFIG = {
   keepAlive: true,
-  maxSockets: 5,
-  maxFreeSockets: 2,
+  maxSockets: 64,
+  maxFreeSockets: 32,
   timeout: 8000,
   freeSocketTimeout: 4000
 }
 
-const agent = new https.Agent(AGENT_CONFIG)
+// Shared agent reference - can be set from Rest module
+let sharedAgent = null
+const getAgent = () => sharedAgent || (sharedAgent = new https.Agent(AGENT_CONFIG))
+
+// Allow Rest module to inject its agent
+const setSharedAgent = (agent) => {
+  if (agent && typeof agent.request === 'function') {
+    sharedAgent = agent
+  }
+}
+
 
 const SC_LINK_RE = /<a\s+itemprop="url"\s+href="(\/[^"]+)"/g
 const MAX_REDIRECTS = 3
@@ -23,7 +34,7 @@ const fastFetch = (url, depth = 0) =>
 
     const req = https.get(
       url,
-      { agent, timeout: DEFAULT_TIMEOUT_MS },
+      { agent: getAgent(), timeout: DEFAULT_TIMEOUT_MS },
       (res) => {
         const { statusCode, headers } = res
 
@@ -132,5 +143,6 @@ const spAutoPlay = async (seed, player, requester, excludedIds = []) => {
 
 module.exports = {
   scAutoPlay,
-  spAutoPlay
+  spAutoPlay,
+  setSharedAgent
 }

package/build/index.d.ts

@@ -50,16 +50,81 @@ declare module 'aqualink' {
     get leastUsedNodes(): Node[]
 
     // Core Methods
+    /**
+     * Initializes the specific client id and connects to all nodes
+     * @param clientId Client ID
+     * @example
+     * ```ts
+     * await aqua.init(client.user.id);
+     * ```
+     */
     init(clientId: string): Promise<Aqua>
+
+    /**
+     * Creates a new node connection
+     * @param options Modified node options
+     */
     createNode(options: NodeOptions): Promise<Node>
+
+    /**
+     * Destroys a node by identifier
+     * @param identifier Node identifier (name or host)
+     */
     destroyNode(identifier: string): void
+
+    /**
+     * Updates the voice state of a player
+     * @param data Voice state update packet
+     */
     updateVoiceState(data: VoiceStateUpdate | VoiceServerUpdate): void
+
+    /**
+     * Fetches nodes in a specific region
+     * @param region Region name
+     */
     fetchRegion(region: string): Node[]
+
+    /**
+     * Creates a connection for a player
+     * @param options Connection options
+     */
     createConnection(options: ConnectionOptions): Player
+
+    /**
+     * Creates a player on a specific node
+     * @param node Node to create player on
+     * @param options Player options
+     */
     createPlayer(node: Node, options: PlayerOptions): Player
+
+    /**
+     * Destroys a player
+     * @param guildId Guild ID
+     */
     destroyPlayer(guildId: string): Promise<void>
+
+    /**
+     * Resolves a track or playlist
+     * @param options Resolution options
+     * @example
+     * ```ts
+     * const result = await aqua.resolve({ query: 'https://...', requester: user });
+     * ```
+     */
     resolve(options: ResolveOptions): Promise<ResolveResponse>
+
+    /**
+     * Gets an existing player
+     * @param guildId Guild ID
+     */
     get(guildId: string): Player
+
+    /**
+     * Searches for tracks
+     * @param query Search query
+     * @param requester Requester object
+     * @param source Search source (ytsearch, scsearch, etc)
+     */
     search(
       query: string,
       requester: any,
@@ -68,12 +133,16 @@ declare module 'aqualink' {
 
     // Save/Load Methods
     savePlayer(filePath?: string): Promise<void>
+    savePlayerSync(filePath?: string): void
     loadPlayers(filePath?: string): Promise<void>
 
     // Failover and Migration Methods
     handleNodeFailover(failedNode: Node): Promise<void>
 
     // Utility Methods
+    /**
+     * Destroys the Aqua instance and all players
+     */
     destroy(): Promise<void>
 
     // Internal Methods
@@ -168,7 +237,7 @@ declare module 'aqualink' {
     _isConnecting: boolean
     _debugEnabled: boolean
     _headers: Record<string, string>
-    _boundHandlers: Record<string, Function>
+    _boundHandlers: Record<string, ReturnType<typeof this._boundHandlers>>
 
     // Methods
     connect(): Promise<void>
@@ -244,29 +313,119 @@ declare module 'aqualink' {
     _boundPlayerUpdate: (packet: any) => void
     _boundEvent: (payload: any) => void
     _boundAquaPlayerMove: (oldChannel: string, newChannel: string) => void
+    _lastVoiceChannel: string | null
+    _lastTextChannel: string | null
 
     // Getters
     get previous(): Track | null
     get currenttrack(): Track | null
 
     // Core Methods
-    play(): Promise<Player>
+    /**
+     * Plays a track. If no track is provided, plays the next track in the queue.
+     * @param track The track to play
+     * @param options Options for playback
+     * @example
+     * ```ts
+     * // Play the next track in the queue
+     * await player.play();
+     *
+     * // Play a specific track
+     * await player.play(track);
+     * ```
+     */
+    play(track?: Track | null, options?: { paused?: boolean; startTime?: number; noReplace?: boolean }): Promise<Player>
+
+    /**
+     * Connects the player to a voice channel
+     * @param options Connection options
+     * @example
+     * ```ts
+     * player.connect({
+     *   guildId: '...',
+     *   voiceChannel: '...',
+     *   deaf: true
+     * });
+     * ```
+     */
     connect(options?: ConnectionOptions): Player
+
+    /**
+     * Destroys the player and optionally cleans up resources
+     * @param options Destruction options
+     */
     destroy(options?: {
       preserveClient?: boolean
       skipRemote?: boolean
+      preserveMessage?: boolean
+      preserveReconnecting?: boolean
+      preserveTracks?: boolean
     }): Player
+
+    /**
+     * Pauses or resumes the player
+     * @param paused Whether to pause
+     */
     pause(paused: boolean): Player
+
+    /**
+     * Seeks to a position in the current track
+     * @param position Position in milliseconds
+     */
     seek(position: number): Player
+
+    /**
+     * Stops the playback
+     */
     stop(): Player
+
+    /**
+     * Sets the player volume
+     * @param volume Volume (0-1000)
+     */
     setVolume(volume: number): Player
+
+    /**
+     * Sets the loop mode
+     * @param mode Loop mode (off, track, queue)
+     */
     setLoop(mode: LoopMode | LoopModeName): Player
+
+    /**
+     * Sets the text channel for the player
+     * @param channel Channel ID
+     */
     setTextChannel(channel: string): Player
+
+    /**
+     * Sets the voice channel and moves the player
+     * @param channel Channel ID
+     */
     setVoiceChannel(channel: string): Player
+
+    /**
+     * Disconnects the player from voice
+     */
     disconnect(): Player
+
+    /**
+     * Shuffles the queue
+     */
     shuffle(): Player
+
+    /**
+     * Gets the player queue
+     */
     getQueue(): Queue
+
+    /**
+     * Replays the current track from the beginning
+     */
     replay(): Player
+
+    /**
+     * Skips the current track
+     */
     skip(): Player
 
     // Advanced Methods
@@ -355,9 +514,24 @@ declare module 'aqualink' {
     get thumbnail(): string
 
     // Methods
+    /**
+     * Resolves local artwork/thumbnail
+     */
     resolveThumbnail(url?: string): string | null
+
+    /**
+     * Resolves the track if it needs (re)resolution
+     */
     resolve(aqua: Aqua, opts?: TrackResolutionOptions): Promise<Track | null>
+
+    /**
+     * Checks if the track is valid
+     */
     isValid(): boolean
+
+    /**
+     * Disposes the track and frees resources
+     */
     dispose(): void
 
     // Internal Methods
@@ -380,13 +554,54 @@ declare module 'aqualink' {
     useHttp2: boolean
 
     // Core Methods
+    /**
+     * Sets the session ID for the REST connection
+     * @param sessionId The session ID
+     */
     setSessionId(sessionId: string): void
+
+    /**
+     * Makes a generic request to the Lavalink REST API
+     * @param method HTTP method
+     * @param endpoint API endpoint
+     * @param body Request body
+     */
     makeRequest(method: HttpMethod, endpoint: string, body?: any): Promise<any>
+
+    /**
+     * Updates a player via REST
+     * @param options Update options
+     */
     updatePlayer(options: UpdatePlayerOptions): Promise<any>
+
+    /**
+     * Destroys a player via REST
+     * @param guildId Guild ID
+     */
     destroyPlayer(guildId: string): Promise<any>
+
+    /**
+     * Gets lyrics for a track
+     * @param options Lyrics options
+     */
     getLyrics(options: GetLyricsOptions): Promise<LyricsResponse>
+
+    /**
+     * Subscribes to live lyrics events
+     * @param guildId Guild ID
+     * @param sync Whether to sync with playback
+     */
     subscribeLiveLyrics(guildId: string, sync?: boolean): Promise<any>
+
+    /**
+     * Unsubscribes from live lyrics
+     * @param guildId Guild ID
+     */
     unsubscribeLiveLyrics(guildId: string): Promise<any>
+
+    /**
+     * Gets node statistics
+     */
     getStats(): Promise<NodeStats>
 
     // Additional REST Methods
@@ -421,14 +636,33 @@ declare module 'aqualink' {
     readonly last: Track | null
 
     // Methods
+    /**
+     * Adds a track to the queue
+     * @param track Track to add
+     */
     add(track: Track): Queue
+
+    /**
+     * Adds multiple tracks to the queue
+     * @param tracks Tracks to add
+     */
     add(...tracks: Track[]): Queue
+
     push(track: Track): number
     unshift(track: Track): number
     shift(): Track | undefined
     remove(track: Track): boolean
+
+    /**
+     * Clears the queue
+     */
     clear(): void
+
+    /**
+     * Shuffles the queue
+     */
     shuffle(): Queue
+
     peek(): Track | null
     isEmpty(): boolean
     toArray(): Track[]
@@ -509,6 +743,9 @@ declare module 'aqualink' {
     _updateTimer: NodeJS.Timeout | null
     _hasDebugListeners: boolean
     _hasMoveListeners: boolean
+    _lastSentVoiceKey: string
+    _lastVoiceDataUpdate: number
+    _stateFlags: number
 
     // Methods
     setServerUpdate(data: VoiceServerUpdate['d']): void

package/build/structures/Aqua.js

@@ -1,5 +1,3 @@
-'use strict'
-
 const fs = require('node:fs')
 const readline = require('node:readline')
 const { EventEmitter } = require('tseep')
@@ -23,7 +21,6 @@ const MAX_CONCURRENT_OPS = 10
 const BROKEN_PLAYER_TTL = 300000
 const FAILOVER_CLEANUP_TTL = 600000
 const PLAYER_BATCH_SIZE = 20
-const SEEK_DELAY = 120
 const RECONNECT_DELAY = 400
 const CACHE_VALID_TIME = 12000
 const NODE_TIMEOUT = 30000
@@ -31,8 +28,6 @@ const MAX_CACHE_SIZE = 20
 const MAX_FAILOVER_QUEUE = 50
 const MAX_REBUILD_LOCKS = 100
 const WRITE_BUFFER_SIZE = 100
-const MAX_QUEUE_SAVE = 10
-const MAX_TRACKS_RESTORE = 20
 
 const DEFAULT_OPTIONS = Object.freeze({
   shouldDeleteMessage: false,
@@ -181,7 +176,9 @@ class Aqua extends EventEmitter {
         }
         if (batch.length)
           queueMicrotask(() =>
-            batch.forEach((p) => p.connection.resendVoiceUpdate())
+            batch.forEach((p) => {
+              p.connection.resendVoiceUpdate()
+            })
           )
       }
     }
@@ -257,7 +254,11 @@ class Aqua extends EventEmitter {
     const id = node.name || node.host
     const now = Date.now()
     const cached = this._nodeLoadCache.get(id)
-    if (cached && now - cached.time < 5000) return cached.load
+    if (cached && now - cached.time < 5000) {
+      this._nodeLoadCache.delete(id)
+      this._nodeLoadCache.set(id, cached)
+      return cached.load
+    }
     const stats = node?.stats
     if (!stats) return 0
     const cores = Math.max(1, stats.cpu?.cores || 1)
@@ -267,11 +268,15 @@ 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 })
-    if (this._nodeLoadCache.size > MAX_CACHE_SIZE) {
-      const first = this._nodeLoadCache.keys().next().value
-      this._nodeLoadCache.delete(first)
+    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.set(id, { load, time: now })
     return load
   }
 
@@ -528,7 +533,7 @@ class Aqua extends EventEmitter {
         return newPlayer
       } catch (error) {
         if (retry === maxRetries - 1) throw error
-        await _functions.delay(retryDelay * Math.pow(1.5, retry))
+        await _functions.delay(retryDelay * 1.5 ** retry)
       }
     }
   }
@@ -858,7 +863,7 @@ class Aqua extends EventEmitter {
         buffer.push(JSON.stringify(data))
 
         if (buffer.length >= WRITE_BUFFER_SIZE) {
-          const chunk = buffer.join('\n') + '\n'
+          const chunk = `${buffer.join('\n')}\n`
           buffer.length = 0
           if (!ws.write(chunk)) {
             drainPromise = drainPromise.then(
@@ -868,7 +873,7 @@ class Aqua extends EventEmitter {
         }
       }
 
-      if (buffer.length) ws.write(buffer.join('\n') + '\n')
+      if (buffer.length) ws.write(`${buffer.join('\n')}\n`)
       await drainPromise
       await new Promise((resolve, reject) =>
         ws.end((err) => (err ? reject(err) : resolve()))
@@ -935,7 +940,7 @@ class Aqua extends EventEmitter {
     try {
       const gId = String(p.g)
       const existing = this.players.get(gId)
-      if (existing && existing.playing) return
+      if (existing?.playing) return
 
       const player =
         existing ||
@@ -1068,7 +1073,6 @@ class Aqua extends EventEmitter {
             break
           }
         } catch {
-          continue
         }
       }
     } catch {
@@ -1079,4 +1083,4 @@ class Aqua extends EventEmitter {
   }
 }
 
-module.exports = Aqua
+module.exports = Aqua

package/build/structures/AqualinkEvents.js

@@ -1,5 +1,3 @@
-'use strict'
-
 const AqualinkEvents = {
   TrackStart: 'trackStart',
   TrackEnd: 'trackEnd',

package/build/structures/Connection.js

@@ -1,5 +1,3 @@
-'use strict'
-
 const { AqualinkEvents } = require('./AqualinkEvents')
 
 const POOL_SIZE = 12
@@ -216,8 +214,9 @@ class Connection {
     this._scheduleVoiceUpdate()
   }
 
-  resendVoiceUpdate() {
+  resendVoiceUpdate(force = false) {
     if (this._destroyed || !this._hasValidVoiceData()) return false
+    if (force) this._lastSentVoiceKey = ''
     this._scheduleVoiceUpdate()
     return true
   }
@@ -456,17 +455,7 @@ class Connection {
   _makeVoiceKey() {
     const p = this._player
     const vol = p?.volume ?? 100
-    return (
-      (this.sessionId || '') +
-      '|' +
-      (this.token || '') +
-      '|' +
-      (this.endpoint || '') +
-      '|' +
-      (p?.voiceChannel || '') +
-      '|' +
-      vol
-    )
+    return `${this.sessionId || ''}|${this.token || ''}|${this.endpoint || ''}|${p?.voiceChannel || ''}|${vol}`
   }
 
   _scheduleVoiceUpdate() {
@@ -538,11 +527,15 @@ class Connection {
       await this._rest.updatePlayer(payload)
     } catch (e) {
       if (e.statusCode === 404 || e.response?.statusCode === 404) {
+        const isSessionError = e.body?.message?.includes('sessionId') || false
         if (this._aqua) {
           this._aqua.emit(
             AqualinkEvents.Debug,
-            `Player ${this._guildId} not found (404). Destroying.`
+            `[Aqua/Connection] Player ${this._guildId} not found (404)${isSessionError ? ' - Session invalid' : ''}. Destroying.`
           )
+          if (isSessionError && this._player?.nodes?._clearSession) {
+            this._player.nodes._clearSession()
+          }
           await this._aqua.destroyPlayer(this._guildId)
         }
         throw e
@@ -581,4 +574,4 @@ class Connection {
   }
 }
 
-module.exports = Connection
+module.exports = Connection

package/build/structures/Filters.js

@@ -1,5 +1,3 @@
-'use strict'
-
 const FILTER_DEFAULTS = Object.freeze({
   karaoke: Object.freeze({
     level: 1,
@@ -41,6 +39,27 @@ const FILTER_KEYS = Object.freeze(
 
 const EMPTY_ARRAY = Object.freeze([])
 
+const FILTER_POOL_SIZE = 16
+const filterPool = {
+  pools: Object.fromEntries(Object.keys(FILTER_DEFAULTS).map(k => [k, []])),
+
+  acquire(type) {
+    const pool = this.pools[type]
+    if (pool && pool.length > 0) {
+      return pool.pop()
+    }
+    return { ...FILTER_DEFAULTS[type] }
+  },
+
+  release(type, obj) {
+    if (!obj || !this.pools[type]) return
+    const pool = this.pools[type]
+    if (pool.length < FILTER_POOL_SIZE) {
+      pool.push(obj)
+    }
+  }
+}
+
 const _utils = Object.freeze({
   shallowEqual(current, defaults, override, keys) {
     if (!current) return false
@@ -73,6 +92,19 @@ const _utils = Object.freeze({
     const out = new Array(len)
     for (let i = 0; i < len; i++) out[i] = { band: i, gain }
     return out
+  },
+
+  mutateFilter(target, defaults, options, keys) {
+    let changed = false
+    for (let i = 0; i < keys.length; i++) {
+      const k = keys[i]
+      const newVal = k in options ? options[k] : defaults[k]
+      if (target[k] !== newVal) {
+        target[k] = newVal
+        changed = true
+      }
+    }
+    return changed
   }
 })
 
@@ -106,6 +138,11 @@ class Filters {
   }
 
   destroy() {
+    for (const [key, value] of Object.entries(this.filters)) {
+      if (value && typeof value === 'object' && key !== 'equalizer') {
+        filterPool.release(key, value)
+      }
+    }
     this._pendingUpdate = false
     this.player = null
   }
@@ -114,16 +151,27 @@ class Filters {
     const current = this.filters[filterName]
     if (!enabled) {
       if (current === null) return this
+      filterPool.release(filterName, current)
       this.filters[filterName] = null
+      this._dirty.add(filterName)
       return this._scheduleUpdate()
     }
 
     const defaults = FILTER_DEFAULTS[filterName]
     const keys = FILTER_KEYS[filterName]
-    if (current && _utils.shallowEqual(current, defaults, options, keys))
-      return this
 
-    this.filters[filterName] = Object.assign({}, defaults, options)
+    if (current) {
+      if (_utils.shallowEqual(current, defaults, options, keys)) {
+        return this
+      }
+      _utils.mutateFilter(current, defaults, options, keys)
+      this._dirty.add(filterName)
+      return this._scheduleUpdate()
+    }
+
+    const newFilter = filterPool.acquire(filterName)
+    _utils.mutateFilter(newFilter, defaults, options, keys)
+    this.filters[filterName] = newFilter
     this._dirty.add(filterName)
     return this._scheduleUpdate()
   }

package/build/structures/Node.js

@@ -1,5 +1,3 @@
-'use strict'
-
 const IS_BUN = !!(process?.isBun || process?.versions?.bun || globalThis.Bun)
 if (process && typeof process.isBun !== 'boolean') process.isBun = IS_BUN
 
@@ -263,7 +261,6 @@ 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
 
@@ -343,7 +340,7 @@ class Node {
   _calcBackoff(attempt) {
     const baseBackoff =
       this.reconnectTimeout *
-      Math.pow(Node.BACKOFF_MULTIPLIER, Math.min(attempt, 10))
+      Node.BACKOFF_MULTIPLIER ** Math.min(attempt, 10)
     const maxJitter = Math.min(
       Node.JITTER_MAX,
       baseBackoff * Node.JITTER_FACTOR
@@ -667,4 +664,4 @@ class Node {
   }
 }
 
-module.exports = Node
+module.exports = Node

package/build/structures/Player.js

@@ -1,5 +1,3 @@
-'use strict'
-
 const { EventEmitter } = require('tseep')
 const { AqualinkEvents } = require('./AqualinkEvents')
 const Connection = require('./Connection')
@@ -41,7 +39,6 @@ const WATCHDOG_INTERVAL = 15000
 const VOICE_DOWN_THRESHOLD = 10000
 const VOICE_ABANDON_MULTIPLIER = 12
 const RECONNECT_MAX = 15
-const RESUME_TIMEOUT = 5000
 const MUTE_TOGGLE_DELAY = 300
 const SEEK_DELAY = 800
 const PAUSE_DELAY = 1200
@@ -263,10 +260,16 @@ class Player extends EventEmitter {
     this.timestamp = _functions.isNum(s.time) ? s.time : Date.now()
 
     if (!this.connected) {
-      if (!this._voiceDownSince) {
+      if (!this._voiceDownSince && !this._reconnecting && !this._voiceRecovering) {
         this._voiceDownSince = Date.now()
         this._createTimer(() => {
-          if (this.connected || this.destroyed || this.nodes?.info?.isNodelink)
+          if (
+            this.connected ||
+            this.destroyed ||
+            this._reconnecting ||
+            this._voiceRecovering ||
+            this.nodes?.info?.isNodelink
+          )
             return
           this.connection.attemptResume()
         }, 1000)
@@ -387,7 +390,9 @@ class Player extends EventEmitter {
       this.nodes?.info?.isNodelink ||
       this.destroyed ||
       !this.voiceChannel ||
-      this.connected
+      this.connected ||
+      this._reconnecting ||
+      this._voiceRecovering
     )
       return false
     if (
@@ -395,7 +400,7 @@ class Player extends EventEmitter {
       Date.now() - this._voiceDownSince < VOICE_DOWN_THRESHOLD
     )
       return false
-    return !this._voiceRecovering && this.reconnectionRetries < RECONNECT_MAX
+    return this.reconnectionRetries < RECONNECT_MAX
   }
 
   async _voiceWatchdog() {
@@ -479,6 +484,7 @@ class Player extends EventEmitter {
     this.autoplayRetries = this.reconnectionRetries = 0
     if (!preserveReconnecting) this._reconnecting = false
     this._lastVoiceChannel = this.voiceChannel
+    this._lastTextChannel = this.textChannel
     this.voiceChannel = null
 
     if (
@@ -728,7 +734,7 @@ class Player extends EventEmitter {
       this.destroyed ||
       !this.isAutoplayEnabled ||
       !this.previous ||
-      (this.queue && this.queue.size)
+      (this.queue?.size)
     )
       return this
     const prev = this.previous
@@ -947,18 +953,21 @@ class Player extends EventEmitter {
   }
 
   async socketClosed(player, track, payload) {
-    if (this.destroyed) return
+    if (this.destroyed || this._reconnecting) return
+
     const code = payload?.code
     let isRecoverable = [4015, 4009, 4006, 4014, 4022].includes(code)
     if (code === 4014 && this.connection?.isWaitingForDisconnect)
       isRecoverable = false
 
     if (code === 4015 && !this.nodes?.info?.isNodelink) {
+      this._reconnecting = true
       try {
         await this._attemptVoiceResume()
+        this._reconnecting = false
         return
       } catch {
-        /* ignore */
+        this._reconnecting = false
       }
     }
 
@@ -974,8 +983,6 @@ class Player extends EventEmitter {
       if (code === 4022) this._suppressResumeUntil = Date.now() + 3000
     }
 
-    if (this._reconnecting) return
-
     const aqua = this.aqua
     const vcId = _functions.toId(this.voiceChannel)
     const tcId = _functions.toId(this.textChannel)
@@ -1102,7 +1109,10 @@ class Player extends EventEmitter {
 
   set(key, value) {
     if (this.destroyed) return
-    ;(this._dataStore || (this._dataStore = new Map())).set(key, value)
+    if (!this._dataStore) {
+      this._dataStore = new Map()
+    }
+    this._dataStore.set(key, value)
   }
 
   get(key) {

package/build/structures/Queue.js

@@ -1,5 +1,3 @@
-'use strict'
-
 class Queue {
   constructor() {
     this._items = []
@@ -41,10 +39,15 @@ class Queue {
   }
 
   shuffle() {
-    // Compact first if needed
     if (this._head > 0) {
-      this._items = this._items.slice(this._head)
-      this._head = 0
+      if (this._head > 0) {
+        const len = this._items.length - this._head
+        for (let i = 0; i < len; i++) {
+          this._items[i] = this._items[this._head + i]
+        }
+        this._items.length = len
+        this._head = 0
+      }
     }
     for (let i = this._items.length - 1; i > 0; i--) {
       const j = Math.floor(Math.random() * (i + 1))
@@ -103,9 +106,12 @@ class Queue {
     const item = this._items[this._head]
     this._items[this._head] = undefined // Allow GC
     this._head++
-    // Compact when head is > 50% of array to prevent unbounded growth
     if (this._head > 0 && this._head > this._items.length / 2) {
-      this._items = this._items.slice(this._head)
+      const len = this._items.length - this._head
+      for (let i = 0; i < len; i++) {
+        this._items[i] = this._items[this._head + i]
+      }
+      this._items.length = len
       this._head = 0
     }
     return item

package/build/structures/Rest.js

@@ -1,9 +1,7 @@
-'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 { Buffer } = require('node:buffer')
+const { Agent: HttpsAgent, request: httpsRequest } = require('node:https')
+const { Agent: HttpAgent, request: httpRequest } = require('node:http')
+const http2 = require('node:http2')
 const {
   createBrotliDecompress,
   createUnzip,
@@ -11,7 +9,12 @@ const {
   unzipSync,
   createZstdDecompress,
   zstdDecompressSync
-} = require('zlib')
+} = require('node:zlib')
+
+let autoplayModule = null
+try {
+  autoplayModule = require('../handlers/autoplay')
+} catch {}
 
 const unrefTimer = (t) => {
   try {
@@ -203,6 +206,10 @@ class Rest {
     this.agent = new (node.ssl ? HttpsAgent : HttpAgent)(opts)
     this.request = node.ssl ? httpsRequest : httpRequest
 
+    if (node.ssl && autoplayModule?.setSharedAgent) {
+      autoplayModule.setSharedAgent(this.agent)
+    }
+
     const origCreate = this.agent.createConnection.bind(this.agent)
     this.agent.createConnection = (options, cb) => {
       const socket = origCreate(options, cb)
@@ -847,4 +854,4 @@ class Rest {
   }
 }
 
-module.exports = Rest
+module.exports = Rest

package/build/structures/Track.js

@@ -1,5 +1,3 @@
-'use strict'
-
 const YT_ID_REGEX =
   /(?:[?&]v=|youtu\.be\/|\/embed\/|\/shorts\/)([A-Za-z0-9_-]{11})/
 
@@ -30,10 +28,12 @@ class Track {
     this.nodes = data.nodes || null
     this.requester = requester || null
     this._infoCache = null
+    this._artworkCache = undefined  // undefined = not computed, null = computed but no artwork
   }
 
   get info() {
-    return (this._infoCache ||= Object.freeze({
+    if (this._infoCache) return this._infoCache
+    this._infoCache = Object.freeze({
       identifier: this.identifier,
       isSeekable: this.isSeekable,
       position: this.position,
@@ -44,7 +44,8 @@ class Track {
       uri: this.uri,
       sourceName: this.sourceName,
       artworkUrl: this.artworkUrl || this._computeArtwork()
-    }))
+    })
+    return this._infoCache
   }
 
   get length() {
@@ -52,7 +53,10 @@ class Track {
   }
 
   get thumbnail() {
-    return this.artworkUrl || this._computeArtwork()
+    if (this.artworkUrl) return this.artworkUrl
+    if (this._artworkCache !== undefined) return this._artworkCache
+    this._artworkCache = this._computeArtwork()
+    return this._artworkCache
   }
 
   async resolve(aqua, opts = {}) {
@@ -140,10 +144,13 @@ class Track {
 
   _computeArtwork() {
     if (this.artworkUrl) return this.artworkUrl
+    if (this._artworkCache !== undefined) return this._artworkCache
     const id = this.identifier || (this.uri && YT_ID_REGEX.exec(this.uri)?.[1])
     if (id && this.sourceName?.includes('youtube')) {
-      return `https://i.ytimg.com/vi/${id}/hqdefault.jpg`
+      this._artworkCache = `https://i.ytimg.com/vi/${id}/hqdefault.jpg`
+      return this._artworkCache
     }
+    this._artworkCache = null
     return null
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aqualink",
-  "version": "2.19.0",
+  "version": "2.19.1",
   "description": "An Lavalink/Nodelink client, focused in pure performance and features",
   "main": "./build/index.js",
   "types": "./build/index.d.ts",