aqualink 2.19.1 → 2.20.0

package/build/structures/Connection.js

@@ -48,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)
@@ -56,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
   }
@@ -83,9 +92,7 @@ class PayloadPool {
         voice: {
           token: null,
           endpoint: null,
-          sessionId: null,
-          resume: undefined,
-          sequence: undefined
+          sessionId: null
         },
         volume: null
       }
@@ -101,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
   }
@@ -151,6 +157,7 @@ class Connection {
 
     this._lastStateReqAt = 0
     this._stateGeneration = 0
+    this._regionMigrationAttempted = false
   }
 
   _hasValidVoiceData() {
@@ -201,6 +208,7 @@ class Connection {
       this._lastEndpoint = endpoint
       this._reconnectAttempts = 0
       this._consecutiveFailures = 0
+      this._regionMigrationAttempted = false
     }
 
     this.endpoint = endpoint
@@ -208,10 +216,71 @@ 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(force = false) {
@@ -237,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(() => {
@@ -249,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
 
@@ -289,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()
@@ -338,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
 
@@ -382,6 +471,9 @@ class Connection {
       }
 
       await this._sendUpdate(payload)
+      this._aqua?._trace?.('connection.resume.success', {
+        guildId: this._guildId
+      })
 
       this._reconnectAttempts = 0
       this._consecutiveFailures = 0
@@ -399,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 &&
@@ -459,8 +555,23 @@ class Connection {
   }
 
   _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()
@@ -485,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(),
@@ -524,8 +638,22 @@ 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) {
@@ -574,4 +702,4 @@ class Connection {
   }
 }
 
-module.exports = Connection
+module.exports = Connection

package/build/structures/Filters.js

@@ -41,7 +41,7 @@ const EMPTY_ARRAY = Object.freeze([])
 
 const FILTER_POOL_SIZE = 16
 const filterPool = {
-  pools: Object.fromEntries(Object.keys(FILTER_DEFAULTS).map(k => [k, []])),
+  pools: Object.fromEntries(Object.keys(FILTER_DEFAULTS).map((k) => [k, []])),
 
   acquire(type) {
     const pool = this.pools[type]

package/build/structures/Node.js

@@ -187,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(() => {
@@ -268,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
 
@@ -301,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, {
@@ -339,8 +354,7 @@ class Node {
 
   _calcBackoff(attempt) {
     const baseBackoff =
-      this.reconnectTimeout *
-      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
@@ -370,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
@@ -570,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
 
@@ -611,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}`, {
@@ -626,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,
@@ -644,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
     }
@@ -664,4 +702,4 @@ class Node {
   }
 }
 
-module.exports = Node
+module.exports = Node