aqualink 2.8.0 → 2.9.0

package/build/structures/Aqua.js

@@ -1,831 +1,822 @@
-"use strict";
-const Node = require("./Node");
-const Player = require("./Player");
-const Track = require("./Track");
-const { version: pkgVersion } = require("../../package.json");
-const { EventEmitter } = require('tseep');
-const fs = require('fs/promises');
+'use strict'
 
-const URL_REGEX = /^https?:\/\//;
-const GUILD_ID_REGEX = /^\d+$/;
+const { promises: fs } = require('node:fs')
+const { EventEmitter } = require('tseep')
+
+const Node = require('./Node')
+const Player = require('./Player')
+const Track = require('./Track')
+const { version: pkgVersion } = require('../../package.json')
+
+const URL_REGEX = /^https?:\/\//
+const GUILD_ID_REGEX = /^\d+$/
 
 const DEFAULT_OPTIONS = Object.freeze({
-    shouldDeleteMessage: false,
-    defaultSearchPlatform: 'ytsearch',
-    leaveOnEnd: true,
-    restVersion: 'v4',
-    plugins: [],
-    autoResume: false,
-    infiniteReconnects: false,
-    failoverOptions: {
-        enabled: true,
-        maxRetries: 3,
-        retryDelay: 1000,
-        preservePosition: true,
-        resumePlayback: true,
-        cooldownTime: 5000,
-        maxFailoverAttempts: 5
-    }
-});
-
-const LEAST_USED_TTL = 15000;
-const CLEANUP_INTERVAL = 60000;
-const MAX_CONCURRENT_OPERATIONS = 2;
+  shouldDeleteMessage: false,
+  defaultSearchPlatform: 'ytsearch',
+  leaveOnEnd: true,
+  restVersion: 'v4',
+  plugins: [],
+  autoResume: false,
+  infiniteReconnects: false,
+  failoverOptions: {
+    enabled: true,
+    maxRetries: 3,
+    retryDelay: 1000,
+    preservePosition: true,
+    resumePlayback: true,
+    cooldownTime: 5000,
+    maxFailoverAttempts: 5
+  }
+})
+
+const CLEANUP_INTERVAL = 60000
+const MAX_CONCURRENT_OPERATIONS = 3
+const BROKEN_PLAYER_TTL = 300000
+const FAILOVER_CLEANUP_TTL = 600000
 
 class Aqua extends EventEmitter {
-    constructor(client, nodes, options = {}) {
-        super();
-        if (!client) throw new Error("Client is required");
-        if (!Array.isArray(nodes) || !nodes.length) {
-            throw new TypeError(`Nodes must be non-empty Array (got ${typeof nodes})`);
-        }
+  constructor(client, nodes, options = {}) {
+    super()
 
-        this.client = client;
-        this.nodes = nodes;
-        this.nodeMap = new Map();
-        this.players = new Map();
-        this.clientId = null;
-        this.initiated = false;
-        this.version = pkgVersion;
-
-        this.options = Object.assign({}, DEFAULT_OPTIONS, options);
-        this.failoverOptions = Object.assign({}, DEFAULT_OPTIONS.failoverOptions, options.failoverOptions);
-
-        this.shouldDeleteMessage = this.options.shouldDeleteMessage;
-        this.defaultSearchPlatform = this.options.defaultSearchPlatform;
-        this.leaveOnEnd = this.options.leaveOnEnd;
-        this.restVersion = this.options.restVersion;
-        this.plugins = this.options.plugins;
-        this.autoResume = this.options.autoResume;
-        this.infiniteReconnects = this.options.infiniteReconnects;
-        this.send = this.options.send || this._defaultSend;
-
-        this._leastUsedCache = null;
-        this._cacheTimestamp = 0;
-        this._nodeStates = new Map();
-        this._failoverQueue = new Map();
-        this._lastFailoverAttempt = new Map();
-        this._brokenPlayers = new Map();
-
-        this._boundCleanupPlayer = this._cleanupPlayer.bind(this);
-        this._boundHandleDestroy = this._handlePlayerDestroy.bind(this);
-        this._boundNodeConnect = this._handleNodeConnect.bind(this);
-        this._boundNodeDisconnect = this._handleNodeDisconnect.bind(this);
-
-        this.on('nodeConnect', this._boundNodeConnect);
-        this.on('nodeDisconnect', this._boundNodeDisconnect);
-        this._cleanupTimer = setInterval(() => this._performCleanup(), CLEANUP_INTERVAL);
-    }
-
-    _defaultSend = (packet) => {
-        const guildId = packet.d.guild_id;
-        const guild = this.client?.cache?.guilds.get(guildId) ?? this.client.guilds?.cache?.get(guildId);
-
-        if (guild) {
-            if (this.client.gateway) {
-                this.client.gateway.send(this.client.gateway.calculateShardId(guildId), packet);
-            } else {
-                guild.shard?.send(packet);
-            }
-        }
+    if (!client) throw new Error('Client is required')
+    if (!Array.isArray(nodes) || !nodes.length) {
+      throw new TypeError(`Nodes must be non-empty Array (got ${typeof nodes})`)
     }
 
-    get leastUsedNodes() {
-        const now = Date.now();
-        if (this._leastUsedCache && (now - this._cacheTimestamp) < LEAST_USED_TTL) {
-            return this._leastUsedCache;
-        }
+    this.client = client
+    this.nodes = nodes
+    this.nodeMap = new Map()
+    this.players = new Map()
+    this.clientId = null
+    this.initiated = false
+    this.version = pkgVersion
 
-        const connectedNodes = [];
-        for (const node of this.nodeMap.values()) {
-            if (node.connected) {
-                connectedNodes.push(node);
-            }
-        }
+    this.options = { ...DEFAULT_OPTIONS, ...options }
+    this.failoverOptions = { ...DEFAULT_OPTIONS.failoverOptions, ...options.failoverOptions }
 
-        connectedNodes.sort((a, b) => (a.rest?.calls || 0) - (b.rest?.calls || 0));
+    this.shouldDeleteMessage = this.options.shouldDeleteMessage
+    this.defaultSearchPlatform = this.options.defaultSearchPlatform
+    this.leaveOnEnd = this.options.leaveOnEnd
+    this.restVersion = this.options.restVersion
+    this.plugins = this.options.plugins
+    this.autoResume = this.options.autoResume
+    this.infiniteReconnects = this.options.infiniteReconnects
+    this.send = this.options.send || this._defaultSend
 
-        this._leastUsedCache = connectedNodes;
-        this._cacheTimestamp = now;
-        return connectedNodes;
-    }
-
-    async init(clientId) {
-        if (this.initiated) return this;
+    this._nodeStates = new Map()
+    this._failoverQueue = new Map()
+    this._lastFailoverAttempt = new Map()
+    this._brokenPlayers = new Map()
 
-        this.clientId = clientId;
-        let successCount = 0;
+    this._bindEventHandlers()
+    this._startCleanupTimer()
+  }
 
-        const batchSize = 2;
-        for (let i = 0; i < this.nodes.length; i += batchSize) {
-            const batch = this.nodes.slice(i, i + batchSize);
-            const results = await Promise.allSettled(
-                batch.map(node => this._createNode(node))
-            );
-
-            successCount += results.filter(r => r.status === 'fulfilled').length;
-        }
+  _defaultSend = (packet) => {
+    const guildId = packet.d.guild_id
+    const guild = this.client?.cache?.guilds.get(guildId) ?? this.client.guilds?.cache?.get(guildId)
 
-        if (successCount === 0) {
-            throw new Error("No nodes connected");
-        }
-
-        if (this.plugins.length > 0) {
-            this.plugins.forEach(plugin => {
-                Promise.resolve(plugin.load(this)).catch(err =>
-                    this.emit('error', null, new Error(`Plugin error: ${err.message}`))
-                );
-            });
-        }
+    if (!guild) return;
 
-        this.initiated = true;
-        return this;
+    if (this.client.gateway) {
+      this.client.gateway.send(this.client.gateway.calculateShardId(guildId), packet)
+    } else {
+      guild.shard?.send(packet)
     }
+  }
 
-    async _createNode(options) {
-        const nodeId = options.name || options.host;
-        this._destroyNode(nodeId);
+  _bindEventHandlers() {
+    this._boundCleanupPlayer = this._cleanupPlayer.bind(this)
+    this._boundHandleDestroy = this._handlePlayerDestroy.bind(this)
+    this._boundNodeConnect = this._handleNodeConnect.bind(this)
+    this._boundNodeDisconnect = this._handleNodeDisconnect.bind(this)
 
-        const node = new Node(this, options, this.options);
-        node.players = new Set();
-        this.nodeMap.set(nodeId, node);
-        this._invalidateCache();
+    this.on('nodeConnect', this._boundNodeConnect)
+    this.on('nodeDisconnect', this._boundNodeDisconnect)
+  }
 
-        this._nodeStates.set(nodeId, { connected: false, failoverInProgress: false });
+  _startCleanupTimer() {
+    this._cleanupTimer = setInterval(() => this._performCleanup(), CLEANUP_INTERVAL)
+  }
 
-        try {
-            await node.connect();
-            this._nodeStates.set(nodeId, { connected: true, failoverInProgress: false });
-            this.emit("nodeCreate", node);
-            return node;
-        } catch (error) {
-            this._cleanupNode(nodeId);
-            throw error;
-        }
-    }
-
-    _handleNodeConnect(node) {
-        if (!this.autoResume) return;
-
-        const nodeId = node.name || node.host;
-        this._nodeStates.set(nodeId, { connected: true, failoverInProgress: false });
+  get leastUsedNodes() {
+    const connectedNodes = []
 
-        process.nextTick(() => this._rebuildBrokenPlayers(node));
+    for (const node of this.nodeMap.values()) {
+      if (node.connected) {
+        connectedNodes.push(node)
+      }
     }
 
-    _handleNodeDisconnect(node) {
-        if (!this.autoResume) return;
+    return connectedNodes.sort((a, b) => (a.rest?.calls || 0) - (b.rest?.calls || 0))
+  }
 
-        const nodeId = node.name || node.host;
-        this._nodeStates.set(nodeId, { connected: false, failoverInProgress: false });
+  async init(clientId) {
+    if (this.initiated) return this
 
-        process.nextTick(() => this._storeBrokenPlayers(node));
-    }
-
-    _storeBrokenPlayers(node) {
-        const nodeId = node.name || node.host;
-        const now = Date.now();
+    this.clientId = clientId
+    let successCount = 0
 
-        for (const player of this.players.values()) {
-            if (player.nodes === node) {
-                try {
-                    const state = this._capturePlayerState(player);
-                    if (state) {
-                        state.originalNodeId = nodeId;
-                        state.brokenAt = now;
-                        this._brokenPlayers.set(player.guildId, state);
-                    }
-                } catch (error) {
-                }
-            }
-        }
+    const batchSize = 2
+    for (let i = 0; i < this.nodes.length; i += batchSize) {
+      const batch = this.nodes.slice(i, i + batchSize)
+      const results = await Promise.allSettled(batch.map(node => this._createNode(node)))
+      successCount += results.filter(r => r.status === 'fulfilled').length
     }
 
-    _rebuildBrokenPlayers(node) {
-        const nodeId = node.name || node.host;
-        let rebuiltCount = 0;
-
-        for (const [guildId, brokenState] of this._brokenPlayers.entries()) {
-            if (brokenState.originalNodeId === nodeId) {
-                this._rebuildPlayer(brokenState, node)
-                    .then(() => {
-                        this._brokenPlayers.delete(guildId);
-                        rebuiltCount++;
-                    })
-                    .catch(() => {
-                        if (Date.now() - brokenState.brokenAt > 300000) {
-                            this._brokenPlayers.delete(guildId);
-                        }
-                    });
-            }
-        }
+    if (successCount === 0) {
+      throw new Error('No nodes connected')
+    }
 
-        if (rebuiltCount > 0) {
-            this.emit("playersRebuilt", node, rebuiltCount);
-        }
+    if (this.plugins.length > 0) {
+      this.plugins.forEach(plugin => {
+        Promise.resolve(plugin.load(this)).catch(err =>
+          this.emit('error', null, new Error(`Plugin error: ${err.message}`))
+        )
+      })
     }
 
-    async _rebuildPlayer(brokenState, targetNode) {
-        const { guildId, textChannel, voiceChannel, current, volume = 65, deaf = true } = brokenState;
+    this.initiated = true
+    return this
+  }
 
-        const existingPlayer = this.players.get(guildId);
-        if (existingPlayer) {
-            await existingPlayer.destroy();
-        }
+  async _createNode(options) {
+    const nodeId = options.name || options.host
+    this._destroyNode(nodeId)
 
-        setTimeout(async () => {
-            try {
-                const player = await this.createConnection({
-                    guildId, textChannel, voiceChannel,
-                    defaultVolume: volume, deaf
-                });
-
-                if (current) {
-                    await player.queue.add(current);
-                    await player.play();
-                    this.emit("trackStart", player, current);
-                }
-            } catch (error) {
-                this._brokenPlayers.delete(guildId);
-            }
-        }, 1000);
-    }
+    const node = new Node(this, options, this.options)
+    node.players = new Set()
+    this.nodeMap.set(nodeId, node)
 
-    _destroyNode(identifier) {
-        const node = this.nodeMap.get(identifier);
-        if (node) {
-            this._cleanupNode(identifier);
-            this.emit("nodeDestroy", node);
-        }
-    }
+    this._nodeStates.set(nodeId, { connected: false, failoverInProgress: false })
 
-    _cleanupNode(nodeId) {
-        const node = this.nodeMap.get(nodeId);
-        if (node) {
-            node.removeAllListeners();
-        }
-
-        this.nodeMap.delete(nodeId);
-        this._nodeStates.delete(nodeId);
-        this._failoverQueue.delete(nodeId);
-        this._lastFailoverAttempt.delete(nodeId);
-        this._invalidateCache();
+    try {
+      await node.connect()
+      this._nodeStates.set(nodeId, { connected: true, failoverInProgress: false })
+      this.emit('nodeCreate', node)
+      return node
+    } catch (error) {
+      this._cleanupNode(nodeId)
+      throw error
     }
+  }
 
-    _invalidateCache() {
-        this._leastUsedCache = null;
-        this._cacheTimestamp = 0;
-    }
+  _handleNodeConnect(node) {
+    if (!this.autoResume) return;
 
-    async handleNodeFailover(failedNode) {
-        if (!this.failoverOptions.enabled) return;
+    const nodeId = node.name || node.host
+    this._nodeStates.set(nodeId, { connected: true, failoverInProgress: false })
 
-        const nodeId = failedNode.name || failedNode.host;
-        const now = Date.now();
+    process.nextTick(() => this._rebuildBrokenPlayers(node))
+  }
 
-        const nodeState = this._nodeStates.get(nodeId);
-        if (nodeState?.failoverInProgress) return;
+  _handleNodeDisconnect(node) {
+    if (!this.autoResume) return;
 
-        const lastAttempt = this._lastFailoverAttempt.get(nodeId);
-        if (lastAttempt && (now - lastAttempt) < this.failoverOptions.cooldownTime) return;
+    const nodeId = node.name || node.host
+    this._nodeStates.set(nodeId, { connected: false, failoverInProgress: false })
 
-        const attempts = this._failoverQueue.get(nodeId) || 0;
-        if (attempts >= this.failoverOptions.maxFailoverAttempts) return;
+    process.nextTick(() => this._storeBrokenPlayers(node))
+  }
 
-        this._nodeStates.set(nodeId, { connected: false, failoverInProgress: true });
-        this._lastFailoverAttempt.set(nodeId, now);
-        this._failoverQueue.set(nodeId, attempts + 1);
+  _storeBrokenPlayers(node) {
+    const nodeId = node.name || node.host
+    const now = Date.now()
 
-        try {
-            this.emit("nodeFailover", failedNode);
+    for (const player of this.players.values()) {
+      if (player.nodes === node) {
+        const state = this._capturePlayerState(player)
+        if (state) {
+          state.originalNodeId = nodeId
+          state.brokenAt = now
+          this._brokenPlayers.set(player.guildId, state)
+        }
+      }
+    }
+  }
 
-            const affectedPlayers = Array.from(failedNode.players);
-            if (affectedPlayers.length === 0) {
-                this._nodeStates.set(nodeId, { connected: false, failoverInProgress: false });
-                return;
-            }
+  _rebuildBrokenPlayers(node) {
+    const nodeId = node.name || node.host
+    let rebuiltCount = 0
 
-            const availableNodes = this._getAvailableNodes(failedNode);
-            if (availableNodes.length === 0) {
-                this.emit("error", null, new Error("No failover nodes available"));
-                return;
+    for (const [guildId, brokenState] of this._brokenPlayers.entries()) {
+      if (brokenState.originalNodeId === nodeId) {
+        this._rebuildPlayer(brokenState, node)
+          .then(() => {
+            this._brokenPlayers.delete(guildId)
+            rebuiltCount++
+          })
+          .catch(() => {
+            if (Date.now() - brokenState.brokenAt > BROKEN_PLAYER_TTL) {
+              this._brokenPlayers.delete(guildId)
             }
+          })
+      }
+    }
 
-            const results = await this._migratePlayersOptimized(affectedPlayers, availableNodes);
-            const successful = results.filter(r => r.success).length;
+    if (rebuiltCount > 0) {
+      this.emit('playersRebuilt', node, rebuiltCount)
+    }
+  }
 
-            if (successful > 0) {
-                this.emit("nodeFailoverComplete", failedNode, successful, results.length - successful);
-            }
+  async _rebuildPlayer(brokenState, targetNode) {
+    const { guildId, textChannel, voiceChannel, current, volume = 65, deaf = true } = brokenState
 
-        } catch (error) {
-            this.emit("error", null, new Error(`Failover failed: ${error.message}`));
-        } finally {
-            this._nodeStates.set(nodeId, { connected: false, failoverInProgress: false });
-        }
+    const existingPlayer = this.players.get(guildId)
+    if (existingPlayer) {
+      await existingPlayer.destroy()
     }
 
-    async _migratePlayersOptimized(players, availableNodes) {
-        const results = [];
-
-        // Process in smaller batches
-        for (let i = 0; i < players.length; i += MAX_CONCURRENT_OPERATIONS) {
-            const batch = players.slice(i, i + MAX_CONCURRENT_OPERATIONS);
-            const batchResults = await Promise.allSettled(
-                batch.map(player => this._migratePlayer(player, availableNodes))
-            );
+    setTimeout(async () => {
+      try {
+        const player = await this.createConnection({
+          guildId,
+          textChannel,
+          voiceChannel,
+          defaultVolume: volume,
+          deaf
+        })
 
-            results.push(...batchResults.map(r => ({
-                success: r.status === 'fulfilled',
-                error: r.reason
-            })));
+        if (current) {
+          await player.queue.add(current)
+          await player.play()
+          this.emit('trackStart', player, current)
         }
+      } catch (error) {
+        this._brokenPlayers.delete(guildId)
+      }
+    }, 1000)
+  }
 
-        return results;
+  _destroyNode(identifier) {
+    const node = this.nodeMap.get(identifier)
+    if (node) {
+      this._cleanupNode(identifier)
+      this.emit('nodeDestroy', node)
     }
+  }
 
-    async _migratePlayer(player, availableNodes) {
-        let retryCount = 0;
-
-        while (retryCount < this.failoverOptions.maxRetries) {
-            try {
-                const targetNode = availableNodes[0]; // Simple selection
-                const playerState = this._capturePlayerState(player);
-
-                if (!playerState) throw new Error("Failed to capture state");
-
-                const newPlayer = await this._createPlayerOnNode(targetNode, playerState);
-                await this._restorePlayerState(newPlayer, playerState);
-
-                this.emit("playerMigrated", player, newPlayer, targetNode);
-                return newPlayer;
-
-            } catch (error) {
-                retryCount++;
-                if (retryCount >= this.failoverOptions.maxRetries) throw error;
-                await this._delay(this.failoverOptions.retryDelay);
-            }
-        }
+  _cleanupNode(nodeId) {
+    const node = this.nodeMap.get(nodeId)
+    if (node) {
+      node.removeAllListeners()
     }
 
-    _capturePlayerState(player) {
-        try {
-            return {
-                guildId: player.guildId,
-                textChannel: player.textChannel,
-                voiceChannel: player.voiceChannel,
-                volume: player.volume || 100,
-                paused: player.paused || false,
-                position: player.position || 0,
-                current: player.current || null,
-                queue: player.queue?.tracks?.slice(0, 10) || [], // Limit queue size
-                repeat: player.loop,
-                shuffle: player.shuffle,
-                deaf: player.deaf || false,
-                connected: player.connected || false,
-            };
-        } catch {
-            return null;
-        }
-    }
+    this.nodeMap.delete(nodeId)
+    this._nodeStates.delete(nodeId)
+    this._failoverQueue.delete(nodeId)
+    this._lastFailoverAttempt.delete(nodeId)
+  }
+
+  async handleNodeFailover(failedNode) {
+    if (!this.failoverOptions.enabled) return;
+
+    const nodeId = failedNode.name || failedNode.host
+    const now = Date.now()
+
+    const nodeState = this._nodeStates.get(nodeId)
+    if (nodeState?.failoverInProgress) return;
+
+    const lastAttempt = this._lastFailoverAttempt.get(nodeId)
+    if (lastAttempt && (now - lastAttempt) < this.failoverOptions.cooldownTime) return;
+
+    const attempts = this._failoverQueue.get(nodeId) || 0
+    if (attempts >= this.failoverOptions.maxFailoverAttempts) return;
+
+    this._nodeStates.set(nodeId, { connected: false, failoverInProgress: true })
+    this._lastFailoverAttempt.set(nodeId, now)
+    this._failoverQueue.set(nodeId, attempts + 1)
+
+    try {
+      this.emit('nodeFailover', failedNode)
+
+      const affectedPlayers = Array.from(failedNode.players)
+      if (affectedPlayers.length === 0) {
+        this._nodeStates.set(nodeId, { connected: false, failoverInProgress: false })
+        return;
+      }
+
+      const availableNodes = this._getAvailableNodes(failedNode)
+      if (availableNodes.length === 0) {
+        this.emit('error', null, new Error('No failover nodes available'))
+        return;
+      }
+
+      const results = await this._migratePlayersOptimized(affectedPlayers, availableNodes)
+      const successful = results.filter(r => r.success).length
 
-    async _createPlayerOnNode(targetNode, playerState) {
-        return this.createPlayer(targetNode, {
-            guildId: playerState.guildId,
-            textChannel: playerState.textChannel,
-            voiceChannel: playerState.voiceChannel,
-            defaultVolume: playerState.volume || 100,
-            deaf: playerState.deaf || false
-        });
+      if (successful > 0) {
+        this.emit('nodeFailoverComplete', failedNode, successful, results.length - successful)
+      }
+    } catch (error) {
+      this.emit('error', null, new Error(`Failover failed: ${error.message}`))
+    } finally {
+      this._nodeStates.set(nodeId, { connected: false, failoverInProgress: false })
     }
+  }
 
-    async _restorePlayerState(newPlayer, playerState) {
-        try {
-            if (playerState.volume !== undefined) {
-                newPlayer.setVolume(playerState.volume);
-            }
+  async _migratePlayersOptimized(players, availableNodes) {
+    const results = []
 
-            if (playerState.queue?.length > 0) {
-                newPlayer.queue.add(...playerState.queue);
-            }
+    for (let i = 0; i < players.length; i += MAX_CONCURRENT_OPERATIONS) {
+      const batch = players.slice(i, i + MAX_CONCURRENT_OPERATIONS)
+      const batchResults = await Promise.allSettled(
+        batch.map(player => this._migratePlayer(player, availableNodes))
+      )
 
-            if (playerState.current && this.failoverOptions.preservePosition) {
-                newPlayer.queue.unshift(playerState.current);
+      results.push(...batchResults.map(r => ({
+        success: r.status === 'fulfilled',
+        error: r.reason
+      })))
+    }
 
-                if (this.failoverOptions.resumePlayback) {
-                    await newPlayer.play();
+    return results
+  }
 
-                    if (playerState.position > 0) {
-                        setTimeout(() => newPlayer.seek(playerState.position), 200);
-                    }
+  async _migratePlayer(player, availableNodes) {
+    let retryCount = 0
 
-                    if (playerState.paused) {
-                        newPlayer.pause();
-                    }
-                }
-            }
+    while (retryCount < this.failoverOptions.maxRetries) {
+      try {
+        const targetNode = availableNodes[0]
+        const playerState = this._capturePlayerState(player)
 
-            // Direct assignment instead of Object.assign
-            newPlayer.repeat = playerState.repeat;
-            newPlayer.shuffle = playerState.shuffle;
+        if (!playerState) throw new Error('Failed to capture state')
 
-        } catch (error) {
-            throw error;
-        }
-    }
+        const newPlayer = await this._createPlayerOnNode(targetNode, playerState)
+        await this._restorePlayerState(newPlayer, playerState)
 
-    _delay(ms) {
-        return new Promise(resolve => setTimeout(resolve, ms));
+        this.emit('playerMigrated', player, newPlayer, targetNode)
+        return newPlayer
+      } catch (error) {
+        retryCount++
+        if (retryCount >= this.failoverOptions.maxRetries) throw error
+        await this._delay(this.failoverOptions.retryDelay)
+      }
     }
+  }
 
-    _cleanupPlayer(player) {
-        if (player) {
-            player.destroy()
-        }
+  _capturePlayerState(player) {
+    try {
+      return {
+        guildId: player.guildId,
+        textChannel: player.textChannel,
+        voiceChannel: player.voiceChannel,
+        volume: player.volume || 100,
+        paused: player.paused || false,
+        position: player.position || 0,
+        current: player.current || null,
+        queue: player.queue?.tracks?.slice(0, 10) || [],
+        repeat: player.loop,
+        shuffle: player.shuffle,
+        deaf: player.deaf || false,
+        connected: player.connected || false
+      }
+    } catch {
+      return null
     }
+  }
 
-    updateVoiceState({ d, t }) {
-        if (!GUILD_ID_REGEX.test(d.guild_id)) return;
+  async _createPlayerOnNode(targetNode, playerState) {
+    return this.createPlayer(targetNode, {
+      guildId: playerState.guildId,
+      textChannel: playerState.textChannel,
+      voiceChannel: playerState.voiceChannel,
+      defaultVolume: playerState.volume || 100,
+      deaf: playerState.deaf || false
+    })
+  }
 
-        const player = this.players.get(d.guild_id);
-        if (!player) return;
-
-        if (t === "VOICE_SERVER_UPDATE" || (t === "VOICE_STATE_UPDATE" && d.user_id === this.clientId)) {
-            if (t === "VOICE_SERVER_UPDATE") {
-                player.connection?.setServerUpdate?.(d);
-            } else {
-                player.connection?.setStateUpdate?.(d);
-            }
+  async _restorePlayerState(newPlayer, playerState) {
+    if (playerState.volume !== undefined) {
+      newPlayer.setVolume(playerState.volume)
+    }
 
-            if (d.channel_id === null) {
-                this._boundCleanupPlayer(player);
-            }
-        }
+    if (playerState.queue?.length > 0) {
+      newPlayer.queue.add(...playerState.queue)
     }
 
-    fetchRegion(region) {
-        if (!region) return this.leastUsedNodes;
+    if (playerState.current && this.failoverOptions.preservePosition) {
+      newPlayer.queue.unshift(playerState.current)
 
-        const lowerRegion = region.toLowerCase();
-        const regionNodes = [];
+      if (this.failoverOptions.resumePlayback) {
+        await newPlayer.play()
 
-        for (const node of this.nodeMap.values()) {
-            if (node.connected && node.regions?.includes(lowerRegion)) {
-                regionNodes.push(node);
-            }
+        if (playerState.position > 0) {
+          setTimeout(() => newPlayer.seek(playerState.position), 200)
         }
 
-        // Simple load calculation
-        regionNodes.sort((a, b) => {
-            const loadA = this._getNodeLoad(a);
-            const loadB = this._getNodeLoad(b);
-            return loadA - loadB;
-        });
-
-        return regionNodes;
-    }
-
-    _getNodeLoad(node) {
-        const stats = node?.stats?.cpu;
-        return stats ? (stats.systemLoad / stats.cores) * 100 : 0;
+        if (playerState.paused) {
+          newPlayer.pause()
+        }
+      }
     }
 
-    createConnection(options) {
-        if (!this.initiated) throw new Error("Aqua not initialized");
+    newPlayer.repeat = playerState.repeat
+    newPlayer.shuffle = playerState.shuffle
+  }
 
-        const existingPlayer = this.players.get(options.guildId);
-        if (existingPlayer?.voiceChannel) return existingPlayer;
+  _delay(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms))
+  }
 
-        const availableNodes = options.region ?
-            this.fetchRegion(options.region) : this.leastUsedNodes;
-
-        if (!availableNodes.length) throw new Error("No nodes available");
-
-        return this.createPlayer(availableNodes[0], options);
+  _cleanupPlayer(player) {
+    if (player) {
+      player.destroy()
     }
+  }
 
-    createPlayer(node, options) {
-        this.destroyPlayer(options.guildId);
+  updateVoiceState({ d, t }) {
+    if (!GUILD_ID_REGEX.test(d.guild_id)) return;
 
-        const player = new Player(this, node, options);
-        this.players.set(options.guildId, player);
+    const player = this.players.get(d.guild_id)
+    if (!player) return;
 
-        player.once("destroy", this._boundHandleDestroy);
-        player.connect(options);
-        this.emit("playerCreate", player);
-        return player;
-    }
+    if (t === 'VOICE_SERVER_UPDATE' || (t === 'VOICE_STATE_UPDATE' && d.user_id === this.clientId)) {
+      if (t === 'VOICE_SERVER_UPDATE') {
+        player.connection?.setServerUpdate?.(d)
+      } else {
+        player.connection?.setStateUpdate?.(d)
+      }
 
-    _handlePlayerDestroy(player) {
-        const node = player.nodes;
-        if (node?.players) {
-            node.players.delete(player);
-        }
-        this.players.delete(player.guildId);
-        this.emit("playerDestroy", player);
+      if (d.channel_id === null) {
+        this._boundCleanupPlayer(player)
+      }
     }
+  }
 
-    async destroyPlayer(guildId) {
-        const player = this.players.get(guildId);
-        if (!player) return;
-
-        try {
-            await player.clearData();
-            player.removeAllListeners();
-            this.players.delete(guildId);
-            this.emit("playerDestroy", player);
-        } catch {
-            // Silent cleanup
-        }
-    }
-
-    async resolve({ query, source = this.defaultSearchPlatform, requester, nodes }) {
-        if (!this.initiated) throw new Error("Aqua not initialized");
-
-        const requestNode = this._getRequestNode(nodes);
-        const formattedQuery = URL_REGEX.test(query) ? query : `${source}:${query}`;
-
-        try {
-            const endpoint = `/v4/loadtracks?identifier=${encodeURIComponent(formattedQuery)}`;
-            const response = await requestNode.rest.makeRequest("GET", endpoint);
+  fetchRegion(region) {
+    if (!region) return this.leastUsedNodes
 
-            if (["empty", "NO_MATCHES"].includes(response.loadType)) {
-                return this._createEmptyResponse();
-            }
+    const lowerRegion = region.toLowerCase()
+    const regionNodes = []
 
-            return this._constructResponse(response, requester, requestNode);
-        } catch (error) {
-            throw new Error(error.name === "AbortError" ? "Request timeout" : `Resolve failed: ${error.message}`);
-        }
+    for (const node of this.nodeMap.values()) {
+      if (node.connected && node.regions?.includes(lowerRegion)) {
+        regionNodes.push(node)
+      }
     }
 
-    _getRequestNode(nodes) {
-        if (!nodes) return this.leastUsedNodes[0];
-        if (nodes instanceof Node) return nodes;
-        if (typeof nodes === "string") {
-            return this.nodeMap.get(nodes) || this.leastUsedNodes[0];
-        }
-        throw new TypeError(`Invalid nodes parameter: ${typeof nodes}`);
-    }
-
-    _createEmptyResponse() {
-        return {
-            loadType: "empty",
-            exception: null,
-            playlistInfo: null,
-            pluginInfo: {},
-            tracks: []
-        };
-    }
-
-    _constructResponse(response, requester, requestNode) {
-        const baseResponse = {
-            loadType: response.loadType,
-            exception: null,
-            playlistInfo: null,
-            pluginInfo: response.pluginInfo || {},
-            tracks: []
-        };
-
-        if (response.loadType === "error" || response.loadType === "LOAD_FAILED") {
-            baseResponse.exception = response.data || response.exception;
-            return baseResponse;
-        }
+    return regionNodes.sort((a, b) => this._getNodeLoad(a) - this._getNodeLoad(b))
+  }
 
-        switch (response.loadType) {
-            case "track":
-                if (response.data) {
-                    baseResponse.tracks.push(new Track(response.data, requester, requestNode));
-                }
-                break;
-
-            case "playlist": {
-                const info = response.data?.info;
-                if (info) {
-                    baseResponse.playlistInfo = {
-                        name: info.name || info.title,
-                        thumbnail: response.data.pluginInfo?.artworkUrl ||
-                            response.data.tracks?.[0]?.info?.artworkUrl || null,
-                        ...info
-                    };
-                }
-
-                const tracks = response.data?.tracks;
-                if (tracks?.length) {
-                    baseResponse.tracks = tracks.map(track => new Track(track, requester, requestNode));
-                }
-                break;
-            }
+  _getNodeLoad(node) {
+    const stats = node?.stats?.cpu
+    return stats ? (stats.systemLoad / stats.cores) * 100 : 0
+  }
 
-            case "search": {
-                const searchData = response.data || [];
-                if (searchData.length) {
-                    baseResponse.tracks = searchData.map(track => new Track(track, requester, requestNode));
-                }
-                break;
-            }
-        }
+  createConnection(options) {
+    if (!this.initiated) throw new Error('Aqua not initialized')
 
-        return baseResponse;
-    }
+    const existingPlayer = this.players.get(options.guildId)
+    if (existingPlayer?.voiceChannel) return existingPlayer
 
-    get(guildId) {
-        const player = this.players.get(guildId);
-        if (!player) throw new Error(`Player not found: ${guildId}`);
-        return player;
-    }
+    const availableNodes = options.region ? this.fetchRegion(options.region) : this.leastUsedNodes
 
-    async search(query, requester, source = this.defaultSearchPlatform) {
-        if (!query || !requester) return null;
+    if (!availableNodes.length) throw new Error('No nodes available')
 
-        try {
-            const { tracks } = await this.resolve({ query, source, requester });
-            return tracks || null;
-        } catch {
-            return null;
-        }
-    }
+    return this.createPlayer(availableNodes[0], options)
+  }
 
-    async loadPlayers(filePath = "./AquaPlayers.json") {
-        try {
-            await fs.access(filePath);
-            await this._waitForFirstNode();
+  createPlayer(node, options) {
+    this.destroyPlayer(options.guildId)
 
-            const data = JSON.parse(await fs.readFile(filePath, "utf8"));
+    const player = new Player(this, node, options)
+    this.players.set(options.guildId, player)
 
-            const batchSize = 5;
-            for (let i = 0; i < data.length; i += batchSize) {
-                const batch = data.slice(i, i + batchSize);
-                await Promise.all(batch.map(p => this._restorePlayer(p)));
-            }
+    player.once('destroy', this._boundHandleDestroy)
+    player.connect(options)
+    this.emit('playerCreate', player)
+    return player
+  }
 
-            await fs.writeFile(filePath, "[]", "utf8");
-        } catch (error) {
-        }
+  _handlePlayerDestroy(player) {
+    const node = player.nodes
+    if (node?.players) {
+      node.players.delete(player)
     }
+    this.players.delete(player.guildId)
+    this.emit('playerDestroy', player)
+  }
 
-    async savePlayer(filePath = "./AquaPlayers.json") {
-        const data = Array.from(this.players.values()).map(player => {
-            const requester = player.requester || player.current?.requester;
-
-            return {
-                g: player.guildId,
-                t: player.textChannel,
-                v: player.voiceChannel,
-                u: player.current?.uri || null,
-                p: player.position || 0,
-                ts: player.timestamp || 0,
-                q: player.queue?.tracks?.map(tr => tr.uri).slice(0, 5) || [],
-                r: requester ? {
-                    id: requester.id,
-                    username: requester.username,
-                    globalName: requester.globalName,
-                    discriminator: requester.discriminator,
-                    avatar: requester.avatar
-                } : null,
-                vol: player.volume,
-                pa: player.paused,
-                isPlaying: !!player.current && !player.paused
-            };
-        });
-
-        await fs.writeFile(filePath, JSON.stringify(data), "utf8");
-        this.emit("debug", "Aqua", `Saved ${data.length} players to ${filePath}`);
-    }
-
-    async _restorePlayer(p) {
-        try {
-            let player = this.players.get(p.g);
-            if (!player) {
-                const targetNode = (p.n && this.nodeMap.get(p.n)?.connected) ?
-                    this.nodeMap.get(p.n) : this.leastUsedNodes[0];
-
-                if (!targetNode) return;
-
-                player = await this.createConnection({
-                    guildId: p.g,
-                    textChannel: p.t,
-                    voiceChannel: p.v,
-                    defaultVolume: p.vol || 65,
-                    deaf: true
-                });
-            }
-
-            if (p.u && player) {
-                const resolved = await this.resolve({ query: p.u, requester: p.r });
-                if (resolved.tracks?.[0]) {
-                    player.queue.add(resolved.tracks[0]);
-                    player.position = p.p || 0;
-                    if (typeof p.ts === "number") player.timestamp = p.ts;
-                }
-            }
-
-            if (p.q?.length && player) {
-                const queuePromises = p.q
-                    .filter(uri => uri !== p.u)
-                    .map(uri => this.resolve({ query: uri, requester: p.r }));
-
-                const queueResults = await Promise.allSettled(queuePromises);
-                queueResults.forEach(result => {
-                    if (result.status === 'fulfilled' && result.value.tracks?.[0]) {
-                        player.queue.add(result.value.tracks[0]);
-                    }
-                });
-            }
+  async destroyPlayer(guildId) {
+    const player = this.players.get(guildId)
+    if (!player) return;
 
-            if (player) {
-                player.paused = !!p.pa;
-                if ((p.isPlaying || (p.pa && p.u)) && player.queue.size > 0) {
-                    player.play();
-                }
-            }
-        } catch (error) {
-        }
+    try {
+      await player.clearData()
+      player.removeAllListeners()
+      this.players.delete(guildId)
+      this.emit('playerDestroy', player)
+    } catch {
+      // Silent cleanup
     }
+  }
 
-    async _waitForFirstNode() {
-        if (this.leastUsedNodes.length > 0) return;
+  async resolve({ query, source = this.defaultSearchPlatform, requester, nodes }) {
+    if (!this.initiated) throw new Error('Aqua not initialized')
 
-        return new Promise(resolve => {
-            const checkInterval = setInterval(() => {
-                if (this.leastUsedNodes.length > 0) {
-                    clearInterval(checkInterval);
-                    resolve();
-                }
-            }, 100);
-        });
-    }
+    const requestNode = this._getRequestNode(nodes)
+    const formattedQuery = URL_REGEX.test(query) ? query : `${source}:${query}`
 
-    _performCleanup() {
-        const now = Date.now();
+    try {
+      const endpoint = `/v4/loadtracks?identifier=${encodeURIComponent(formattedQuery)}`
+      const response = await requestNode.rest.makeRequest('GET', endpoint)
 
-        for (const [guildId, state] of this._brokenPlayers.entries()) {
-            if (now - state.brokenAt > 300000) {
-                this._brokenPlayers.delete(guildId);
-            }
-        }
+      if (['empty', 'NO_MATCHES'].includes(response.loadType)) {
+        return this._createEmptyResponse()
+      }
 
-        for (const [nodeId, timestamp] of this._lastFailoverAttempt.entries()) {
-            if (now - timestamp > 600000) {
-                this._lastFailoverAttempt.delete(nodeId);
-                this._failoverQueue.delete(nodeId);
-            }
-        }
+      return this._constructResponse(response, requester, requestNode)
+    } catch (error) {
+      throw new Error(error.name === 'AbortError' ? 'Request timeout' : `Resolve failed: ${error.message}`)
     }
+  }
 
-    getBrokenPlayersCount() {
-        return this._brokenPlayers.size;
+  _getRequestNode(nodes) {
+    if (!nodes) return this.leastUsedNodes[0]
+    if (nodes instanceof Node) return nodes
+    if (typeof nodes === 'string') {
+      return this.nodeMap.get(nodes) || this.leastUsedNodes[0]
     }
+    throw new TypeError(`Invalid nodes parameter: ${typeof nodes}`)
+  }
 
-    getNodeStats() {
-        const stats = {};
-        for (const [name, node] of this.nodeMap) {
-            const nodeStats = node.stats || {};
-            stats[name] = {
-                connected: node.connected,
-                players: nodeStats.players || 0,
-                playingPlayers: nodeStats.playingPlayers || 0,
-                uptime: nodeStats.uptime || 0,
-                cpu: nodeStats.cpu || {},
-                memory: nodeStats.memory || {},
-                ping: nodeStats.ping || 0
-            };
-        }
-        return stats;
+  _createEmptyResponse() {
+    return {
+      loadType: 'empty',
+      exception: null,
+      playlistInfo: null,
+      pluginInfo: {},
+      tracks: []
     }
+  }
 
-    destroy() {
-        if (this._cleanupTimer) {
-            clearInterval(this._cleanupTimer);
-        }
-
-        this.removeAllListeners();
+  _constructResponse(response, requester, requestNode) {
+    const baseResponse = {
+      loadType: response.loadType,
+      exception: null,
+      playlistInfo: null,
+      pluginInfo: response.pluginInfo || {},
+      tracks: []
+    }
+
+    if (response.loadType === 'error' || response.loadType === 'LOAD_FAILED') {
+      baseResponse.exception = response.data || response.exception
+      return baseResponse
+    }
+
+    switch (response.loadType) {
+      case 'track':
+        if (response.data) {
+          baseResponse.tracks.push(new Track(response.data, requester, requestNode))
+        }
+        break
+
+      case 'playlist': {
+        const info = response.data?.info
+        if (info) {
+          baseResponse.playlistInfo = {
+            name: info.name || info.title,
+            thumbnail: response.data.pluginInfo?.artworkUrl ||
+              response.data.tracks?.[0]?.info?.artworkUrl || null,
+            ...info
+          }
+        }
+
+        const tracks = response.data?.tracks
+        if (tracks?.length) {
+          baseResponse.tracks = tracks.map(track => new Track(track, requester, requestNode))
+        }
+        break
+      }
+
+      case 'search': {
+        const searchData = response.data || []
+        if (searchData.length) {
+          baseResponse.tracks = searchData.map(track => new Track(track, requester, requestNode))
+        }
+        break
+      }
+    }
+
+    return baseResponse
+  }
+
+  get(guildId) {
+    const player = this.players.get(guildId)
+    if (!player) throw new Error(`Player not found: ${guildId}`)
+    return player
+  }
+
+  async search(query, requester, source = this.defaultSearchPlatform) {
+    if (!query || !requester) return null
+
+    try {
+      const { tracks } = await this.resolve({ query, source, requester })
+      return tracks || null
+    } catch {
+      return null
+    }
+  }
+
+  async loadPlayers(filePath = './AquaPlayers.json') {
+    try {
+      await fs.access(filePath)
+      await this._waitForFirstNode()
+
+      const data = JSON.parse(await fs.readFile(filePath, 'utf8'))
+
+      const batchSize = 5
+      for (let i = 0; i < data.length; i += batchSize) {
+        const batch = data.slice(i, i + batchSize)
+        await Promise.all(batch.map(p => this._restorePlayer(p)))
+      }
+
+      await fs.writeFile(filePath, '[]', 'utf8')
+    } catch (error) {
+      // Silent error handling
+    }
+  }
+
+  async savePlayer(filePath = './AquaPlayers.json') {
+    const data = Array.from(this.players.values()).map(player => {
+      const requester = player.requester || player.current?.requester
+
+      return {
+        g: player.guildId,
+        t: player.textChannel,
+        v: player.voiceChannel,
+        u: player.current?.uri || null,
+        p: player.position || 0,
+        ts: player.timestamp || 0,
+        q: player.queue?.tracks?.map(tr => tr.uri).slice(0, 5) || [],
+        r: requester ? {
+          id: requester.id,
+          username: requester.username,
+          globalName: requester.globalName,
+          discriminator: requester.discriminator,
+          avatar: requester.avatar
+        } : null,
+        vol: player.volume,
+        pa: player.paused,
+        isPlaying: player.playing,
+        sessionId: player.connection.sessionId,
+        endpoint: player.connection.endpoint,
+        token: player.connection.token
+      }
+    })
+
+    await fs.writeFile(filePath, JSON.stringify(data), 'utf8')
+    this.emit('debug', 'Aqua', `Saved ${data.length} players to ${filePath}`)
+  }
+
+  async _restorePlayer(p) {
+    try {
+      let player = this.players.get(p.g)
+      if (!player) {
+        const targetNode = (p.n && this.nodeMap.get(p.n)?.connected) ?
+          this.nodeMap.get(p.n) : this.leastUsedNodes[0]
+
+        if (!targetNode) return;
+
+        player = await this.createConnection({
+          guildId: p.g,
+          textChannel: p.t,
+          voiceChannel: p.v,
+          defaultVolume: p.vol || 65,
+          deaf: true
+        })
+      }
+
+      if (player?.connection) {
+        if (p.sessionId) player.connection.sessionId = p.sessionId
+        if (p.endpoint) player.connection.endpoint = p.endpoint
+        if (p.token) player.connection.token = p.token
+      }
+
+      if (p.u && player) {
+        const resolved = await this.resolve({ query: p.u, requester: p.r })
+        if (resolved.tracks?.[0]) {
+          player.queue.add(resolved.tracks[0])
+          player.position = p.p || 0
+          if (typeof p.ts === 'number') player.timestamp = p.ts
+        }
+      }
+
+      if (p.q?.length && player) {
+        const queuePromises = p.q
+          .filter(uri => uri !== p.u)
+          .map(uri => this.resolve({ query: uri, requester: p.r }))
+
+        const queueResults = await Promise.allSettled(queuePromises)
+        queueResults.forEach(result => {
+          if (result.status === 'fulfilled' && result.value.tracks?.[0]) {
+            player.queue.add(result.value.tracks[0])
+          }
+        })
+      }
+
+      if (player) {
+        if (typeof p.vol === 'number') {
+          player.volume = p.vol
+        }
+
+        player.paused = !!p.pa
+
+        if ((p.isPlaying || (p.pa && p.u)) && player.queue.size > 0) {
+          player.play()
+        }
+      }
+    } catch (error) {
+      this.emit('debug', 'Aqua', `Error restoring player for guild ${p.g}: ${error.message}`)
+    }
+  }
+
+  async _waitForFirstNode() {
+    if (this.leastUsedNodes.length > 0) return;
+
+    return new Promise(resolve => {
+      const checkInterval = setInterval(() => {
+        if (this.leastUsedNodes.length > 0) {
+          clearInterval(checkInterval)
+          resolve()
+        }
+      }, 100)
+    })
+  }
+
+  _performCleanup() {
+    const now = Date.now()
+
+    for (const [guildId, state] of this._brokenPlayers.entries()) {
+      if (now - state.brokenAt > BROKEN_PLAYER_TTL) {
+        this._brokenPlayers.delete(guildId)
+      }
+    }
+
+    for (const [nodeId, timestamp] of this._lastFailoverAttempt.entries()) {
+      if (now - timestamp > FAILOVER_CLEANUP_TTL) {
+        this._lastFailoverAttempt.delete(nodeId)
+        this._failoverQueue.delete(nodeId)
+      }
+    }
+  }
+
+  getBrokenPlayersCount() {
+    return this._brokenPlayers.size
+  }
+
+  getNodeStats() {
+    const stats = {}
+    for (const [name, node] of this.nodeMap) {
+      const nodeStats = node.stats || {}
+      stats[name] = {
+        connected: node.connected,
+        players: nodeStats.players || 0,
+        playingPlayers: nodeStats.playingPlayers || 0,
+        uptime: nodeStats.uptime || 0,
+        cpu: nodeStats.cpu || {},
+        memory: nodeStats.memory || {},
+        ping: nodeStats.ping || 0
+      }
+    }
+    return stats
+  }
+
+  destroy() {
+    if (this._cleanupTimer) {
+      clearInterval(this._cleanupTimer)
+    }
 
-        for (const player of this.players.values()) {
-            this._cleanupPlayer(player);
-        }
+    this.removeAllListeners()
 
-        for (const node of this.nodeMap.values()) {
-            node.removeAllListeners();
-        }
+    for (const player of this.players.values()) {
+      this._cleanupPlayer(player)
+    }
 
-        this.players.clear();
-        this.nodeMap.clear();
-        this._brokenPlayers.clear();
-        this._nodeStates.clear();
-        this._failoverQueue.clear();
-        this._lastFailoverAttempt.clear();
+    for (const node of this.nodeMap.values()) {
+      node.removeAllListeners()
     }
 
-    _getAvailableNodes(excludeNode) {
-        const available = [];
-        for (const node of this.nodeMap.values()) {
-            if (node !== excludeNode && node.connected) {
-                available.push(node);
-            }
-        }
-        return available;
+    this.players.clear()
+    this.nodeMap.clear()
+    this._brokenPlayers.clear()
+    this._nodeStates.clear()
+    this._failoverQueue.clear()
+    this._lastFailoverAttempt.clear()
+  }
+
+  _getAvailableNodes(excludeNode) {
+    const available = []
+    for (const node of this.nodeMap.values()) {
+      if (node !== excludeNode && node.connected) {
+        available.push(node)
+      }
     }
+    return available
+  }
 }
 
-module.exports = Aqua;
+module.exports = Aqua