lavalink-client 2.4.4 → 2.4.6

package/README.md

@@ -808,3 +808,14 @@ if(previousTrack) {
   - Added the try to play the next track if there is no current track
     - *There was a problem trying to auto-reconnect on-Disconnect while the queue was empty, which caused the player to get destroyed by that and log the error in console "`There is no Track in the Queue, nor provided in the PlayOptions`"*
     - *Now you have to handle that case manually if you want to or set autoReconnectOnlyWithTracks to false (default)*
+
+
+## **Version 2.4.4 - Version 2.4.6**
+- `player.changeNode()` is fixed and works - thanks to @PandaIN95
+- The code got re-formatted and re-structured, no code-changes are needed to be made, but it's now cleaner & more readable in some areas
+- The same for the testbot Folder(s), also it imports lavalink-client directly, so you can just copy it and move on from it.
+- Some minor Fixess:
+  - Autoplay sometimes doesn't get called when previousAutoplay call failed.
+  - remove structuredClone so that it works in bun more stable
+  - Player Options Validation also allows single property objects
+  - Some typos were fixed

package/dist/cjs/structures/Constants.d.ts

@@ -49,6 +49,8 @@ export declare enum DestroyReasons {
     NodeReconnectFail = "NodeReconnectFail",
     Disconnected = "Disconnected",
     PlayerReconnectFail = "PlayerReconnectFail",
+    PlayerChangeNodeFail = "PlayerChangeNodeFail",
+    PlayerChangeNodeFailNoEligibleNode = "PlayerChangeNodeFailNoEligibleNode",
     ChannelDeleted = "ChannelDeleted",
     DisconnectAllNodes = "DisconnectAllNodes",
     ReconnectAllNodes = "ReconnectAllNodes",

package/dist/cjs/structures/Constants.js

@@ -53,6 +53,8 @@ var DestroyReasons;
     DestroyReasons["NodeReconnectFail"] = "NodeReconnectFail";
     DestroyReasons["Disconnected"] = "Disconnected";
     DestroyReasons["PlayerReconnectFail"] = "PlayerReconnectFail";
+    DestroyReasons["PlayerChangeNodeFail"] = "PlayerChangeNodeFail";
+    DestroyReasons["PlayerChangeNodeFailNoEligibleNode"] = "PlayerChangeNodeFailNoEligibleNode";
     DestroyReasons["ChannelDeleted"] = "ChannelDeleted";
     DestroyReasons["DisconnectAllNodes"] = "DisconnectAllNodes";
     DestroyReasons["ReconnectAllNodes"] = "ReconnectAllNodes";

package/dist/cjs/structures/Node.d.ts

@@ -173,14 +173,20 @@ export declare class LavalinkNode {
      * Destroys the Node-Connection (Websocket) and all player's of the node
      * @param destroyReason Destroy Reason to use when destroying the players
      * @param deleteNode wether to delete the nodte from the nodes list too, if false it will emit a disconnect. @default true
+     * @param movePlayers whether to movePlayers to different eligible connected node. If false players won't be moved @default false
      * @returns void
      *
      * @example
+     * Destroys node and its players
      * ```ts
      * player.node.destroy("custom Player Destroy Reason", true);
      * ```
+     * destroys only the node and moves its players to different connected node.
+     * ```ts
+     * player.node.destroy("custom Player Destroy Reason", true, true);
+     * ```
      */
-    destroy(destroyReason?: DestroyReasonsType, deleteNode?: boolean): void;
+    destroy(destroyReason?: DestroyReasonsType, deleteNode?: boolean, movePlayers?: boolean): void;
     /**
      * Disconnects the Node-Connection (Websocket)
      * @param disconnectReason Disconnect Reason to use when disconnecting Node

package/dist/cjs/structures/Node.js

@@ -412,32 +412,94 @@ class LavalinkNode {
      * Destroys the Node-Connection (Websocket) and all player's of the node
      * @param destroyReason Destroy Reason to use when destroying the players
      * @param deleteNode wether to delete the nodte from the nodes list too, if false it will emit a disconnect. @default true
+     * @param movePlayers whether to movePlayers to different eligible connected node. If false players won't be moved @default false
      * @returns void
      *
      * @example
+     * Destroys node and its players
      * ```ts
      * player.node.destroy("custom Player Destroy Reason", true);
      * ```
+     * destroys only the node and moves its players to different connected node.
+     * ```ts
+     * player.node.destroy("custom Player Destroy Reason", true, true);
+     * ```
      */
-    destroy(destroyReason, deleteNode = true) {
+    destroy(destroyReason, deleteNode = true, movePlayers = false) {
         if (!this.connected)
             return;
         const players = this.NodeManager.LavalinkManager.players.filter(p => p.node.id === this.id);
-        if (players)
-            players.forEach(p => {
-                p.destroy(destroyReason || Constants_1.DestroyReasons.NodeDestroy);
+        if (players.size) {
+            const enableDebugEvents = this.NodeManager.LavalinkManager.options?.advancedOptions?.enableDebugEvents;
+            const handlePlayerOperations = () => {
+                if (movePlayers) {
+                    const nodeToMove = Array.from(this.NodeManager.leastUsedNodes("playingPlayers"))
+                        .find(n => n.connected && n.options.id !== this.id);
+                    if (nodeToMove) {
+                        return Promise.allSettled(Array.from(players.values()).map(player => player.changeNode(nodeToMove.options.id)
+                            .catch(error => {
+                            if (enableDebugEvents) {
+                                console.error(`Node > destroy() Failed to move player ${player.guildId}: ${error.message}`);
+                            }
+                            return player.destroy(error.message ?? Constants_1.DestroyReasons.PlayerChangeNodeFail)
+                                .catch(destroyError => {
+                                if (enableDebugEvents) {
+                                    console.error(`Node > destroy() Failed to destroy player ${player.guildId} after move failure: ${destroyError.message}`);
+                                }
+                            });
+                        })));
+                    }
+                    else {
+                        return Promise.allSettled(Array.from(players.values()).map(player => player.destroy(Constants_1.DestroyReasons.PlayerChangeNodeFailNoEligibleNode)
+                            .catch(error => {
+                            if (enableDebugEvents) {
+                                console.error(`Node > destroy() Failed to destroy player ${player.guildId}: ${error.message}`);
+                            }
+                        })));
+                    }
+                }
+                else {
+                    return Promise.allSettled(Array.from(players.values()).map(player => player.destroy(destroyReason || Constants_1.DestroyReasons.NodeDestroy)
+                        .catch(error => {
+                        if (enableDebugEvents) {
+                            console.error(`Node > destroy() Failed to destroy player ${player.guildId}: ${error.message}`);
+                        }
+                    })));
+                }
+            };
+            // Handle all player operations first, then clean up the socket
+            handlePlayerOperations().finally(() => {
+                this.socket.close(1000, "Node-Destroy");
+                this.socket.removeAllListeners();
+                this.socket = null;
+                this.reconnectAttempts = 1;
+                clearTimeout(this.reconnectTimeout);
+                if (deleteNode) {
+                    this.NodeManager.emit("destroy", this, destroyReason);
+                    this.NodeManager.nodes.delete(this.id);
+                    clearInterval(this.heartBeatInterval);
+                    clearTimeout(this.pingTimeout);
+                }
+                else {
+                    this.NodeManager.emit("disconnect", this, { code: 1000, reason: destroyReason });
+                }
             });
-        this.socket.close(1000, "Node-Destroy");
-        this.socket.removeAllListeners();
-        this.socket = null;
-        this.reconnectAttempts = 1;
-        clearTimeout(this.reconnectTimeout);
-        if (deleteNode) {
-            this.NodeManager.emit("destroy", this, destroyReason);
-            this.NodeManager.nodes.delete(this.id);
         }
-        else {
-            this.NodeManager.emit("disconnect", this, { code: 1000, reason: destroyReason });
+        else { // If no players, proceed with socket cleanup immediately
+            this.socket.close(1000, "Node-Destroy");
+            this.socket.removeAllListeners();
+            this.socket = null;
+            this.reconnectAttempts = 1;
+            clearTimeout(this.reconnectTimeout);
+            if (deleteNode) {
+                this.NodeManager.emit("destroy", this, destroyReason);
+                this.NodeManager.nodes.delete(this.id);
+                clearInterval(this.heartBeatInterval);
+                clearTimeout(this.pingTimeout);
+            }
+            else {
+                this.NodeManager.emit("disconnect", this, { code: 1000, reason: destroyReason });
+            }
         }
         return;
     }
@@ -966,8 +1028,11 @@ class LavalinkNode {
         if (code === 1000 && reason === "Node-Disconnect")
             return; // manually disconnected and already emitted the event.
         this.NodeManager.emit("disconnect", this, { code, reason });
-        if (code !== 1000 || reason !== "Node-Destroy")
-            this.reconnect();
+        if (code !== 1000 || reason !== "Node-Destroy") {
+            if (this.NodeManager.nodes.has(this.id)) { // try to reconnect only when the node is still in the nodeManager.nodes list
+                this.reconnect();
+            }
+        }
     }
     /** @private util function for handling error events from websocket */
     error(error) {
@@ -1159,6 +1224,8 @@ class LavalinkNode {
     }
     /** @private util function for handling trackEnd event */
     async trackEnd(player, track, payload) {
+        if (player.get('internal_nodeChanging') === true)
+            return; // Check if nodeChange is in Progress than stop the trackEnd Event from being triggered.
         const trackToUse = track || this.getTrackOfPayload(payload);
         // If a track was forcibly played
         if (payload.reason === "replaced") {
@@ -1374,6 +1441,8 @@ class LavalinkNode {
     }
     /** private util function for handling the queue end event */
     async queueEnd(player, track, payload) {
+        if (player.get('internal_nodeChanging') === true)
+            return; // Check if nodeChange is in Progress than stop the queueEnd Event from being triggered.
         // add previous track to the queue!
         player.queue.current = null;
         player.playing = false;

package/dist/cjs/structures/NodeManager.d.ts

@@ -83,7 +83,18 @@ export declare class NodeManager extends EventEmitter {
     /**
      * Delete a node from the nodeManager and destroy it
      * @param node The node to delete
+     * @param movePlayers whether to movePlayers to different connected node before deletion. @default false
      * @returns
+     *
+     * @example
+     * Deletes the node
+     * ```ts
+     * client.lavalink.nodeManager.deleteNode("nodeId to delete");
+     * ```
+     * Moves players to a different node before deleting
+     * ```ts
+     * client.lavalink.nodeManager.deleteNode("nodeId to delete", true);
+     * ```
      */
-    deleteNode(node: LavalinkNodeIdentifier | LavalinkNode): void;
+    deleteNode(node: LavalinkNodeIdentifier | LavalinkNode, movePlayers?: boolean): void;
 }

package/dist/cjs/structures/NodeManager.js

@@ -196,13 +196,27 @@ class NodeManager extends events_1.EventEmitter {
     /**
      * Delete a node from the nodeManager and destroy it
      * @param node The node to delete
+     * @param movePlayers whether to movePlayers to different connected node before deletion. @default false
      * @returns
+     *
+     * @example
+     * Deletes the node
+     * ```ts
+     * client.lavalink.nodeManager.deleteNode("nodeId to delete");
+     * ```
+     * Moves players to a different node before deleting
+     * ```ts
+     * client.lavalink.nodeManager.deleteNode("nodeId to delete", true);
+     * ```
      */
-    deleteNode(node) {
+    deleteNode(node, movePlayers = false) {
         const decodeNode = typeof node === "string" ? this.nodes.get(node) : node || this.leastUsedNodes()[0];
         if (!decodeNode)
             throw new Error("Node was not found");
-        decodeNode.destroy(Constants_1.DestroyReasons.NodeDeleted);
+        if (movePlayers)
+            decodeNode.destroy(Constants_1.DestroyReasons.NodeDeleted, true, true);
+        else
+            decodeNode.destroy(Constants_1.DestroyReasons.NodeDeleted);
         this.nodes.delete(decodeNode.id);
         return;
     }

package/dist/cjs/structures/Player.d.ts

@@ -217,8 +217,9 @@ export declare class Player {
     /**
      * Move the player on a different Audio-Node
      * @param newNode New Node / New Node Id
+     * @param checkSources If it should check if the sources are supported by the new node
      */
-    changeNode(newNode: LavalinkNode | string): Promise<string>;
+    changeNode(newNode: LavalinkNode | string, checkSources?: boolean): Promise<string>;
     /** Converts the Player including Queue to a Json state */
     toJSON(): PlayerJson;
 }

package/dist/cjs/structures/Player.js

@@ -459,11 +459,11 @@ class Player {
                 throw new RangeError("Can't skip more than the queue size");
             await this.queue.splice(0, skipTo - 1);
         }
-        if (!this.playing)
+        if (!this.playing && !this.queue.current)
             return (this.play(), this);
         const now = performance.now();
         this.set("internal_skipped", true);
-        await this.node.updatePlayer({ guildId: this.guildId, playerOptions: { track: { encoded: null } } });
+        await this.node.updatePlayer({ guildId: this.guildId, playerOptions: { track: { encoded: null }, paused: false } });
         this.ping.lavalink = Math.round((performance.now() - now) / 10) / 100;
         return this;
     }
@@ -639,11 +639,37 @@ class Player {
     /**
      * Move the player on a different Audio-Node
      * @param newNode New Node / New Node Id
+     * @param checkSources If it should check if the sources are supported by the new node
      */
-    async changeNode(newNode) {
+    async changeNode(newNode, checkSources = true) {
         const updateNode = typeof newNode === "string" ? this.LavalinkManager.nodeManager.nodes.get(newNode) : newNode;
         if (!updateNode)
             throw new Error("Could not find the new Node");
+        if (!updateNode.connected)
+            throw new Error("The provided Node is not active or disconnected");
+        if (this.node.id === updateNode.id)
+            throw new Error("Player is already on the provided Node");
+        if (this.get("internal_nodeChanging") === true)
+            throw new Error("Player is already changing the node please wait");
+        if (checkSources) {
+            const isDefaultSource = () => {
+                try {
+                    this.LavalinkManager.utils.validateSourceString(updateNode, this.LavalinkManager.options.playerOptions.defaultSearchPlatform);
+                    return true;
+                }
+                catch {
+                    return false;
+                }
+            };
+            if (!isDefaultSource())
+                throw new RangeError(`defaultSearchPlatform "${this.LavalinkManager.options.playerOptions.defaultSearchPlatform}" is not supported by the newNode`);
+            if (this.queue.current || this.queue.tracks.length) { // Check if all queued track sources are supported by the new node
+                const trackSources = new Set([this.queue.current, ...this.queue.tracks].map(track => track.info.sourceName));
+                const missingSources = [...trackSources].filter(source => !updateNode.info.sourceManagers.includes(source));
+                if (missingSources.length)
+                    throw new RangeError(`Sources missing for Node ${updateNode.id}: ${missingSources.join(', ')}`);
+            }
+        }
         if (this.LavalinkManager.options?.advancedOptions?.enableDebugEvents) {
             this.LavalinkManager.emit("debug", Constants_1.DebugEvents.PlayerChangeNode, {
                 state: "log",
@@ -653,23 +679,60 @@ class Player {
         }
         const data = this.toJSON();
         const currentTrack = this.queue.current;
-        await this.node.destroyPlayer(this.guildId);
+        const voiceData = this.voice;
+        if (!voiceData.endpoint ||
+            !voiceData.sessionId ||
+            !voiceData.token)
+            throw new Error("Voice Data is missing, can't change the node");
+        this.set("internal_nodeChanging", true); // This will stop execution of trackEnd or queueEnd event while changing the node
+        if (this.node.connected)
+            await this.node.destroyPlayer(this.guildId); // destroy the player on the currentNode if it's connected
         this.node = updateNode;
         const now = performance.now();
-        await this.connect();
-        await this.node.updatePlayer({
-            guildId: this.guildId,
-            noReplace: false,
-            playerOptions: {
-                position: data.position,
-                volume: Math.round(Math.max(Math.min(data.volume, 1000), 0)),
-                paused: data.paused,
-                filters: { ...data.filters, equalizer: data.equalizer },
-                track: currentTrack ?? undefined
-            },
-        });
-        this.ping.lavalink = Math.round((performance.now() - now) / 10) / 100;
-        return this.node.id;
+        try {
+            await this.connect();
+            const endpoint = `/sessions/${this.node.sessionId}/players/${this.guildId}`; //Send the VoiceData to the newly connected node.
+            await this.node.request(endpoint, r => {
+                r.method = "PATCH";
+                r.headers["Content-Type"] = "application/json";
+                r.body = JSON.stringify({
+                    voice: {
+                        token: voiceData.token,
+                        endpoint: voiceData.endpoint,
+                        sessionId: voiceData.sessionId
+                    }
+                });
+            });
+            if (currentTrack) { // If there is a current track, send it to the new node.
+                await this.node.updatePlayer({
+                    guildId: this.guildId,
+                    noReplace: false,
+                    playerOptions: {
+                        track: currentTrack ?? null,
+                        position: currentTrack ? data.position : 0,
+                        volume: data.lavalinkVolume,
+                        paused: data.paused,
+                        //filters: { ...data.filters, equalizer: data.equalizer }, Sending filters on nodeChange causes issues (player gets dicsonnected)
+                    }
+                });
+            }
+            this.ping.lavalink = Math.round((performance.now() - now) / 10) / 100;
+            return this.node.id;
+        }
+        catch (error) {
+            if (this.LavalinkManager.options?.advancedOptions?.enableDebugEvents) {
+                this.LavalinkManager.emit("debug", Constants_1.DebugEvents.PlayerChangeNode, {
+                    state: "error",
+                    error: error,
+                    message: `Player.changeNode() execution failed`,
+                    functionLayer: "Player > changeNode()",
+                });
+            }
+            throw new Error(`Failed to change the node: ${error}`);
+        }
+        finally {
+            this.set("internal_nodeChanging", undefined);
+        }
     }
     /** Converts the Player including Queue to a Json state */
     toJSON() {

package/dist/esm/structures/Constants.d.ts

@@ -49,6 +49,8 @@ export declare enum DestroyReasons {
     NodeReconnectFail = "NodeReconnectFail",
     Disconnected = "Disconnected",
     PlayerReconnectFail = "PlayerReconnectFail",
+    PlayerChangeNodeFail = "PlayerChangeNodeFail",
+    PlayerChangeNodeFailNoEligibleNode = "PlayerChangeNodeFailNoEligibleNode",
     ChannelDeleted = "ChannelDeleted",
     DisconnectAllNodes = "DisconnectAllNodes",
     ReconnectAllNodes = "ReconnectAllNodes",

package/dist/esm/structures/Constants.js

@@ -50,6 +50,8 @@ export var DestroyReasons;
     DestroyReasons["NodeReconnectFail"] = "NodeReconnectFail";
     DestroyReasons["Disconnected"] = "Disconnected";
     DestroyReasons["PlayerReconnectFail"] = "PlayerReconnectFail";
+    DestroyReasons["PlayerChangeNodeFail"] = "PlayerChangeNodeFail";
+    DestroyReasons["PlayerChangeNodeFailNoEligibleNode"] = "PlayerChangeNodeFailNoEligibleNode";
     DestroyReasons["ChannelDeleted"] = "ChannelDeleted";
     DestroyReasons["DisconnectAllNodes"] = "DisconnectAllNodes";
     DestroyReasons["ReconnectAllNodes"] = "ReconnectAllNodes";

package/dist/esm/structures/Node.d.ts

@@ -173,14 +173,20 @@ export declare class LavalinkNode {
      * Destroys the Node-Connection (Websocket) and all player's of the node
      * @param destroyReason Destroy Reason to use when destroying the players
      * @param deleteNode wether to delete the nodte from the nodes list too, if false it will emit a disconnect. @default true
+     * @param movePlayers whether to movePlayers to different eligible connected node. If false players won't be moved @default false
      * @returns void
      *
      * @example
+     * Destroys node and its players
      * ```ts
      * player.node.destroy("custom Player Destroy Reason", true);
      * ```
+     * destroys only the node and moves its players to different connected node.
+     * ```ts
+     * player.node.destroy("custom Player Destroy Reason", true, true);
+     * ```
      */
-    destroy(destroyReason?: DestroyReasonsType, deleteNode?: boolean): void;
+    destroy(destroyReason?: DestroyReasonsType, deleteNode?: boolean, movePlayers?: boolean): void;
     /**
      * Disconnects the Node-Connection (Websocket)
      * @param disconnectReason Disconnect Reason to use when disconnecting Node

package/dist/esm/structures/Node.js

@@ -408,32 +408,94 @@ export class LavalinkNode {
      * Destroys the Node-Connection (Websocket) and all player's of the node
      * @param destroyReason Destroy Reason to use when destroying the players
      * @param deleteNode wether to delete the nodte from the nodes list too, if false it will emit a disconnect. @default true
+     * @param movePlayers whether to movePlayers to different eligible connected node. If false players won't be moved @default false
      * @returns void
      *
      * @example
+     * Destroys node and its players
      * ```ts
      * player.node.destroy("custom Player Destroy Reason", true);
      * ```
+     * destroys only the node and moves its players to different connected node.
+     * ```ts
+     * player.node.destroy("custom Player Destroy Reason", true, true);
+     * ```
      */
-    destroy(destroyReason, deleteNode = true) {
+    destroy(destroyReason, deleteNode = true, movePlayers = false) {
         if (!this.connected)
             return;
         const players = this.NodeManager.LavalinkManager.players.filter(p => p.node.id === this.id);
-        if (players)
-            players.forEach(p => {
-                p.destroy(destroyReason || DestroyReasons.NodeDestroy);
+        if (players.size) {
+            const enableDebugEvents = this.NodeManager.LavalinkManager.options?.advancedOptions?.enableDebugEvents;
+            const handlePlayerOperations = () => {
+                if (movePlayers) {
+                    const nodeToMove = Array.from(this.NodeManager.leastUsedNodes("playingPlayers"))
+                        .find(n => n.connected && n.options.id !== this.id);
+                    if (nodeToMove) {
+                        return Promise.allSettled(Array.from(players.values()).map(player => player.changeNode(nodeToMove.options.id)
+                            .catch(error => {
+                            if (enableDebugEvents) {
+                                console.error(`Node > destroy() Failed to move player ${player.guildId}: ${error.message}`);
+                            }
+                            return player.destroy(error.message ?? DestroyReasons.PlayerChangeNodeFail)
+                                .catch(destroyError => {
+                                if (enableDebugEvents) {
+                                    console.error(`Node > destroy() Failed to destroy player ${player.guildId} after move failure: ${destroyError.message}`);
+                                }
+                            });
+                        })));
+                    }
+                    else {
+                        return Promise.allSettled(Array.from(players.values()).map(player => player.destroy(DestroyReasons.PlayerChangeNodeFailNoEligibleNode)
+                            .catch(error => {
+                            if (enableDebugEvents) {
+                                console.error(`Node > destroy() Failed to destroy player ${player.guildId}: ${error.message}`);
+                            }
+                        })));
+                    }
+                }
+                else {
+                    return Promise.allSettled(Array.from(players.values()).map(player => player.destroy(destroyReason || DestroyReasons.NodeDestroy)
+                        .catch(error => {
+                        if (enableDebugEvents) {
+                            console.error(`Node > destroy() Failed to destroy player ${player.guildId}: ${error.message}`);
+                        }
+                    })));
+                }
+            };
+            // Handle all player operations first, then clean up the socket
+            handlePlayerOperations().finally(() => {
+                this.socket.close(1000, "Node-Destroy");
+                this.socket.removeAllListeners();
+                this.socket = null;
+                this.reconnectAttempts = 1;
+                clearTimeout(this.reconnectTimeout);
+                if (deleteNode) {
+                    this.NodeManager.emit("destroy", this, destroyReason);
+                    this.NodeManager.nodes.delete(this.id);
+                    clearInterval(this.heartBeatInterval);
+                    clearTimeout(this.pingTimeout);
+                }
+                else {
+                    this.NodeManager.emit("disconnect", this, { code: 1000, reason: destroyReason });
+                }
             });
-        this.socket.close(1000, "Node-Destroy");
-        this.socket.removeAllListeners();
-        this.socket = null;
-        this.reconnectAttempts = 1;
-        clearTimeout(this.reconnectTimeout);
-        if (deleteNode) {
-            this.NodeManager.emit("destroy", this, destroyReason);
-            this.NodeManager.nodes.delete(this.id);
         }
-        else {
-            this.NodeManager.emit("disconnect", this, { code: 1000, reason: destroyReason });
+        else { // If no players, proceed with socket cleanup immediately
+            this.socket.close(1000, "Node-Destroy");
+            this.socket.removeAllListeners();
+            this.socket = null;
+            this.reconnectAttempts = 1;
+            clearTimeout(this.reconnectTimeout);
+            if (deleteNode) {
+                this.NodeManager.emit("destroy", this, destroyReason);
+                this.NodeManager.nodes.delete(this.id);
+                clearInterval(this.heartBeatInterval);
+                clearTimeout(this.pingTimeout);
+            }
+            else {
+                this.NodeManager.emit("disconnect", this, { code: 1000, reason: destroyReason });
+            }
         }
         return;
     }
@@ -962,8 +1024,11 @@ export class LavalinkNode {
         if (code === 1000 && reason === "Node-Disconnect")
             return; // manually disconnected and already emitted the event.
         this.NodeManager.emit("disconnect", this, { code, reason });
-        if (code !== 1000 || reason !== "Node-Destroy")
-            this.reconnect();
+        if (code !== 1000 || reason !== "Node-Destroy") {
+            if (this.NodeManager.nodes.has(this.id)) { // try to reconnect only when the node is still in the nodeManager.nodes list
+                this.reconnect();
+            }
+        }
     }
     /** @private util function for handling error events from websocket */
     error(error) {
@@ -1155,6 +1220,8 @@ export class LavalinkNode {
     }
     /** @private util function for handling trackEnd event */
     async trackEnd(player, track, payload) {
+        if (player.get('internal_nodeChanging') === true)
+            return; // Check if nodeChange is in Progress than stop the trackEnd Event from being triggered.
         const trackToUse = track || this.getTrackOfPayload(payload);
         // If a track was forcibly played
         if (payload.reason === "replaced") {
@@ -1370,6 +1437,8 @@ export class LavalinkNode {
     }
     /** private util function for handling the queue end event */
     async queueEnd(player, track, payload) {
+        if (player.get('internal_nodeChanging') === true)
+            return; // Check if nodeChange is in Progress than stop the queueEnd Event from being triggered.
         // add previous track to the queue!
         player.queue.current = null;
         player.playing = false;

package/dist/esm/structures/NodeManager.d.ts

@@ -83,7 +83,18 @@ export declare class NodeManager extends EventEmitter {
     /**
      * Delete a node from the nodeManager and destroy it
      * @param node The node to delete
+     * @param movePlayers whether to movePlayers to different connected node before deletion. @default false
      * @returns
+     *
+     * @example
+     * Deletes the node
+     * ```ts
+     * client.lavalink.nodeManager.deleteNode("nodeId to delete");
+     * ```
+     * Moves players to a different node before deleting
+     * ```ts
+     * client.lavalink.nodeManager.deleteNode("nodeId to delete", true);
+     * ```
      */
-    deleteNode(node: LavalinkNodeIdentifier | LavalinkNode): void;
+    deleteNode(node: LavalinkNodeIdentifier | LavalinkNode, movePlayers?: boolean): void;
 }

package/dist/esm/structures/NodeManager.js

@@ -193,13 +193,27 @@ export class NodeManager extends EventEmitter {
     /**
      * Delete a node from the nodeManager and destroy it
      * @param node The node to delete
+     * @param movePlayers whether to movePlayers to different connected node before deletion. @default false
      * @returns
+     *
+     * @example
+     * Deletes the node
+     * ```ts
+     * client.lavalink.nodeManager.deleteNode("nodeId to delete");
+     * ```
+     * Moves players to a different node before deleting
+     * ```ts
+     * client.lavalink.nodeManager.deleteNode("nodeId to delete", true);
+     * ```
      */
-    deleteNode(node) {
+    deleteNode(node, movePlayers = false) {
         const decodeNode = typeof node === "string" ? this.nodes.get(node) : node || this.leastUsedNodes()[0];
         if (!decodeNode)
             throw new Error("Node was not found");
-        decodeNode.destroy(DestroyReasons.NodeDeleted);
+        if (movePlayers)
+            decodeNode.destroy(DestroyReasons.NodeDeleted, true, true);
+        else
+            decodeNode.destroy(DestroyReasons.NodeDeleted);
         this.nodes.delete(decodeNode.id);
         return;
     }

package/dist/esm/structures/Player.d.ts

@@ -217,8 +217,9 @@ export declare class Player {
     /**
      * Move the player on a different Audio-Node
      * @param newNode New Node / New Node Id
+     * @param checkSources If it should check if the sources are supported by the new node
      */
-    changeNode(newNode: LavalinkNode | string): Promise<string>;
+    changeNode(newNode: LavalinkNode | string, checkSources?: boolean): Promise<string>;
     /** Converts the Player including Queue to a Json state */
     toJSON(): PlayerJson;
 }

package/dist/esm/structures/Player.js

@@ -456,11 +456,11 @@ export class Player {
                 throw new RangeError("Can't skip more than the queue size");
             await this.queue.splice(0, skipTo - 1);
         }
-        if (!this.playing)
+        if (!this.playing && !this.queue.current)
             return (this.play(), this);
         const now = performance.now();
         this.set("internal_skipped", true);
-        await this.node.updatePlayer({ guildId: this.guildId, playerOptions: { track: { encoded: null } } });
+        await this.node.updatePlayer({ guildId: this.guildId, playerOptions: { track: { encoded: null }, paused: false } });
         this.ping.lavalink = Math.round((performance.now() - now) / 10) / 100;
         return this;
     }
@@ -636,11 +636,37 @@ export class Player {
     /**
      * Move the player on a different Audio-Node
      * @param newNode New Node / New Node Id
+     * @param checkSources If it should check if the sources are supported by the new node
      */
-    async changeNode(newNode) {
+    async changeNode(newNode, checkSources = true) {
         const updateNode = typeof newNode === "string" ? this.LavalinkManager.nodeManager.nodes.get(newNode) : newNode;
         if (!updateNode)
             throw new Error("Could not find the new Node");
+        if (!updateNode.connected)
+            throw new Error("The provided Node is not active or disconnected");
+        if (this.node.id === updateNode.id)
+            throw new Error("Player is already on the provided Node");
+        if (this.get("internal_nodeChanging") === true)
+            throw new Error("Player is already changing the node please wait");
+        if (checkSources) {
+            const isDefaultSource = () => {
+                try {
+                    this.LavalinkManager.utils.validateSourceString(updateNode, this.LavalinkManager.options.playerOptions.defaultSearchPlatform);
+                    return true;
+                }
+                catch {
+                    return false;
+                }
+            };
+            if (!isDefaultSource())
+                throw new RangeError(`defaultSearchPlatform "${this.LavalinkManager.options.playerOptions.defaultSearchPlatform}" is not supported by the newNode`);
+            if (this.queue.current || this.queue.tracks.length) { // Check if all queued track sources are supported by the new node
+                const trackSources = new Set([this.queue.current, ...this.queue.tracks].map(track => track.info.sourceName));
+                const missingSources = [...trackSources].filter(source => !updateNode.info.sourceManagers.includes(source));
+                if (missingSources.length)
+                    throw new RangeError(`Sources missing for Node ${updateNode.id}: ${missingSources.join(', ')}`);
+            }
+        }
         if (this.LavalinkManager.options?.advancedOptions?.enableDebugEvents) {
             this.LavalinkManager.emit("debug", DebugEvents.PlayerChangeNode, {
                 state: "log",
@@ -650,23 +676,60 @@ export class Player {
         }
         const data = this.toJSON();
         const currentTrack = this.queue.current;
-        await this.node.destroyPlayer(this.guildId);
+        const voiceData = this.voice;
+        if (!voiceData.endpoint ||
+            !voiceData.sessionId ||
+            !voiceData.token)
+            throw new Error("Voice Data is missing, can't change the node");
+        this.set("internal_nodeChanging", true); // This will stop execution of trackEnd or queueEnd event while changing the node
+        if (this.node.connected)
+            await this.node.destroyPlayer(this.guildId); // destroy the player on the currentNode if it's connected
         this.node = updateNode;
         const now = performance.now();
-        await this.connect();
-        await this.node.updatePlayer({
-            guildId: this.guildId,
-            noReplace: false,
-            playerOptions: {
-                position: data.position,
-                volume: Math.round(Math.max(Math.min(data.volume, 1000), 0)),
-                paused: data.paused,
-                filters: { ...data.filters, equalizer: data.equalizer },
-                track: currentTrack ?? undefined
-            },
-        });
-        this.ping.lavalink = Math.round((performance.now() - now) / 10) / 100;
-        return this.node.id;
+        try {
+            await this.connect();
+            const endpoint = `/sessions/${this.node.sessionId}/players/${this.guildId}`; //Send the VoiceData to the newly connected node.
+            await this.node.request(endpoint, r => {
+                r.method = "PATCH";
+                r.headers["Content-Type"] = "application/json";
+                r.body = JSON.stringify({
+                    voice: {
+                        token: voiceData.token,
+                        endpoint: voiceData.endpoint,
+                        sessionId: voiceData.sessionId
+                    }
+                });
+            });
+            if (currentTrack) { // If there is a current track, send it to the new node.
+                await this.node.updatePlayer({
+                    guildId: this.guildId,
+                    noReplace: false,
+                    playerOptions: {
+                        track: currentTrack ?? null,
+                        position: currentTrack ? data.position : 0,
+                        volume: data.lavalinkVolume,
+                        paused: data.paused,
+                        //filters: { ...data.filters, equalizer: data.equalizer }, Sending filters on nodeChange causes issues (player gets dicsonnected)
+                    }
+                });
+            }
+            this.ping.lavalink = Math.round((performance.now() - now) / 10) / 100;
+            return this.node.id;
+        }
+        catch (error) {
+            if (this.LavalinkManager.options?.advancedOptions?.enableDebugEvents) {
+                this.LavalinkManager.emit("debug", DebugEvents.PlayerChangeNode, {
+                    state: "error",
+                    error: error,
+                    message: `Player.changeNode() execution failed`,
+                    functionLayer: "Player > changeNode()",
+                });
+            }
+            throw new Error(`Failed to change the node: ${error}`);
+        }
+        finally {
+            this.set("internal_nodeChanging", undefined);
+        }
     }
     /** Converts the Player including Queue to a Json state */
     toJSON() {

package/dist/types/structures/Constants.d.ts

@@ -49,6 +49,8 @@ export declare enum DestroyReasons {
     NodeReconnectFail = "NodeReconnectFail",
     Disconnected = "Disconnected",
     PlayerReconnectFail = "PlayerReconnectFail",
+    PlayerChangeNodeFail = "PlayerChangeNodeFail",
+    PlayerChangeNodeFailNoEligibleNode = "PlayerChangeNodeFailNoEligibleNode",
     ChannelDeleted = "ChannelDeleted",
     DisconnectAllNodes = "DisconnectAllNodes",
     ReconnectAllNodes = "ReconnectAllNodes",

package/dist/types/structures/Node.d.ts

@@ -173,14 +173,20 @@ export declare class LavalinkNode {
      * Destroys the Node-Connection (Websocket) and all player's of the node
      * @param destroyReason Destroy Reason to use when destroying the players
      * @param deleteNode wether to delete the nodte from the nodes list too, if false it will emit a disconnect. @default true
+     * @param movePlayers whether to movePlayers to different eligible connected node. If false players won't be moved @default false
      * @returns void
      *
      * @example
+     * Destroys node and its players
      * ```ts
      * player.node.destroy("custom Player Destroy Reason", true);
      * ```
+     * destroys only the node and moves its players to different connected node.
+     * ```ts
+     * player.node.destroy("custom Player Destroy Reason", true, true);
+     * ```
      */
-    destroy(destroyReason?: DestroyReasonsType, deleteNode?: boolean): void;
+    destroy(destroyReason?: DestroyReasonsType, deleteNode?: boolean, movePlayers?: boolean): void;
     /**
      * Disconnects the Node-Connection (Websocket)
      * @param disconnectReason Disconnect Reason to use when disconnecting Node

package/dist/types/structures/NodeManager.d.ts

@@ -83,7 +83,18 @@ export declare class NodeManager extends EventEmitter {
     /**
      * Delete a node from the nodeManager and destroy it
      * @param node The node to delete
+     * @param movePlayers whether to movePlayers to different connected node before deletion. @default false
      * @returns
+     *
+     * @example
+     * Deletes the node
+     * ```ts
+     * client.lavalink.nodeManager.deleteNode("nodeId to delete");
+     * ```
+     * Moves players to a different node before deleting
+     * ```ts
+     * client.lavalink.nodeManager.deleteNode("nodeId to delete", true);
+     * ```
      */
-    deleteNode(node: LavalinkNodeIdentifier | LavalinkNode): void;
+    deleteNode(node: LavalinkNodeIdentifier | LavalinkNode, movePlayers?: boolean): void;
 }

package/dist/types/structures/Player.d.ts

@@ -217,8 +217,9 @@ export declare class Player {
     /**
      * Move the player on a different Audio-Node
      * @param newNode New Node / New Node Id
+     * @param checkSources If it should check if the sources are supported by the new node
      */
-    changeNode(newNode: LavalinkNode | string): Promise<string>;
+    changeNode(newNode: LavalinkNode | string, checkSources?: boolean): Promise<string>;
     /** Converts the Player including Queue to a Json state */
     toJSON(): PlayerJson;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lavalink-client",
-  "version": "2.4.4",
+  "version": "2.4.6",
   "description": "Easy, flexible and feature-rich lavalink@v4 Client. Both for Beginners and Proficients.",
   "main": "dist/cjs/index.js",
   "module": "dist/esm/index.js",
@@ -58,22 +58,22 @@
   },
   "homepage": "https://tomato6966.github.io/lavalink-client/",
   "devDependencies": {
-    "@eslint/eslintrc": "^3.1.0",
-    "@eslint/js": "^9.11.0",
-    "@types/node": "^22.5.5",
-    "@types/ws": "^8.5.12",
-    "@typescript-eslint/eslint-plugin": "^8.6.0",
-    "@typescript-eslint/parser": "^8.6.0",
-    "eslint": "^9.11.0",
+    "@eslint/eslintrc": "^3.2.0",
+    "@eslint/js": "^9.18.0",
+    "@types/node": "^22.10.5",
+    "@types/ws": "^8.5.13",
+    "@typescript-eslint/eslint-plugin": "^8.20.0",
+    "@typescript-eslint/parser": "^8.20.0",
+    "eslint": "^9.18.0",
     "tsc-alias": "^1.8.10",
-    "typescript": "^5.6.2"
+    "typescript": "^5.7.3"
   },
   "dependencies": {
-    "tslib": "^2.7.0",
+    "tslib": "^2.8.1",
     "ws": "^8.18.0"
   },
   "engines": {
     "node": ">=18.0.0",
-    "bun": ">=1.0.0"
+    "bun": ">=1.1.27"
   }
 }