aqualink 2.19.0 → 2.20.0

package/build/structures/Connection.js

@@ -1,5 +1,3 @@
-'use strict'
-
 const { AqualinkEvents } = require('./AqualinkEvents')
 
 const POOL_SIZE = 12
@@ -50,6 +48,17 @@ const _functions = {
     const label = (dot === -1 ? endpoint : endpoint.slice(0, dot)).toLowerCase()
     if (!label) return 'unknown'
 
+    // Discord voice hosts commonly look like: c-gru20-<hash>.discord.media
+    const cPrefix = /^c-([a-z]{3})(?:\d+)?(?:-|$)/
+    const m1 = cPrefix.exec(label)
+    if (m1?.[1]) return m1[1]
+
+    // Fallback for labels that still contain an iata-like token.
+    const token = /(?:^|-)([a-z]{3})(?:\d+)?(?:-|$)/
+    const m2 = token.exec(label)
+    if (m2?.[1]) return m2[1]
+
+    // Last fallback: strip trailing digits from first label.
     let i = label.length - 1
     while (i >= 0) {
       const c = label.charCodeAt(i)
@@ -58,15 +67,13 @@ const _functions = {
     }
     return label.slice(0, i + 1) || 'unknown'
   },
-  fillVoicePayload: (payload, guildId, conn, player, resume) => {
+  fillVoicePayload: (payload, guildId, conn, player) => {
     payload.guildId = guildId
     const v = payload.data.voice
     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
     return payload
   }
@@ -85,9 +92,7 @@ class PayloadPool {
         voice: {
           token: null,
           endpoint: null,
-          sessionId: null,
-          resume: undefined,
-          sequence: undefined
+          sessionId: null
         },
         volume: null
       }
@@ -103,7 +108,6 @@ class PayloadPool {
     payload.guildId = null
     const v = payload.data.voice
     v.token = v.endpoint = v.sessionId = null
-    v.resume = v.sequence = undefined
     payload.data.volume = null
     this._pool[this._size++] = payload
   }
@@ -153,6 +157,7 @@ class Connection {
 
     this._lastStateReqAt = 0
     this._stateGeneration = 0
+    this._regionMigrationAttempted = false
   }
 
   _hasValidVoiceData() {
@@ -203,6 +208,7 @@ class Connection {
       this._lastEndpoint = endpoint
       this._reconnectAttempts = 0
       this._consecutiveFailures = 0
+      this._regionMigrationAttempted = false
     }
 
     this.endpoint = endpoint
@@ -210,14 +216,76 @@ class Connection {
     this.token = data.token
     this.channelId = data.channel_id || this.channelId || this.voiceChannel
     this._lastVoiceDataUpdate = Date.now()
+    this._aqua?._trace?.('connection.serverUpdate', {
+      guildId: this._guildId,
+      endpoint: this.endpoint,
+      region: this.region,
+      txId: data.txId || null
+    })
     this._stateFlags &= ~STATE.VOICE_DATA_STALE
 
     if (this._player?.paused) this._player.pause(false)
+    const migrated = this._checkRegionMigration()
+    if (migrated) return
     this._scheduleVoiceUpdate()
+    this._player?._flushDeferredPlay?.()
+  }
+
+  _checkRegionMigration() {
+    if (this._destroyed || this._regionMigrationAttempted) return false
+    if (
+      !this._aqua?.autoRegionMigrate ||
+      !this.region ||
+      this.region === 'unknown'
+    )
+      return false
+    const player = this._player
+    if (!player || player.destroyed || player._resuming || player._reconnecting)
+      return false
+
+    const currentNode = player.nodes
+    if (!currentNode) return false
+
+    const currentRegions = Array.isArray(currentNode.regions)
+      ? currentNode.regions
+      : []
+    const alreadyMatching = currentRegions.some((r) =>
+      this._aqua._regionMatches?.(r, this.region)
+    )
+    if (alreadyMatching) {
+      this._regionMigrationAttempted = true
+      return false
+    }
+
+    const targetNode = this._aqua._findBestNodeForRegion?.(this.region)
+    if (!targetNode || targetNode === currentNode) return false
+
+    this._regionMigrationAttempted = true
+    this._aqua?._trace?.('connection.region.migrate', {
+      guildId: this._guildId,
+      region: this.region,
+      from: currentNode?.name || currentNode?.host,
+      to: targetNode?.name || targetNode?.host
+    })
+
+    queueMicrotask(() => {
+      this._aqua
+        .movePlayerToNode?.(this._guildId, targetNode, 'region')
+        .catch((err) => {
+          this._regionMigrationAttempted = false
+          this._aqua?._trace?.('connection.region.migrate.error', {
+            guildId: this._guildId,
+            region: this.region,
+            error: err?.message || String(err)
+          })
+        })
+    })
+    return true
   }
 
-  resendVoiceUpdate() {
+  resendVoiceUpdate(force = false) {
     if (this._destroyed || !this._hasValidVoiceData()) return false
+    if (force) this._lastSentVoiceKey = ''
     this._scheduleVoiceUpdate()
     return true
   }
@@ -238,6 +306,10 @@ class Connection {
     if (data.txId && data.txId < this.txId) return
 
     if (!channelId) {
+      this._aqua?._trace?.('connection.stateUpdate.nullChannel', {
+        guildId: this._guildId,
+        txId: data.txId || null
+      })
       this.isWaitingForDisconnect = true
       if (!this._nullChannelTimer) {
         this._nullChannelTimer = setTimeout(() => {
@@ -250,6 +322,12 @@ class Connection {
     }
 
     this.isWaitingForDisconnect = false
+    this._aqua?._trace?.('connection.stateUpdate', {
+      guildId: this._guildId,
+      channelId,
+      sessionId,
+      txId: data.txId || null
+    })
 
     if (p && p.txId > this.txId) this.txId = p.txId
 
@@ -290,6 +368,9 @@ class Connection {
 
     this._stateFlags =
       (this._stateFlags | STATE.DISCONNECTING) & ~STATE.CONNECTED
+    this._aqua?._trace?.('connection.disconnect', {
+      guildId: this._guildId
+    })
     this._clearNullChannelTimer()
     this._clearPendingUpdate()
     this._clearReconnectTimer()
@@ -339,6 +420,13 @@ class Connection {
 
   async attemptResume() {
     if (!this._canAttemptResumeCore()) return false
+    this._aqua?._trace?.('connection.resume.attempt', {
+      guildId: this._guildId,
+      reconnectAttempts: this._reconnectAttempts,
+      hasSessionId: !!this.sessionId,
+      hasEndpoint: !!this.endpoint,
+      hasToken: !!this.token
+    })
 
     const currentGen = this._stateGeneration
 
@@ -383,6 +471,9 @@ class Connection {
       }
 
       await this._sendUpdate(payload)
+      this._aqua?._trace?.('connection.resume.success', {
+        guildId: this._guildId
+      })
 
       this._reconnectAttempts = 0
       this._consecutiveFailures = 0
@@ -400,6 +491,10 @@ class Connection {
         AqualinkEvents.Debug,
         `Resume failed for guild ${this._guildId}: ${e?.message || e}`
       )
+      this._aqua?._trace?.('connection.resume.error', {
+        guildId: this._guildId,
+        error: e?.message || String(e)
+      })
 
       if (
         this._reconnectAttempts < MAX_RECONNECT_ATTEMPTS &&
@@ -456,22 +551,27 @@ 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() {
-    if (this._destroyed) return
-    if (!this._hasValidVoiceData()) return
+    if (this._destroyed) {
+      this._aqua?._trace?.('connection.update.skip', {
+        guildId: this._guildId,
+        reason: 'destroyed'
+      })
+      return
+    }
+    if (!this._hasValidVoiceData()) {
+      this._aqua?._trace?.('connection.update.skip', {
+        guildId: this._guildId,
+        reason: 'invalid_voice_data',
+        hasSessionId: !!this.sessionId,
+        hasEndpoint: !!this.endpoint,
+        hasToken: !!this.token
+      })
+      return
+    }
 
     if (!this._pendingUpdate) {
       const payload = sharedPool.acquire()
@@ -496,6 +596,9 @@ class Connection {
 
     if (this._stateFlags & STATE.UPDATE_SCHEDULED) return
     this._stateFlags |= STATE.UPDATE_SCHEDULED
+    this._aqua?._trace?.('connection.update.scheduled', {
+      guildId: this._guildId
+    })
 
     this._voiceFlushTimer = setTimeout(
       () => this._executeVoiceUpdate(),
@@ -535,14 +638,32 @@ class Connection {
     if (!this._rest) throw new Error('REST interface unavailable')
 
     try {
+      this._aqua?._trace?.('connection.update.send', {
+        guildId: this._guildId,
+        hasSessionId: !!this._rest?.sessionId,
+        hasVoice:
+          !!payload?.data?.voice?.sessionId && !!payload?.data?.voice?.endpoint
+      })
       await this._rest.updatePlayer(payload)
+      this._aqua?._trace?.('connection.update.ok', {
+        guildId: this._guildId
+      })
     } catch (e) {
+      this._aqua?._trace?.('connection.update.error', {
+        guildId: this._guildId,
+        statusCode: e?.statusCode || e?.response?.statusCode || null,
+        error: e?.message || String(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

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
 
@@ -189,6 +187,10 @@ class Node {
     this._isConnecting = false
     this.reconnectAttempted = 0
     this._emitDebug('WebSocket connection established')
+    this.aqua?._trace?.('node.ws.open', {
+      node: this.name,
+      reconnectAttempted: this.reconnectAttempted
+    })
 
     if (!this.aqua?.bypassChecks?.nodeFetchInfo && !this.info) {
       const timeoutId = setTimeout(() => {
@@ -263,7 +265,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
 
@@ -271,6 +272,12 @@ class Node {
       code,
       reason: _functions.reasonToString(reason)
     })
+    this.aqua?._trace?.('node.ws.close', {
+      node: this.name,
+      code,
+      reason: _functions.reasonToString(reason),
+      hasSessionId: !!this.sessionId
+    })
 
     if (this.isDestroyed) return
 
@@ -304,6 +311,11 @@ class Node {
     this._clearReconnectTimeout()
 
     const attempt = ++this.reconnectAttempted
+    this.aqua?._trace?.('node.ws.reconnect.scheduled', {
+      node: this.name,
+      attempt,
+      infinite: !!this.infiniteReconnects
+    })
 
     if (this.infiniteReconnects) {
       this.aqua.emit(AqualinkEvents.NodeReconnect, this, {
@@ -342,8 +354,7 @@ class Node {
 
   _calcBackoff(attempt) {
     const baseBackoff =
-      this.reconnectTimeout *
-      Math.pow(Node.BACKOFF_MULTIPLIER, Math.min(attempt, 10))
+      this.reconnectTimeout * Node.BACKOFF_MULTIPLIER ** Math.min(attempt, 10)
     const maxJitter = Math.min(
       Node.JITTER_MAX,
       baseBackoff * Node.JITTER_FACTOR
@@ -373,6 +384,10 @@ class Node {
     this._isConnecting = true
     this.state = NODE_STATE.CONNECTING
     this._cleanup()
+    this.aqua?._trace?.('node.ws.connect', {
+      node: this.name,
+      url: this.wsUrl
+    })
 
     try {
       const h = this._boundHandlers
@@ -573,6 +588,12 @@ class Node {
       oldSessionId && oldSessionId !== sessionId && !payload.resumed
 
     this.sessionId = sessionId
+    this.aqua?._trace?.('node.ready.packet', {
+      node: this.name,
+      resumed: !!payload.resumed,
+      oldSessionId,
+      newSessionId: sessionId
+    })
     this.rest.setSessionId(sessionId)
     this._headers['Session-Id'] = sessionId
 
@@ -614,6 +635,11 @@ class Node {
 
   async _resumePlayers() {
     if (!this.sessionId) return
+    this.aqua?._trace?.('node.resume.begin', {
+      node: this.name,
+      sessionId: this.sessionId,
+      players: this.aqua?.players?.size || 0
+    })
 
     try {
       await this.rest.makeRequest('PATCH', `/v4/sessions/${this.sessionId}`, {
@@ -629,6 +655,11 @@ class Node {
           ) {
             try {
               this._emitDebug(`Rejoining voice for guild ${guildId} on resume`)
+              this.aqua?._trace?.('node.resume.rejoin', {
+                node: this.name,
+                guildId,
+                voiceChannel: player.voiceChannel
+              })
               player.connect({
                 voiceChannel: player.voiceChannel,
                 deaf: player.deaf,
@@ -647,6 +678,10 @@ class Node {
         await this.aqua.loadPlayers()
       }
     } catch (err) {
+      this.aqua?._trace?.('node.resume.error', {
+        node: this.name,
+        error: _functions.errMsg(err)
+      })
       this._emitError(`Failed to resume session: ${_functions.errMsg(err)}`)
       throw err
     }