aqualink 2.6.4 → 2.7.0

package/build/structures/Aqua.js

@@ -14,9 +14,19 @@ const DEFAULT_OPTIONS = Object.freeze({
     restVersion: 'v4',
     plugins: [],
     autoResume: false,
-    infiniteReconnects: false
+    infiniteReconnects: false,
+    failoverOptions: {
+        enabled: true,
+        maxRetries: 3,
+        retryDelay: 1000,
+        preservePosition: true,
+        resumePlayback: true,
+        cooldownTime: 5000,
+        maxFailoverAttempts: 5
+    }
 });
-const LEAST_USED_CACHE_TTL = 50;
+
+const LEAST_USED_CACHE_TTL = 30;
 
 class Aqua extends EventEmitter {
     constructor(client, nodes, options = {}) {
@@ -34,35 +44,37 @@ class Aqua extends EventEmitter {
         this.initiated = false;
         this.version = pkgVersion;
 
-        this.options = Object.assign({}, DEFAULT_OPTIONS, options);
-
-        const {
-            shouldDeleteMessage,
-            defaultSearchPlatform,
-            leaveOnEnd,
-            restVersion,
-            plugins,
-            autoResume,
-            infiniteReconnects,
-            send
-        } = this.options;
-
-        this.shouldDeleteMessage = shouldDeleteMessage;
-        this.defaultSearchPlatform = defaultSearchPlatform;
-        this.leaveOnEnd = leaveOnEnd;
-        this.restVersion = restVersion;
-        this.plugins = plugins;
-        this.autoResume = autoResume;
-        this.infiniteReconnects = infiniteReconnects;
-
-        this.send = send || this.defaultSendFunction.bind(this);
+        this.options = { ...DEFAULT_OPTIONS, ...options };
+        this.failoverOptions = { ...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.defaultSendFunction.bind(this);
 
         this._leastUsedCache = { nodes: [], timestamp: 0 };
+        
+        this._nodeStates = new Map();
+        this._failoverQueue = new Map();
+        this._lastFailoverAttempt = new Map();
+        
+        this._boundCleanupPlayer = this.cleanupPlayer.bind(this);
+        this._boundHandlePlayerDestroy = this._handlePlayerDestroy.bind(this);
     }
 
-    defaultSendFunction(payload) {
-        const guild = this.client.guilds.cache.get(payload.d.guild_id);
-        if (guild) guild.shard.send(payload);
+    defaultSendFunction(packet) {
+        const guild = this.client?.cache?.guilds.get(packet.d.guild_id) ?? this.client.guilds.cache.get(packet.d.guild_id);
+        if (guild) {
+            if (this.client.gateway) {
+                this.client.gateway.send(this.client.gateway.calculateShardId(packet.d.guild_id), packet);
+            } else {
+                guild.shard.send(packet);
+            }
+        }
     }
 
     get leastUsedNodes() {
@@ -71,12 +83,9 @@ class Aqua extends EventEmitter {
             return this._leastUsedCache.nodes;
         }
 
-        const connectedNodes = [];
-        for (const node of this.nodeMap.values()) {
-            if (node.connected) connectedNodes.push(node);
-        }
-
-        connectedNodes.sort((a, b) => a.rest.calls - b.rest.calls);
+        const connectedNodes = Array.from(this.nodeMap.values())
+            .filter(node => node.connected)
+            .sort((a, b) => a.rest.calls - b.rest.calls);
 
         this._leastUsedCache = { nodes: connectedNodes, timestamp: now };
         return connectedNodes;
@@ -87,15 +96,23 @@ class Aqua extends EventEmitter {
         this.clientId = clientId;
 
         try {
-            const nodePromises = [];
-            for (const node of this.nodes) {
-                nodePromises.push(this.createNode(node));
+            const nodePromises = this.nodes.map(node => this.createNode(node).catch(err => {
+                console.error(`Failed to create node ${node.name || node.host}:`, err);
+                return null;
+            }));
+            
+            const results = await Promise.allSettled(nodePromises);
+            const successfulNodes = results.filter(r => r.status === 'fulfilled' && r.value).length;
+            
+            if (successfulNodes === 0) {
+                throw new Error("No nodes could be connected");
             }
-            await Promise.all(nodePromises);
 
-            for (const plugin of this.plugins) {
-                plugin.load(this);
-            }
+            await Promise.all(this.plugins.map(plugin => 
+                Promise.resolve(plugin.load(this)).catch(err => 
+                    console.error("Plugin load error:", err)
+                )
+            ));
 
             this.initiated = true;
         } catch (error) {
@@ -112,15 +129,17 @@ class Aqua extends EventEmitter {
 
         const node = new Node(this, options, this.options);
         this.nodeMap.set(nodeId, node);
-        this._leastUsedCache.timestamp = 0;
+        this._invalidateCache();
+
+        this._nodeStates.set(nodeId, { connected: false, failoverInProgress: false });
 
         try {
             await node.connect();
+            this._nodeStates.set(nodeId, { connected: true, failoverInProgress: false });
             this.emit("nodeCreate", node);
             return node;
         } catch (error) {
-            this.nodeMap.delete(nodeId);
-            console.error("Failed to connect node:", error);
+            this._cleanupNode(nodeId);
             throw error;
         }
     }
@@ -129,12 +148,263 @@ class Aqua extends EventEmitter {
         const node = this.nodeMap.get(identifier);
         if (!node) return;
 
-        node.destroy();
-        this.nodeMap.delete(identifier);
-        this._leastUsedCache.timestamp = 0;
+        this._cleanupNode(identifier);
         this.emit("nodeDestroy", node);
     }
 
+    _cleanupNode(nodeId) {
+        this.nodeMap.delete(nodeId);
+        this._nodeStates.delete(nodeId);
+        this._failoverQueue.delete(nodeId);
+        this._lastFailoverAttempt.delete(nodeId);
+        this._invalidateCache();
+    }
+
+    _invalidateCache() {
+        this._leastUsedCache.timestamp = 0;
+    }
+
+    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 currentAttempts = this._failoverQueue.get(nodeId) || 0;
+        if (currentAttempts >= this.failoverOptions.maxFailoverAttempts) return;
+
+        this._nodeStates.set(nodeId, { connected: false, failoverInProgress: true });
+        this._lastFailoverAttempt.set(nodeId, now);
+        this._failoverQueue.set(nodeId, currentAttempts + 1);
+        
+        try {
+            this.emit("nodeFailover", failedNode);
+            
+            const affectedPlayers = this._getPlayersForNode(failedNode);
+            if (affectedPlayers.length === 0) {
+                this._nodeStates.set(nodeId, { connected: false, failoverInProgress: false });
+                return;
+            }
+
+            const availableNodes = this._getAvailableNodesForFailover(failedNode);
+            if (availableNodes.length === 0) {
+                this.emit("error", null, new Error("No available nodes for failover"));
+                this._nodeStates.set(nodeId, { connected: false, failoverInProgress: false });
+                return;
+            }
+
+            const failoverResults = await this._migratePlayersWithRetry(affectedPlayers, availableNodes);
+            
+            const successful = failoverResults.filter(r => r.success).length;
+            const failed = failoverResults.length - successful;
+            
+            if (successful > 0) {
+                this.emit("nodeFailoverComplete", failedNode, successful, failed);
+            }
+            
+        } catch (error) {
+            this.emit("error", null, new Error(`Failover failed for node ${nodeId}: ${error.message}`));
+        } finally {
+            this._nodeStates.set(nodeId, { connected: false, failoverInProgress: false });
+        }
+    }
+
+    _getPlayersForNode(node) {
+        const affectedPlayers = [];
+        for (const player of this.players.values()) {
+            if (player.nodes === node || player.nodes?.name === node.name) {
+                affectedPlayers.push(player);
+            }
+        }
+        return affectedPlayers;
+    }
+
+    _getAvailableNodesForFailover(failedNode) {
+        return this.leastUsedNodes.filter(node => 
+            node !== failedNode && node.name !== failedNode.name
+        );
+    }
+
+    async _migratePlayersWithRetry(players, availableNodes) {
+        const results = [];
+        
+        const concurrency = 3;
+        for (let i = 0; i < players.length; i += concurrency) {
+            const batch = players.slice(i, i + concurrency);
+            const batchPromises = batch.map(async player => {
+                try {
+                    const result = await this._migratePlayer(player, availableNodes);
+                    return { player, success: true, result };
+                } catch (error) {
+                    await this._boundCleanupPlayer(player);
+                    return { player, success: false, error };
+                }
+            });
+            
+            const batchResults = await Promise.allSettled(batchPromises);
+            results.push(...batchResults.map(r => r.value || r.reason));
+        }
+        
+        return results;
+    }
+
+    async _migratePlayer(player, availableNodes) {
+        if (!player || !availableNodes.length) {
+            throw new Error("Invalid player or no available nodes");
+        }
+
+        const guildId = player.guildId;
+        let retryCount = 0;
+        
+        while (retryCount < this.failoverOptions.maxRetries) {
+            try {
+                const targetNode = this._selectBestNode(availableNodes, player);
+                if (!targetNode) throw new Error("No suitable node found");
+
+                const playerState = this._capturePlayerState(player);
+                if (!playerState) throw new Error("Failed to capture player state");
+
+                const newPlayer = await this._createPlayerOnNode(targetNode, player, playerState);
+                if (!newPlayer) throw new Error("Failed to create player on target node");
+
+                await this._restorePlayerState(newPlayer, playerState);
+                
+                newPlayer.destroy();
+                if (playerState.current) {
+                    newPlayer.queue.add(playerState.current);
+                }
+                
+                this.emit("playerMigrated", player, newPlayer, targetNode);
+                return newPlayer;
+                
+            } catch (error) {
+                retryCount++;
+                if (retryCount < this.failoverOptions.maxRetries) {
+                    await this._delay(this.failoverOptions.retryDelay);
+                } else {
+                    throw error;
+                }
+            }
+        }
+    }
+
+    _selectBestNode(availableNodes, player) {
+        if (player.region) {
+            const regionNode = availableNodes.find(node => 
+                node.regions?.includes(player.region.toLowerCase())
+            );
+            if (regionNode) return regionNode;
+        }
+        
+        return availableNodes[0];
+    }
+
+    _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 ? { ...player.current } : null,
+                queue: player.queue?.tracks ? [...player.queue.tracks] : [],
+                repeat: player.repeat,
+                shuffle: player.shuffle,
+                deaf: player.deaf || false,
+                mute: player.mute || false,
+                region: player.region,
+                requester: player.requester,
+                timestamp: Date.now()
+            };
+        } catch (error) {
+            return null;
+        }
+    }
+
+    async _createPlayerOnNode(targetNode, originalPlayer, playerState) {
+        const options = {
+            guildId: playerState.guildId,
+            textChannel: playerState.textChannel,
+            voiceChannel: playerState.voiceChannel,
+            defaultVolume: playerState.volume || 100,
+            deaf: playerState.deaf || false,
+            mute: playerState.mute || false,
+            region: playerState.region
+        };
+
+        return this.createPlayer(targetNode, options);
+    }
+
+    async _restorePlayerState(newPlayer, playerState) {
+        if (!newPlayer || !playerState) return;
+
+        try {
+            // Batch operations where possible
+            const operations = [];
+            
+            if (playerState.volume !== undefined) {
+                operations.push(newPlayer.setVolume(playerState.volume));
+            }
+
+            // Restore queue efficiently
+            if (playerState.queue?.length > 0) {
+                newPlayer.queue.add(...playerState.queue);
+            }
+
+            // Wait for all operations
+            await Promise.all(operations);
+
+            // Handle current track restoration
+            if (playerState.current && this.failoverOptions.preservePosition) {
+                newPlayer.queue.unshift(playerState.current);
+                
+                if (this.failoverOptions.resumePlayback) {
+                    await newPlayer.play();
+                    
+                    if (playerState.position > 0) {
+                        await this._delay(300); // Reduced delay
+                        await newPlayer.seek(playerState.position);
+                    }
+                    
+                    if (playerState.paused) {
+                        await newPlayer.pause();
+                    }
+                }
+            }
+
+            // Restore other properties
+            Object.assign(newPlayer, {
+                repeat: playerState.repeat,
+                shuffle: playerState.shuffle
+            });
+
+        } catch (error) {
+            throw error;
+        }
+    }
+
+    _delay(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+
+    // Optimized cleanup
+    async cleanupPlayer(player) {
+        if (!player) return;
+        try {
+            await player.destroy();
+        } catch (error) {
+            // Silent fail for cleanup
+        }
+    }
+
     updateVoiceState({ d, t }) {
         const player = this.players.get(d.guild_id);
         if (!player) return;
@@ -147,7 +417,7 @@ class Aqua extends EventEmitter {
             }
 
             if (d.channel_id === null) {
-                this.cleanupPlayer(player);
+                this._boundCleanupPlayer(player);
             }
         }
     }
@@ -164,34 +434,33 @@ class Aqua extends EventEmitter {
             }
         }
 
+        // Optimized sorting with caching
         const loadCache = new Map();
         regionNodes.sort((a, b) => {
-            if (!loadCache.has(a)) loadCache.set(a, this.calculateLoad(a));
-            if (!loadCache.has(b)) loadCache.set(b, this.calculateLoad(b));
-            return loadCache.get(a) - loadCache.get(b);
+            const loadA = loadCache.get(a) ?? (loadCache.set(a, this._calculateLoad(a)), loadCache.get(a));
+            const loadB = loadCache.get(b) ?? (loadCache.set(b, this._calculateLoad(b)), loadCache.get(b));
+            return loadA - loadB;
         });
 
         return regionNodes;
     }
 
-    calculateLoad(node) {
+    _calculateLoad(node) {
         const stats = node?.stats?.cpu;
         if (!stats) return 0;
-        const { systemLoad, cores } = stats;
-        return (systemLoad / cores) * 100;
+        return (stats.systemLoad / stats.cores) * 100;
     }
 
     createConnection(options) {
         if (!this.initiated) throw new Error("Aqua must be initialized before this operation");
 
         const existingPlayer = this.players.get(options.guildId);
-        if (existingPlayer && existingPlayer.voiceChannel) return existingPlayer;
+        if (existingPlayer?.voiceChannel) return existingPlayer;
 
         const availableNodes = options.region ? this.fetchRegion(options.region) : this.leastUsedNodes;
-        const node = availableNodes[0];
-        if (!node) throw new Error("No nodes are available");
+        if (!availableNodes.length) throw new Error("No nodes are available");
 
-        return this.createPlayer(node, options);
+        return this.createPlayer(availableNodes[0], options);
     }
 
     createPlayer(node, options) {
@@ -200,16 +469,18 @@ class Aqua extends EventEmitter {
         const player = new Player(this, node, options);
         this.players.set(options.guildId, player);
 
-        player.on("destroy", () => {
-            this.players.delete(options.guildId);
-            this.emit("playerDestroy", player);
-        });
-
+        // Use pre-bound method for better performance
+        player.once("destroy", this._boundHandlePlayerDestroy);
         player.connect(options);
         this.emit("playerCreate", player);
         return player;
     }
 
+    _handlePlayerDestroy(player) {
+        this.players.delete(player.guildId);
+        this.emit("playerDestroy", player);
+    }
+
     async destroyPlayer(guildId) {
         const player = this.players.get(guildId);
         if (!player) return;
@@ -220,14 +491,14 @@ class Aqua extends EventEmitter {
             this.players.delete(guildId);
             this.emit("playerDestroy", player);
         } catch (error) {
-            console.error(`Error destroying player for guild ${guildId}:`, error);
+            // Silent fail for cleanup
         }
     }
 
     async resolve({ query, source = this.defaultSearchPlatform, requester, nodes }) {
         if (!this.initiated) throw new Error("Aqua must be initialized before this operation");
 
-        const requestNode = this.getRequestNode(nodes);
+        const requestNode = this._getRequestNode(nodes);
         const formattedQuery = URL_REGEX.test(query) ? query : `${source}:${query}`;
 
         try {
@@ -235,10 +506,10 @@ class Aqua extends EventEmitter {
             const response = await requestNode.rest.makeRequest("GET", endpoint);
 
             if (["empty", "NO_MATCHES"].includes(response.loadType)) {
-                return await this.handleNoMatches(query);
+                return this._createEmptyResponse();
             }
 
-            return this.constructResponse(response, requester, requestNode);
+            return this._constructResponse(response, requester, requestNode);
         } catch (error) {
             if (error.name === "AbortError") {
                 throw new Error("Request timed out");
@@ -247,19 +518,16 @@ class Aqua extends EventEmitter {
         }
     }
 
-    getRequestNode(nodes) {
+    _getRequestNode(nodes) {
         if (!nodes) return this.leastUsedNodes[0];
-
         if (nodes instanceof Node) return nodes;
         if (typeof nodes === "string") {
-            const mappedNode = this.nodeMap.get(nodes);
-            return mappedNode || this.leastUsedNodes[0];
+            return this.nodeMap.get(nodes) || this.leastUsedNodes[0];
         }
-
         throw new TypeError(`'nodes' must be a string or Node instance, received: ${typeof nodes}`);
     }
 
-    async handleNoMatches(query) {
+    _createEmptyResponse() {
         return {
             loadType: "empty",
             exception: null,
@@ -269,7 +537,7 @@ class Aqua extends EventEmitter {
         };
     }
 
-    async constructResponse(response, requester, requestNode) {
+    _constructResponse(response, requester, requestNode) {
         const baseResponse = {
             loadType: response.loadType,
             exception: null,
@@ -283,44 +551,34 @@ class Aqua extends EventEmitter {
             return baseResponse;
         }
 
-        const trackFactory = (trackData) => new Track(trackData, requester, requestNode);
-
         switch (response.loadType) {
             case "track":
                 if (response.data) {
-                    baseResponse.tracks.push(trackFactory(response.data));
+                    baseResponse.tracks.push(new Track(response.data, requester, requestNode));
                 }
                 break;
+                
             case "playlist": {
                 const info = response.data?.info;
                 if (info) {
-                    const playlistInfo = {
+                    baseResponse.playlistInfo = {
                         name: info.name ?? info.title,
                         thumbnail: response.data.pluginInfo?.artworkUrl ?? (response.data.tracks?.[0]?.info?.artworkUrl || null),
                         ...info
                     };
-                    baseResponse.playlistInfo = playlistInfo;
                 }
 
                 const tracks = response.data?.tracks;
                 if (tracks?.length) {
-                    const trackCount = tracks.length;
-                    baseResponse.tracks = new Array(trackCount);
-                    for (let i = 0; i < trackCount; i++) {
-                        baseResponse.tracks[i] = trackFactory(tracks[i]);
-                    }
+                    baseResponse.tracks = tracks.map(track => new Track(track, requester, requestNode));
                 }
                 break;
             }
 
             case "search": {
                 const searchData = response.data ?? [];
-                const dataLength = searchData.length;
-                if (dataLength) {
-                    baseResponse.tracks = new Array(dataLength);
-                    for (let i = 0; i < dataLength; i++) {
-                        baseResponse.tracks[i] = trackFactory(searchData[i]);
-                    }
+                if (searchData.length) {
+                    baseResponse.tracks = searchData.map(track => new Track(track, requester, requestNode));
                 }
                 break;
             }
@@ -342,110 +600,163 @@ class Aqua extends EventEmitter {
             const { tracks } = await this.resolve({ query, source, requester });
             return tracks || null;
         } catch (error) {
-            console.error("Search error:", error);
             return null;
         }
     }
 
+    // Optimized save/load methods
     async savePlayer(filePath = "./AquaPlayers.json") {
-        const data = Array.from(this.players.values()).map(player => ({
+        const data = Array.from(this.players.values(), player => ({
             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) || [],
+            q: player.queue?.tracks?.slice(0, 5).map(tr => tr.uri) || [],
             r: player.requester || player.current?.requester,
             vol: player.volume,
-            pa: player.paused
+            pa: player.paused,
+            n: player.nodes?.name || null
         }));
+        
         await fs.writeFile(filePath, JSON.stringify(data), "utf8");
-        this.emit("debug", "Aqua", `Saved ${data.length} players to ${filePath}`);
-    }
-
-    async waitForFirstNode() {
-        if (this.leastUsedNodes.length > 0) return;
-        return new Promise(resolve => {
-            const check = () => {
-                if (this.leastUsedNodes.length > 0) {
-                    resolve();
-                } else {
-                    setTimeout(check, 100);
-                }
-            };
-            check();
-        });
     }
 
     async loadPlayers(filePath = "./AquaPlayers.json") {
         try {
-            await fs.promises.access(filePath);
-        } catch {
-            this.emit("debug", "Aqua", `File ${filePath} does not exist, skipping load.`);
-            return;
+            await fs.access(filePath);
+            await this._waitForFirstNode();
+            
+            const data = JSON.parse(await fs.readFile(filePath, "utf8"));
+            
+            // Process in batches to avoid overwhelming
+            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 fail if file doesn't exist
         }
+    }
+
+    async _restorePlayer(p) {
         try {
-            await this.waitForFirstNode();
-            const data = JSON.parse(await fs.readFile(filePath, "utf8"));
-            for (const p of data) {
-                let player = this.players.get(p.g);
-                if (!player) {
-                    player = await this.createConnection({
-                        guildId: p.g,
-                        textChannel: p.t,
-                        voiceChannel: p.v,
-                        defaultVolume: p.vol || 65,
-                        deaf: true
-                    });
-                }
+            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 && resolved.tracks.length > 0) {
-                        player.queue.add(resolved.tracks[0]);
-                        player.position = p.p || 0;
-                        if (typeof p.ts === "number") {
-                            player.timestamp = p.ts;
-                        }
-                    }
+            // Restore current track
+            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 (Array.isArray(p.q) && player) {
-                    for (const uri of p.q) {
-                        if (!p.u || uri !== p.u) {
-                            const resolved = await this.resolve({ query: uri, requester: p.r });
-                            if (resolved.tracks && resolved.tracks.length > 0) {
-                                player.queue.add(resolved.tracks[0]);
-                                player.position = p.p || 0;
-                                if (typeof p.ts === "number") {
-                                    player.timestamp = p.ts;
-                                }
-                            }
-                        }
-                    }
-                }
-                if (player) {
-                    player.paused = !!p.pa;
-                    if (!player.playing && !player.paused && player.queue.size > 0) {
-                        player.play();
+            }
+            
+            // Restore queue
+            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) {
+                player.paused = !!p.pa;
+                if (!player.playing && !player.paused && player.queue.size > 0) {
+                    player.play();
                 }
             }
-            await fs.writeFile(filePath, "[]", "utf8");
-            this.emit("debug", "Aqua", `Loaded players from ${filePath} and cleared its content.`);
         } catch (error) {
-            console.error(`Failed to load players from ${filePath}:`, error);
+            // Silent fail for individual player restoration
         }
     }
 
-    async cleanupPlayer(player) {
-        if (!player) return;
+    async _waitForFirstNode() {
+        if (this.leastUsedNodes.length > 0) return;
+        
+        return new Promise(resolve => {
+            const checkInterval = setInterval(() => {
+                if (this.leastUsedNodes.length > 0) {
+                    clearInterval(checkInterval);
+                    resolve();
+                }
+            }, 100);
+        });
+    }
 
-        try {
-            await player.destroy();
-        } catch (error) {
-            console.error(`Error during player cleanup: ${error.message}`);
+    // Utility methods
+    resetFailoverAttempts(nodeId) {
+        this._failoverQueue.delete(nodeId);
+        this._lastFailoverAttempt.delete(nodeId);
+        const nodeState = this._nodeStates.get(nodeId);
+        if (nodeState) nodeState.failoverInProgress = false;
+    }
+
+    getFailoverStatus() {
+        const status = {};
+        for (const [nodeId, attempts] of this._failoverQueue) {
+            const lastAttempt = this._lastFailoverAttempt.get(nodeId);
+            const nodeState = this._nodeStates.get(nodeId);
+            status[nodeId] = {
+                attempts,
+                lastAttempt,
+                inProgress: nodeState?.failoverInProgress || false,
+                connected: nodeState?.connected || false
+            };
+        }
+        return status;
+    }
+
+    getNodeStats() {
+        const stats = {};
+        for (const [name, node] of this.nodeMap) {
+            stats[name] = {
+                connected: node.connected,
+                players: node.stats?.players || 0,
+                playingPlayers: node.stats?.playingPlayers || 0,
+                uptime: node.stats?.uptime || 0,
+                cpu: node.stats?.cpu || {},
+                memory: node.stats?.memory || {},
+                ping: node.stats?.ping || 0
+            };
+        }
+        return stats;
+    }
+    
+    async forceFailover(nodeIdentifier) {
+        const node = this.nodeMap.get(nodeIdentifier);
+        if (!node) return;
+        
+        if (node.connected) {
+            await node.destroy();
         }
+        
+        this._cleanupNode(nodeIdentifier);
     }
 }
 

package/build/structures/Node.js

@@ -51,9 +51,10 @@ class Node {
         this.ws = null;
         this.reconnectAttempted = 0;
         this.reconnectTimeoutId = null;
+        this.isDestroyed = false;
+        this.lastHealthCheck = Date.now();
 
         this._headers = this._constructHeaders();
-
         this.initializeStats();
     }
 
@@ -73,7 +74,7 @@ class Node {
         const headers = {
             Authorization: this.password,
             "User-Id": this.aqua.clientId,
-            "Client-Name": `Aqua/${this.aqua.version} (https://github.com/ToddyTheNoobDud/AquaLink`
+            "Client-Name": `Aqua/${this.aqua.version} (https://github.com/ToddyTheNoobDud/AquaLink)`
         };
 
         if (this.sessionId) {
@@ -86,13 +87,13 @@ class Node {
     async _onOpen() {
         this.connected = true;
         this.reconnectAttempted = 0;
+        this.lastHealthCheck = Date.now();
         this.aqua.emit("debug", this.name, "WebSocket connection established");
 
         if (this.aqua.bypassChecks?.nodeFetchInfo) return;
 
         try {
             this.info = await this.rest.makeRequest("GET", "/v4/info");
-
             this.aqua.emit("nodeConnected", this);
 
             if (this.autoResume && this.sessionId) {
@@ -120,41 +121,37 @@ class Node {
         const op = payload?.op;
         if (!op) return;
 
-        switch (op) {
-            case "stats":
-                this._updateStats(payload);
-                break;
-            case "ready":
-                this._handleReadyOp(payload);
-                break;
-            case "LyricsLineEvent": {
-                const player = payload.guildId ? this.aqua.players.get(payload.guildId) : null;
-                const track = payload.track || null;
-                this.aqua.emit("LyricsLineEvent", player, track, payload);
-                break;
-            }
-            case "LyricsFoundEvent": {
-                const player = payload.guildId ? this.aqua.players.get(payload.guildId) : null;
-                const track = payload.track || null;
-                this.aqua.emit("LyricsFoundEvent", player, track, payload);
-                break;
-            }
-            default:
-                if (payload.guildId) {
-                    const player = this.aqua.players.get(payload.guildId);
-                    if (player) player.emit(op, payload);
-                }
-                break;
+        this.lastHealthCheck = Date.now();
+
+        if (op === "stats") {
+            this._updateStats(payload);
+            return;
+        }
+        if (op === "ready") {
+            this._handleReadyOp(payload);
+            return;
+        }
+
+        if (op.startsWith("Lyrics")) {
+            const player = payload.guildId ? this.aqua.players.get(payload.guildId) : null;
+            const track = payload.track || null;
+            this.aqua.emit(op, player, track, payload);
+            return;
+        }
+
+        if (payload.guildId) {
+            const player = this.aqua.players.get(payload.guildId);
+            if (player) player.emit(op, payload);
         }
     }
 
     _onClose(code, reason) {
         this.connected = false;
+        const reasonStr = reason?.toString() || "No reason provided";
 
-        this.aqua.emit("nodeDisconnect", this, {
-            code,
-            reason: reason?.toString() || "No reason provided"
-        });
+        this.aqua.emit("nodeDisconnect", this, { code, reason: reasonStr });
+
+        this.aqua.handleNodeFailover(this);
 
         this.scheduleReconnect(code);
     }
@@ -162,7 +159,7 @@ class Node {
     scheduleReconnect(code) {
         this.clearReconnectTimeout();
 
-        if (code === Node.WS_CLOSE_NORMAL) {
+        if (code === Node.WS_CLOSE_NORMAL || this.isDestroyed) {
             this.aqua.emit("debug", this.name, "WebSocket closed normally, not reconnecting");
             return;
         }
@@ -204,6 +201,8 @@ class Node {
     }
 
     async connect() {
+        if (this.isDestroyed) return;
+        
         if (this.ws && this.ws.readyState === Node.WS_OPEN) {
             this.aqua.emit("debug", this.name, "WebSocket already connected");
             return;
@@ -231,7 +230,7 @@ class Node {
             try {
                 this.ws.close();
             } catch (err) {
-               this.emitError(`Failed to close WebSocket: ${err.message}`);
+                this.emitError(`Failed to close WebSocket: ${err.message}`);
             }
         }
 
@@ -239,25 +238,21 @@ class Node {
     }
 
     destroy(clean = false) {
+        this.isDestroyed = true;
         this.clearReconnectTimeout();
         this.cleanupExistingConnection();
 
         if (!clean) {
-            for (const player of this.aqua.players.values()) {
-                if (player.nodes === this) {
-                    player.destroy();
-                }
-            }
+            this.aqua.handleNodeFailover(this);
         }
 
         this.connected = false;
-        this.aqua.nodes.delete(this.name);
+        this.aqua.destroyNode(this.name);
         this.aqua.emit("nodeDestroy", this);
         this.info = null;
     }
 
     async getStats() {
-        
         if (this.connected && this.stats) {
             return this.stats;
         }
@@ -344,13 +339,11 @@ class Node {
     async resumePlayers() {
         try {
             await this.aqua.loadPlayers();
-
             this.aqua.emit("debug", this.name, "Session resumed successfully");
         } catch (err) {
             this.emitError(`Failed to resume session: ${err.message}`);
         }
     }
-
     emitError(error) {
         const errorObj = error instanceof Error ? error : new Error(error);
         console.error(`[Aqua] [${this.name}] Error:`, errorObj);

package/build/structures/Player.js

@@ -18,7 +18,8 @@ const EVENT_HANDLERS = Object.freeze({
     TrackChangeEvent: "trackChange",
     WebSocketClosedEvent: "socketClosed",
     LyricsLineEvent: "lyricsLine",
-    LyricsFoundEvent: "lyricsFound" // <-- add this line
+    LyricsFoundEvent: "lyricsFound" ,
+    LyricsNotFoundEvent: "lyricsNotFound"
 });
 
 
@@ -248,37 +249,47 @@ class Player extends EventEmitter {
         return this;
     }
 
-    destroy() {
-        if (!this.connected) return this;
+  destroy() {
+    if (!this.connected) return this;
 
-        const voiceChannelId = this.voiceChannel ? this.voiceChannel.id || this.voiceChannel : null;
-        this._updateBatcher.destroy();
+    const voiceChannelId = this.voiceChannel ? this.voiceChannel.id || this.voiceChannel : null;
+    this._updateBatcher.destroy();
 
-        this.send({ guild_id: this.guildId, channel_id: null });
-        this._lastVoiceChannel = voiceChannelId;
-        this.voiceChannel = null;
-        this.connected = false;
-        this.send({ guild_id: this.guildId, channel_id: null });
+    this.send({ guild_id: this.guildId, channel_id: null });
+    this._lastVoiceChannel = voiceChannelId;
+    this.voiceChannel = null;
+    this.connected = false;
+    this.send({ guild_id: this.guildId, channel_id: null });
 
-        if (this.nowPlayingMessage) {
-            this.nowPlayingMessage.delete().catch(() => { });
-            this.nowPlayingMessage = null;
-        }
+    if (this.nowPlayingMessage) {
+        this.nowPlayingMessage.delete().catch(() => { });
+        this.nowPlayingMessage = null;
+    }
 
-        this.isAutoplay = false;
-        this.aqua.destroyPlayer(this.guildId);
-        this.nodes.rest.destroyPlayer(this.guildId);
-        this.previousTracksCount = 0;
-        this._dataStore.clear();
-        this.removeAllListeners();
+    this.isAutoplay = false;
+    this.aqua.destroyPlayer(this.guildId);
+    
+    if (this.nodes?.connected) {
+        try {
+            this.nodes.rest.destroyPlayer(this.guildId);
+        } catch (error) {
+            if (!error.message.includes('ECONNREFUSED')) {
+                console.error('Error destroying player on node:', error);
+            }
+        }
+    }
+    
+    this.previousTracksCount = 0;
+    this._dataStore.clear();
+    this.removeAllListeners();
 
-        this.queue = null;
-        this.previousTracks = null;
-        this.connection = null;
-        this.filters = null;
+    this.queue = null;
+    this.previousTracks = null;
+    this.connection = null;
+    this.filters = null;
 
-        return this;
-    }
+    return this;
+}
 
     pause(paused) {
         if (this.paused === paused) return this;
@@ -324,12 +335,16 @@ class Player extends EventEmitter {
         return this.nodes.rest.unsubscribeLiveLyrics(this.guildId);
     }
 
-    seek(position) {
-        if (!this.playing) return this;
-        this.position += position;
-        this.batchUpdatePlayer({ position: this.position });
-        return this;
+  seek(position) {
+    if (!this.playing) return this;
+    if (position < 0) position = 0;
+    if (this.current?.info?.length && position > this.current.info.length) {
+      position = this.current.info.length;
     }
+    this.position = position;
+    this.batchUpdatePlayer({ position: this.position });
+    return this;
+  }
 
     stop() {
         if (!this.playing) return this;
@@ -520,6 +535,10 @@ class Player extends EventEmitter {
         this.aqua.emit("lyricsFound", player, track, payload);
     }
 
+    async lyricsNotFound(player, track, payload) {
+        this.aqua.emit("lyricsNotFound", player, track, payload);
+    }
+
     send(data) {
         this.aqua.send({ op: 4, d: data });
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aqualink",
-  "version": "2.6.4",
+  "version": "2.7.0",
   "description": "An Lavalink client, focused in pure performance and features",
   "main": "build/index.js",
   "types": "index.d.ts",
@@ -41,7 +41,7 @@
     "url": "https://github.com/ToddyTheNoobDud/AquaLink"
   },
   "dependencies": {
-    "ws": "^8.18.2",
+    "ws": "^8.18.3",
     "fs-extra": "^11.3.0",
 		"tseep": "^1.3.1"
   },