aqualink 2.11.5 → 2.11.7

package/build/structures/Aqua.js

@@ -28,6 +28,7 @@ const DEFAULT_OPTIONS = Object.freeze({
   plugins: [],
   autoResume: false,
   infiniteReconnects: false,
+  loadBancer: 'leastLoad', // cpu, memory, rest: leastLoad, only rest: leastRest, no check: random
   failoverOptions: Object.freeze({
     enabled: true,
     maxRetries: 3,
@@ -142,21 +143,37 @@ class Aqua extends EventEmitter {
   }
 
   get leastUsedNodes() {
-    const now = Date.now()
+    const now = Date.now();
     if (this._leastUsedNodesCache && (now - this._leastUsedNodesCacheTime) < CACHE_VALID_TIME) {
-      return this._leastUsedNodesCache
+      return this._leastUsedNodesCache;
     }
 
-    const connected = []
+    const connected = [];
     for (const node of this.nodeMap.values()) {
-      if (node.connected) connected.push(node)
+      if (node.connected) connected.push(node);
     }
 
-    connected.sort((a, b) => this._getCachedNodeLoad(a) - this._getCachedNodeLoad(b))
+    let sorted;
+    switch (this.options.loadBancer) {
+      case 'leastRest':
+        sorted = connected.slice().sort((a, b) => {
+          const restA = a?.rest?.calls || 0;
+          const restB = b?.rest?.calls || 0;
+          return restA - restB;
+        });
+        break;
+      case 'random':
+        sorted = Array.from(connected);
+        break;
+      case 'leastLoad':
+      default:
+        sorted = connected.slice().sort((a, b) => this._getCachedNodeLoad(a) - this._getCachedNodeLoad(b));
+        break;
+    }
 
-    this._leastUsedNodesCache = Object.freeze(connected.slice())
-    this._leastUsedNodesCacheTime = now
-    return this._leastUsedNodesCache
+    this._leastUsedNodesCache = Object.freeze(sorted);
+    this._leastUsedNodesCacheTime = now;
+    return this._leastUsedNodesCache;
   }
 
   _invalidateCache() {

package/build/structures/Connection.js

@@ -142,8 +142,8 @@ class Connection {
 
   setServerUpdate(data) {
     if (!data?.endpoint || !data.token ||
-        typeof data.endpoint !== 'string' ||
-        typeof data.token !== 'string') {
+      typeof data.endpoint !== 'string' ||
+      typeof data.token !== 'string') {
       return
     }
 
@@ -175,18 +175,18 @@ class Connection {
     this.token = data.token
 
     if (this._player.paused) {
-      this._player.paused = false
+      this._player.pause(false)
     }
 
     this._scheduleVoiceUpdate()
   }
 
-  resendVoiceUpdate({ resume = false } = {}) {
+  resendVoiceUpdate() {  // Remove the parameter
     if (!(this.sessionId && this.endpoint && this.token)) {
       return false
     }
 
-    this._scheduleVoiceUpdate(resume)
+    this._scheduleVoiceUpdate()  // No parameter needed
     return true
   }
 
@@ -201,9 +201,7 @@ class Connection {
       let needsUpdate = false
 
       if (this.voiceChannel !== channel_id) {
-        if (this._stateFlags & STATE_FLAGS.HAS_MOVE_LISTENERS) {
-          this._aqua.emit('playerMove', this.voiceChannel, channel_id)
-        }
+        this._aqua.emit('playerMove', this.voiceChannel, channel_id)
         this.voiceChannel = channel_id
         this._player.voiceChannel = channel_id
         needsUpdate = true
@@ -249,32 +247,29 @@ class Connection {
 
   async attemptResume() {
     if (!(this.sessionId && this.endpoint && this.token)) {
-      throw new Error('Missing required voice state')
+      return false;
     }
 
-    const payload = this._payloadPool.acquire()
+    const payload = this._payloadPool.acquire(); // USE THE POOL
 
     try {
-      payload.guildId = this._guildId
-      payload.data.voice.token = this.token
-      payload.data.voice.endpoint = this.endpoint
-      payload.data.voice.sessionId = this.sessionId
-      payload.data.voice.resume = true
-      payload.data.volume = this._player?.volume
-
-      if (this.sequence >= 0 && Number.isFinite(this.sequence)) {
-        payload.data.voice.sequence = this.sequence
-      }
-
-      await this._sendUpdate(payload)
-      return true
+      payload.guildId = this._guildId;
+      payload.data.voice.token = this.token;
+      payload.data.voice.endpoint = this.endpoint;
+      payload.data.voice.sessionId = this.sessionId;
+      payload.data.voice.resume = true;
+      payload.data.volume = this._player?.volume;
+
+      await this._sendUpdate(payload);
+      return true;
     } catch (error) {
+      console.log(`Voice connection resume failed in guild ${this._guildId}: ${error?.message}`);
       if (this._stateFlags & STATE_FLAGS.HAS_DEBUG_LISTENERS) {
-        this._aqua.emit('debug', `[Player ${this._guildId}] Resume update failed: ${error?.message}`)
+        this._aqua.emit('debug', `[Player ${this._guildId}] Voice update failed: ${error?.message}`);
       }
-      return false
+      return false;
     } finally {
-      this._payloadPool.release(payload)
+      this._payloadPool.release(payload); // ALWAYS RELEASE
     }
   }
 
@@ -294,40 +289,31 @@ class Connection {
     this._pendingUpdate = null
   }
 
-  _scheduleVoiceUpdate(isResume = false) {
+  _scheduleVoiceUpdate() {
     if (!(this.sessionId && this.endpoint && this.token)) {
-      return
+      return;
     }
 
     if (this._stateFlags & STATE_FLAGS.UPDATE_SCHEDULED) {
-      return
+      return;
     }
 
-    this._clearPendingUpdate()
-
-    const payload = this._payloadPool.acquire()
+    this._clearPendingUpdate();
 
-    payload.guildId = this._guildId
-    const voice = payload.data.voice
-    voice.token = this.token
-    voice.endpoint = this.endpoint
-    voice.sessionId = this.sessionId
-    payload.data.volume = this._player.volume
-
-    if (isResume) {
-      voice.resume = true
-      voice.sequence = this.sequence
-    }
+    const payload = this._payloadPool.acquire();
+    payload.guildId = this._guildId;
+    payload.data.voice.token = this.token;
+    payload.data.voice.endpoint = this.endpoint;
+    payload.data.voice.sessionId = this.sessionId;
+    payload.data.volume = this._player.volume;
 
     this._pendingUpdate = {
-      isResume,
       payload,
       timestamp: Date.now()
-    }
-
-    this._stateFlags |= STATE_FLAGS.UPDATE_SCHEDULED
+    };
 
-    queueMicrotask(this._executeVoiceUpdate)
+    this._stateFlags |= STATE_FLAGS.UPDATE_SCHEDULED;
+    queueMicrotask(this._executeVoiceUpdate);
   }
 
   _executeVoiceUpdate() {
@@ -366,8 +352,8 @@ class Connection {
       await this._nodes.rest.updatePlayer(payload)
     } catch (error) {
       if (error.code !== 'ECONNREFUSED' &&
-          error.code !== 'ENOTFOUND' &&
-          (this._stateFlags & STATE_FLAGS.HAS_DEBUG_LISTENERS)) {
+        error.code !== 'ENOTFOUND' &&
+        (this._stateFlags & STATE_FLAGS.HAS_DEBUG_LISTENERS)) {
         this._aqua.emit('debug', `[Player ${this._guildId}] Update failed: ${error.message}`)
       }
       throw error

package/build/structures/Player.js

@@ -107,7 +107,7 @@ class MicrotaskUpdateBatcher {
 
       try {
         this.player?.aqua?.emit?.('error', new Error(`Update player error: ${err.message}`))
-      } catch {}
+      } catch { }
       throw err
     })
   }
@@ -235,6 +235,12 @@ class Player extends EventEmitter {
     this._boundEvent = this._handleEvent.bind(this)
     this.on('playerUpdate', this._boundPlayerUpdate)
     this.on('event', this._boundEvent)
+    this._boundAquaPlayerMove = this._handleAquaPlayerMove.bind(this)
+    this.aqua.on('playerMove', this._boundAquaPlayerMove)
+    this._voiceDownSince = 0
+    this._voiceRecovering = false
+    this._voiceWatchdogTimer = setInterval(() => this._voiceWatchdog(), 15000)
+    this._voiceWatchdogTimer.unref?.()
   }
 
   _handlePlayerUpdate(packet) {
@@ -246,6 +252,20 @@ class Player extends EventEmitter {
     this.connected = !!state.connected
     this.ping = typeof state.ping === 'number' ? state.ping : 0
     this.timestamp = typeof state.time === 'number' ? state.time : Date.now()
+
+    if (!this.connected) {
+      if (!this._voiceDownSince) {
+        this._voiceDownSince = Date.now()
+        setTimeout(() => {
+          if (!this.connected && !this.destroyed) {
+            this.connection.attemptResume()
+          }
+        }, 1000)
+      }
+    } else {
+      this._voiceDownSince = 0
+    }
+
     this.aqua.emit('playerUpdate', this, packet)
   }
 
@@ -336,9 +356,55 @@ class Player extends EventEmitter {
     return this
   }
 
+  async _voiceWatchdog() {
+    if (this.destroyed || !this.voiceChannel || this.connected) return
+    if (!this._voiceDownSince || (Date.now() - this._voiceDownSince) < 10000) return
+    if (this._voiceRecovering) return
+
+    this._voiceRecovering = true
+    try {
+      try {
+        await this.connection.attemptResume()
+        this.aqua.emit('debug', `[Player ${this.guildId}] Watchdog: resume sent`)
+        return
+      } catch { }
+
+      // 2) Force a new Discord voice update to re-trigger VSU/VSS
+      const toggleMute = !this.mute
+      this.send({
+        guild_id: this.guildId,
+        channel_id: this.voiceChannel,
+        self_deaf: this.deaf,
+        self_mute: toggleMute
+      })
+      setTimeout(() => {
+        if (!this.destroyed) {
+          this.send({
+            guild_id: this.guildId,
+            channel_id: this.voiceChannel,
+            self_deaf: this.deaf,
+            self_mute: this.mute
+          })
+        }
+      }, 300)
+
+      this.connection.resendVoiceUpdate({ resume: false })
+      this.aqua.emit('debug', `[Player ${this.guildId}] Watchdog: forced voice update/rejoin`)
+    } catch (err) {
+      this.aqua.emit('debug', `[Player ${this.guildId}] Watchdog recover failed: ${err?.message || err}`)
+    } finally {
+      this._voiceRecovering = false
+    }
+  }
+
   destroy({ preserveClient = true, skipRemote = false } = {}) {
     if (this.destroyed) return this
 
+    if (this._voiceWatchdogTimer) {
+      clearInterval(this._voiceWatchdogTimer)
+      this._voiceWatchdogTimer = null
+    }
+
     this.destroyed = true
     this.connected = false
     this.playing = false
@@ -360,6 +426,11 @@ class Player extends EventEmitter {
       this._updateBatcher = null
     }
 
+    if (this._boundAquaPlayerMove) {
+      try { this.aqua.off('playerMove', this._boundAquaPlayerMove) } catch { }
+      this._boundAquaPlayerMove = null
+    }
+
     if (!skipRemote) {
       try {
         this.send({ guild_id: this.guildId, channel_id: null })
@@ -634,10 +705,10 @@ class Player extends EventEmitter {
   _isInvalidResponse(response) {
 
     return !response?.tracks?.length ||
-           response.loadType === 'error' ||
-           response.loadType === 'empty' ||
-           response.loadType === 'LOAD_FAILED' ||
-           response.loadType === 'NO_MATCHES'
+      response.loadType === 'error' ||
+      response.loadType === 'empty' ||
+      response.loadType === 'LOAD_FAILED' ||
+      response.loadType === 'NO_MATCHES'
   }
 
   async trackStart(player, track) {
@@ -718,54 +789,56 @@ class Player extends EventEmitter {
     this.aqua.emit('trackChange', this, track, payload)
   }
 
-async _attemptVoiceResume() {
-  if (!this.connection || !this.connection.sessionId) {
-    throw new Error('Missing connection or sessionId')
-  }
-
-  const ok = await this.connection.attemptResume()
-  if (!ok) throw new Error('Resume request failed')
-  return new Promise((resolve, reject) => {
-    const timeout = setTimeout(() => {
-      this.off('playerUpdate', onUpdate)
-      reject(new Error('No resume confirmation'))
-    }, 5000)
+  async _attemptVoiceResume() {
+    if (!this.connection || !this.connection.sessionId) {
+      throw new Error('Missing connection or sessionId')
+    }
 
-    const onUpdate = (payload) => {
-      if (payload?.state?.connected || typeof payload?.state?.time === 'number') {
-        clearTimeout(timeout)
+    const ok = await this.connection.attemptResume()
+    if (!ok) throw new Error('Resume request failed')
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
         this.off('playerUpdate', onUpdate)
-        resolve()
+        reject(new Error('No resume confirmation'))
+      }, 5000)
+
+      const onUpdate = (payload) => {
+        if (payload?.state?.connected || typeof payload?.state?.time === 'number') {
+          clearTimeout(timeout)
+          this.off('playerUpdate', onUpdate)
+          resolve()
+        }
       }
-    }
 
-    this.on('playerUpdate', onUpdate)
-  })
-}
+      this.on('playerUpdate', onUpdate)
+    })
+  }
 
   async socketClosed(player, track, payload) {
     if (this.destroyed) return
 
     const code = payload?.code
 
-    if (code === 4014 || code === 4022) {
+    // playerMove is handled by a single listener registered in constructor
+
+    if (code === 4022) {
       this.aqua.emit('socketClosed', this, payload)
       this.destroy()
       return
     }
 
-   if (code === 4015) {
-    this.aqua.emit('debug', `[Player ${this.guildId}] Voice server crashed (4015), attempting resume...`)
-    try {
-      // Race resume with timeout inside _attemptVoiceResume
-      await this._attemptVoiceResume()
-      this.aqua.emit('debug', `[Player ${this.guildId}] Voice resume succeeded`)
-      return
-    } catch (err) {
-      this.aqua.emit('debug', `[Player ${this.guildId}] Resume failed: ${err.message}. Falling back to reconnect`)
-      // fall through to your existing reconnect flow below
+    if (code === 4015) {
+      this.aqua.emit('debug', `[Player ${this.guildId}] Voice server crashed (4015), attempting resume...`)
+      try {
+        // Race resume with timeout inside _attemptVoiceResume
+        await this._attemptVoiceResume()
+        this.aqua.emit('debug', `[Player ${this.guildId}] Voice resume succeeded`)
+        return
+      } catch (err) {
+        this.aqua.emit('debug', `[Player ${this.guildId}] Resume failed: ${err.message}. Falling back to reconnect`)
+        // fall through to your existing reconnect flow below
+      }
     }
-  }
 
     if (code !== 4015 && code !== 4009 && code !== 4006) {
       this.aqua.emit('socketClosed', this, payload)
@@ -884,6 +957,23 @@ async _attemptVoiceResume() {
     this.aqua.emit('lyricsNotFound', this, track, payload)
   }
 
+  _handleAquaPlayerMove(oldChannel, newChannel) {
+    try {
+      if (fnToId(oldChannel) === fnToId(this.voiceChannel)) {
+        this.voiceChannel = fnToId(newChannel)
+        this.connected = !!newChannel
+        this.send({
+          guild_id: options.guildId || this.guildId,
+          channel_id: this.voiceChannel,
+          self_deaf: this.deaf,
+          self_mute: this.mute
+        })
+      }
+    } catch (err) {
+      // don't let playerMove errors propagate
+    }
+  }
+
   send(data) {
     try {
       this.aqua.send({ op: 4, d: data })

package/package.json

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