lavalink-client 2.3.1 → 2.3.4

package/dist/esm/structures/Node.js

@@ -1,6 +1,6 @@
 import { isAbsolute } from "path";
 import WebSocket from "ws";
-import { DestroyReasons, validSponsorBlocks } from "./Constants";
+import { DebugEvents, DestroyReasons, validSponsorBlocks } from "./Constants";
 import { NodeSymbol, queueTrackEnd } from "./Utils";
 /**
  * Lavalink Node creator class
@@ -188,7 +188,8 @@ export class LavalinkNode {
         }
         let uri = `/loadtracks?identifier=`;
         if (/^https?:\/\//.test(Query.query) || ["http", "https", "link", "uri"].includes(Query.source)) { // if it's a link simply encode it
-            uri += encodeURIComponent(Query.query);
+            const url = encodeURIComponent(Query.query);
+            uri += url;
         }
         else { // if not make a query out of it
             if (Query.source !== "local")
@@ -205,8 +206,16 @@ export class LavalinkNode {
         });
         // transform the data which can be Error, Track or Track[] to enfore [Track]
         const resTracks = res.loadType === "playlist" ? res.data?.tracks : res.loadType === "track" ? [res.data] : res.loadType === "search" ? Array.isArray(res.data) ? res.data : [res.data] : [];
-        if (throwOnEmpty === true && (res.loadType === "empty" || !resTracks.length))
+        if (throwOnEmpty === true && (res.loadType === "empty" || !resTracks.length)) {
+            if (this.NodeManager.LavalinkManager.options?.advancedOptions?.enableDebugEvents) {
+                this.NodeManager.LavalinkManager.emit("debug", DebugEvents.SearchNothingFound, {
+                    state: "warn",
+                    message: `Search found nothing for Request: "${Query.source ? `${Query.source}:` : ""}${Query.query}"`,
+                    functionLayer: "(LavalinkNode > node | player) > search()",
+                });
+            }
             throw new Error("Nothing found");
+        }
         return {
             loadType: res.loadType,
             exception: res.loadType === "error" ? res.data : null,
@@ -250,8 +259,16 @@ export class LavalinkNode {
             throw new RangeError(`there is no lavasrc-plugin available in the lavalink node: ${this.id}`);
         const { request } = await this.rawRequest(`/loadsearch?query=${Query.source ? `${Query.source}:` : ""}${encodeURIComponent(Query.query)}${Query.types?.length ? `&types=${Query.types.join(",")}` : ""}`);
         const res = (request.status === 204 ? {} : await request.json());
-        if (throwOnEmpty === true && !Object.entries(res).flat().filter(Boolean).length)
+        if (throwOnEmpty === true && !Object.entries(res).flat().filter(Boolean).length) {
+            if (this.NodeManager.LavalinkManager.options?.advancedOptions?.enableDebugEvents) {
+                this.NodeManager.LavalinkManager.emit("debug", DebugEvents.LavaSearchNothingFound, {
+                    state: "warn",
+                    message: `LavaSearch found nothing for Request: "${Query.source ? `${Query.source}:` : ""}${Query.query}"`,
+                    functionLayer: "(LavalinkNode > node | player) > lavaSearch()",
+                });
+            }
             throw new Error("Nothing found");
+        }
         return {
             tracks: res.tracks?.map(v => this.NodeManager.LavalinkManager.utils.buildTrack(v, requestUser)) || [],
             albums: res.albums?.map(v => ({ info: v.info, pluginInfo: v?.plugin || v.pluginInfo, tracks: v.tracks.map(v => this.NodeManager.LavalinkManager.utils.buildTrack(v, requestUser)) })) || [],
@@ -287,6 +304,13 @@ export class LavalinkNode {
                 r.path = url.pathname + url.search;
             }
         });
+        if (this.NodeManager.LavalinkManager.options?.advancedOptions?.enableDebugEvents) {
+            this.NodeManager.LavalinkManager.emit("debug", DebugEvents.PlayerUpdateSuccess, {
+                state: "log",
+                message: `Player get's updated with following payload :: ${JSON.stringify(data.playerOptions, null, 3)}`,
+                functionLayer: "LavalinkNode > node > updatePlayer()",
+            });
+        }
         return this.syncPlayerData({}, res), res;
     }
     /**
@@ -319,8 +343,16 @@ export class LavalinkNode {
      * ```
      */
     connect(sessionId) {
-        if (this.connected)
+        if (this.connected) {
+            if (this.NodeManager.LavalinkManager.options?.advancedOptions?.enableDebugEvents) {
+                this.NodeManager.LavalinkManager.emit("debug", DebugEvents.TryingConnectWhileConnected, {
+                    state: "warn",
+                    message: `Tryed to connect to node, but it's already connected!`,
+                    functionLayer: "LavalinkNode > node > connect()",
+                });
+            }
             return;
+        }
         const headers = {
             Authorization: this.options.authorization,
             "User-Id": this.NodeManager.LavalinkManager.options.client.id,
@@ -338,11 +370,33 @@ export class LavalinkNode {
         // this.socket.on("ping", () => this.heartBeat("ping")); // lavalink doesn'T send ping periodically, therefore we use the stats message
     }
     heartBeat() {
+        if (this.NodeManager.LavalinkManager.options?.advancedOptions?.enableDebugEvents) {
+            this.NodeManager.LavalinkManager.emit("debug", DebugEvents.HeartBeatTriggered, {
+                state: "log",
+                message: `Node Socket Heartbeat triggered, resetting old Timeout to 65000ms (should happen every 60s due to /stats event)`,
+                functionLayer: "LavalinkNode > nodeEvent > stats > heartBeat()",
+            });
+        }
         if (this.pingTimeout)
             clearTimeout(this.pingTimeout);
         this.pingTimeout = setTimeout(() => {
-            if (!this.socket)
-                return console.error("Node-Ping-Acknowledge-Timeout - Socket not available - maybe reconnecting?");
+            if (!this.socket) {
+                if (this.NodeManager.LavalinkManager.options?.advancedOptions?.enableDebugEvents) {
+                    this.NodeManager.LavalinkManager.emit("debug", DebugEvents.NoSocketOnDestroy, {
+                        state: "error",
+                        message: `Heartbeat registered a disconnect, but socket didn't exist therefore can't terminate`,
+                        functionLayer: "LavalinkNode > nodeEvent > stats > heartBeat() > timeoutHit",
+                    });
+                }
+                return;
+            }
+            if (this.NodeManager.LavalinkManager.options?.advancedOptions?.enableDebugEvents) {
+                this.NodeManager.LavalinkManager.emit("debug", DebugEvents.SocketTerminateHeartBeatTimeout, {
+                    state: "warn",
+                    message: `Heartbeat registered a disconnect, because timeout wasn't resetted in time. Terminating Web-Socket`,
+                    functionLayer: "LavalinkNode > nodeEvent > stats > heartBeat() > timeoutHit",
+                });
+            }
             this.isAlive = false;
             this.socket.terminate();
         }, 65000); // the stats endpoint get's sent every 60s. se wee add a 5s buffer to make sure we don't miss any stats message
@@ -834,8 +888,16 @@ export class LavalinkNode {
             case "playerUpdate":
                 {
                     const player = this.NodeManager.LavalinkManager.getPlayer(payload.guildId);
-                    if (!player)
+                    if (!player) {
+                        if (this.NodeManager.LavalinkManager.options?.advancedOptions?.enableDebugEvents) {
+                            this.NodeManager.LavalinkManager.emit("debug", DebugEvents.PlayerUpdateNoPlayer, {
+                                state: "error",
+                                message: `PlayerUpdate Event Triggered, but no player found of payload.guildId: ${payload.guildId}`,
+                                functionLayer: "LavalinkNode > nodeEvent > playerUpdate",
+                            });
+                        }
                         return;
+                    }
                     const oldPlayer = player?.toJSON();
                     player.lastPositionChange = Date.now();
                     player.lastPosition = payload.state.position || 0;
@@ -845,6 +907,13 @@ export class LavalinkNode {
                         player.createdTimeStamp = payload.state.time;
                     if (player.filterManager.filterUpdatedState === true && ((player.queue.current?.info?.duration || 0) <= (player.LavalinkManager.options.advancedOptions.maxFilterFixDuration || 600000) || isAbsolute(player.queue.current?.info?.uri))) {
                         player.filterManager.filterUpdatedState = false;
+                        if (this.NodeManager.LavalinkManager.options?.advancedOptions?.enableDebugEvents) {
+                            this.NodeManager.LavalinkManager.emit("debug", DebugEvents.PlayerUpdateFilterFixApply, {
+                                state: "log",
+                                message: `Fixing FilterState on "${player.guildId}" because player.options.instaUpdateFiltersFix === true`,
+                                functionLayer: "LavalinkNode > nodeEvent > playerUpdate",
+                            });
+                        }
                         await player.seek(player.position);
                     }
                     this.NodeManager.LavalinkManager.emit("playerUpdate", oldPlayer, player);
@@ -861,7 +930,14 @@ export class LavalinkNode {
                         this.NodeManager.emit("resumed", this, payload, await this.fetchAllPlayers());
                     }
                     catch (e) {
-                        console.error("Failed to fetch players for resumed event, falling back without players array", e);
+                        if (this.NodeManager.LavalinkManager.options?.advancedOptions?.enableDebugEvents) {
+                            this.NodeManager.LavalinkManager.emit("debug", DebugEvents.ResumingFetchingError, {
+                                state: "error",
+                                message: `Failed to fetch players for resumed event, falling back without players array`,
+                                error: e,
+                                functionLayer: "LavalinkNode > nodeEvent > resumed",
+                            });
+                        }
                         this.NodeManager.emit("resumed", this, payload, []);
                     }
                 }
@@ -922,12 +998,30 @@ export class LavalinkNode {
         player.playing = true;
         player.paused = false;
         // don't emit the event if previous track == new track aka track loop
-        if (this.NodeManager.LavalinkManager.options?.emitNewSongsOnly === true && player.queue.previous[0]?.info?.identifier === track?.info?.identifier)
+        if (this.NodeManager.LavalinkManager.options?.emitNewSongsOnly === true && player.queue.previous[0]?.info?.identifier === track?.info?.identifier) {
+            if (this.NodeManager.LavalinkManager.options?.advancedOptions?.enableDebugEvents) {
+                this.NodeManager.LavalinkManager.emit("debug", DebugEvents.TrackStartNewSongsOnly, {
+                    state: "log",
+                    message: `TrackStart not Emitting, because playing the previous song again.`,
+                    functionLayer: "LavalinkNode > trackStart()",
+                });
+            }
             return;
+        }
         if (!player.queue.current) {
             player.queue.current = await this.getTrackOfPayload(payload);
-            if (player.queue.current)
+            if (player.queue.current) {
                 await player.queue.utils.save();
+            }
+            else {
+                if (this.NodeManager.LavalinkManager.options?.advancedOptions?.enableDebugEvents) {
+                    this.NodeManager.LavalinkManager.emit("debug", DebugEvents.TrackStartNoTrack, {
+                        state: "warn",
+                        message: `Trackstart emitted but there is no track on player.queue.current, trying to get the track of the payload failed too.`,
+                        functionLayer: "LavalinkNode > trackStart()",
+                    });
+                }
+            }
         }
         return this.NodeManager.LavalinkManager.emit("trackStart", player, player.queue.current, payload);
     }
@@ -936,6 +1030,13 @@ export class LavalinkNode {
         const trackToUse = track || await this.getTrackOfPayload(payload);
         // If a track was forcibly played
         if (payload.reason === "replaced") {
+            if (this.NodeManager.LavalinkManager.options?.advancedOptions?.enableDebugEvents) {
+                this.NodeManager.LavalinkManager.emit("debug", DebugEvents.TrackEndReplaced, {
+                    state: "warn",
+                    message: `TrackEnd Event does not handle any playback, because the track was replaced.`,
+                    functionLayer: "LavalinkNode > trackEnd()",
+                });
+            }
             return this.NodeManager.LavalinkManager.emit("trackEnd", player, trackToUse, payload);
         }
         // If there are no songs in the queue
@@ -961,10 +1062,10 @@ export class LavalinkNode {
                 player.queue.previous.splice(player.queue.options.maxPreviousTracks, player.queue.previous.length);
             await player.queue.utils.save();
         }
-        player.set("internal_skipped", false);
         // if no track available, end queue
         if (!player.queue.current)
             return this.queueEnd(player, trackToUse, payload);
+        player.set("internal_skipped", false);
         // fire event
         this.NodeManager.LavalinkManager.emit("trackEnd", player, trackToUse, payload);
         // play track if autoSkip is true
@@ -972,6 +1073,21 @@ export class LavalinkNode {
     }
     /** @private util function for handling trackStuck event */
     async trackStuck(player, track, payload) {
+        if (this.NodeManager.LavalinkManager.options.playerOptions.maxErrorsPerTime?.threshold > 0 && this.NodeManager.LavalinkManager.options.playerOptions.maxErrorsPerTime?.maxAmount >= 0) {
+            const oldTimestamps = (player.get("internal_erroredTracksTimestamps") || [])
+                .filter(v => Date.now() - v < this.NodeManager.LavalinkManager.options.playerOptions.maxErrorsPerTime?.threshold);
+            player.set("internal_erroredTracksTimestamps", [...oldTimestamps, Date.now()]);
+            if (oldTimestamps.length > this.NodeManager.LavalinkManager.options.playerOptions.maxErrorsPerTime?.maxAmount) {
+                if (this.NodeManager.LavalinkManager.options?.advancedOptions?.enableDebugEvents) {
+                    this.NodeManager.LavalinkManager.emit("debug", DebugEvents.TrackStuckMaxTracksErroredPerTime, {
+                        state: "log",
+                        message: `trackStuck Event was triggered too often within a given threshold (LavalinkManager.options.playerOptions.maxErrorsPerTime). Threshold: "${this.NodeManager.LavalinkManager.options.playerOptions.maxErrorsPerTime?.threshold}ms", maxAmount: "${this.NodeManager.LavalinkManager.options.playerOptions.maxErrorsPerTime?.maxAmount}"`,
+                        functionLayer: "LavalinkNode > trackStuck()",
+                    });
+                }
+                return player.destroy(DestroyReasons.TrackStuckMaxTracksErroredPerTime);
+            }
+        }
         this.NodeManager.LavalinkManager.emit("trackStuck", player, track || await this.getTrackOfPayload(payload), payload);
         // If there are no songs in the queue
         if (!player.queue.tracks.length && (player.repeatMode === "off" || player.get("internal_stopPlaying")))
@@ -979,13 +1095,29 @@ export class LavalinkNode {
         // remove the current track, and enqueue the next one
         await queueTrackEnd(player);
         // if no track available, end queue
-        if (!player.queue.current)
+        if (!player.queue.current) {
             return this.queueEnd(player, track || await this.getTrackOfPayload(payload), payload);
+        }
         // play track if autoSkip is true
         return (this.NodeManager.LavalinkManager.options.autoSkip && player.queue.current) && player.play({ noReplace: true });
     }
     /** @private util function for handling trackError event */
     async trackError(player, track, payload) {
+        if (this.NodeManager.LavalinkManager.options.playerOptions.maxErrorsPerTime?.threshold > 0 && this.NodeManager.LavalinkManager.options.playerOptions.maxErrorsPerTime?.maxAmount >= 0) {
+            const oldTimestamps = (player.get("internal_erroredTracksTimestamps") || [])
+                .filter(v => Date.now() - v < this.NodeManager.LavalinkManager.options.playerOptions.maxErrorsPerTime?.threshold);
+            player.set("internal_erroredTracksTimestamps", [...oldTimestamps, Date.now()]);
+            if (oldTimestamps.length > this.NodeManager.LavalinkManager.options.playerOptions.maxErrorsPerTime?.maxAmount) {
+                if (this.NodeManager.LavalinkManager.options?.advancedOptions?.enableDebugEvents) {
+                    this.NodeManager.LavalinkManager.emit("debug", DebugEvents.TrackErrorMaxTracksErroredPerTime, {
+                        state: "log",
+                        message: `TrackError Event was triggered too often within a given threshold (LavalinkManager.options.playerOptions.maxErrorsPerTime). Threshold: "${this.NodeManager.LavalinkManager.options.playerOptions.maxErrorsPerTime?.threshold}ms", maxAmount: "${this.NodeManager.LavalinkManager.options.playerOptions.maxErrorsPerTime?.maxAmount}"`,
+                        functionLayer: "LavalinkNode > trackError()",
+                    });
+                }
+                return player.destroy(DestroyReasons.TrackErrorMaxTracksErroredPerTime);
+            }
+        }
         this.NodeManager.LavalinkManager.emit("trackError", player, track || await this.getTrackOfPayload(payload), payload);
         return; // get's handled by trackEnd
         // If there are no songs in the queue
@@ -1069,6 +1201,13 @@ export class LavalinkNode {
             r.headers = { Authorization: this.options.authorization, 'Content-Type': 'application/json' };
             r.body = JSON.stringify(segments.map(v => v.toLowerCase()));
         });
+        if (this.NodeManager.LavalinkManager.options?.advancedOptions?.enableDebugEvents) {
+            this.NodeManager.LavalinkManager.emit("debug", DebugEvents.SetSponsorBlock, {
+                state: "log",
+                message: `SponsorBlock was set for Player: ${player.guildId} to: ${segments.map(v => `'${v.toLowerCase()}'`).join(", ")}`,
+                functionLayer: "LavalinkNode > setSponsorBlock()",
+            });
+        }
         return;
     }
     /**
@@ -1090,6 +1229,13 @@ export class LavalinkNode {
         await this.request(`/sessions/${this.sessionId}/players/${player.guildId}/sponsorblock/categories`, (r) => {
             r.method = "DELETE";
         });
+        if (this.NodeManager.LavalinkManager.options?.advancedOptions?.enableDebugEvents) {
+            this.NodeManager.LavalinkManager.emit("debug", DebugEvents.DeleteSponsorBlock, {
+                state: "log",
+                message: `SponsorBlock was deleted for Player: ${player.guildId}`,
+                functionLayer: "LavalinkNode > deleteSponsorBlock()",
+            });
+        }
         return;
     }
     /** private util function for handling the queue end event */
@@ -1098,17 +1244,46 @@ export class LavalinkNode {
         player.queue.current = null;
         player.playing = false;
         player.set("internal_stopPlaying", undefined);
+        if (this.NodeManager.LavalinkManager.options?.advancedOptions?.enableDebugEvents) {
+            this.NodeManager.LavalinkManager.emit("debug", DebugEvents.QueueEnded, {
+                state: "log",
+                message: `Queue Ended because no more Tracks were in the Queue, due to EventName: "${payload.type}"`,
+                functionLayer: "LavalinkNode > queueEnd()",
+            });
+        }
         if (typeof this.NodeManager.LavalinkManager.options?.playerOptions?.onEmptyQueue?.autoPlayFunction === "function" && typeof player.get("internal_autoplayStopPlaying") === "undefined") {
-            await this.NodeManager.LavalinkManager.options?.playerOptions?.onEmptyQueue?.autoPlayFunction(player, track);
-            if (player.queue.tracks.length > 0)
-                await queueTrackEnd(player);
-            if (player.queue.current) {
-                if (payload.type === "TrackEndEvent")
-                    this.NodeManager.LavalinkManager.emit("trackEnd", player, track, payload);
-                return player.play({ noReplace: true, paused: false });
+            const previousAutoplayTime = player.get("internal_previousautoplay");
+            const duration = previousAutoplayTime ? Date.now() - previousAutoplayTime : 0;
+            if ((duration && duration > this.NodeManager.LavalinkManager.options.playerOptions.minAutoPlayMs) || !!player.get("internal_skipped")) {
+                await this.NodeManager.LavalinkManager.options?.playerOptions?.onEmptyQueue?.autoPlayFunction(player, track);
+                player.set("internal_previousautoplay", Date.now());
+                if (player.queue.tracks.length > 0)
+                    await queueTrackEnd(player);
+                else if (this.NodeManager.LavalinkManager.options?.advancedOptions?.enableDebugEvents) {
+                    this.NodeManager.LavalinkManager.emit("debug", DebugEvents.AutoplayNoSongsAdded, {
+                        state: "warn",
+                        message: `Autoplay was triggered but no songs were added to the queue.`,
+                        functionLayer: "LavalinkNode > queueEnd() > autoplayFunction",
+                    });
+                }
+                if (player.queue.current) {
+                    if (payload.type === "TrackEndEvent")
+                        this.NodeManager.LavalinkManager.emit("trackEnd", player, track, payload);
+                    return player.play({ noReplace: true, paused: false });
+                }
+            }
+            else {
+                if (this.NodeManager.LavalinkManager.options?.advancedOptions?.enableDebugEvents) {
+                    this.NodeManager.LavalinkManager.emit("debug", DebugEvents.AutoplayThresholdSpamLimiter, {
+                        state: "warn",
+                        message: `Autoplay was triggered after the previousautoplay too early. Threshold is: ${this.NodeManager.LavalinkManager.options.playerOptions.minAutoPlayMs}ms and the Duration was ${duration}ms`,
+                        functionLayer: "LavalinkNode > queueEnd() > autoplayFunction",
+                    });
+                }
             }
         }
-        player.set("internal_autoplayStopPlaying", undefined);
+        player.set("internal_skipped", false);
+        player.set("internal_autoplayStopPlaying", Date.now());
         if (track && !track?.pluginInfo?.clientData?.previousTrack) { // If there was a current Track already and repeatmode === true, add it to the queue.
             player.queue.previous.unshift(track);
             if (player.queue.previous.length > player.queue.options.maxPreviousTracks)
@@ -1122,6 +1297,13 @@ export class LavalinkNode {
             if (this.NodeManager.LavalinkManager.options.playerOptions.onEmptyQueue?.destroyAfterMs === 0)
                 return player.destroy(DestroyReasons.QueueEmpty);
             else {
+                if (this.NodeManager.LavalinkManager.options?.advancedOptions?.enableDebugEvents) {
+                    this.NodeManager.LavalinkManager.emit("debug", DebugEvents.TriggerQueueEmptyInterval, {
+                        state: "log",
+                        message: `Trigger Queue Empty Interval was Triggered because playerOptions.onEmptyQueue.destroyAfterMs is set to ${this.NodeManager.LavalinkManager.options.playerOptions.onEmptyQueue?.destroyAfterMs}ms`,
+                        functionLayer: "LavalinkNode > queueEnd() > destroyAfterMs",
+                    });
+                }
                 if (player.get("internal_queueempty")) {
                     clearTimeout(player.get("internal_queueempty"));
                     player.set("internal_queueempty", undefined);

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

@@ -1,5 +1,5 @@
 /// <reference types="node" />
-import { EventEmitter } from "stream";
+import { EventEmitter } from "events";
 import { LavalinkNode } from "./Node";
 import { MiniMap } from "./Utils";
 import type { LavalinkNodeIdentifier, LavalinkNodeOptions, NodeManagerEvents } from "./Types/Node";

package/dist/esm/structures/NodeManager.js

@@ -1,4 +1,4 @@
-import { EventEmitter } from "stream";
+import { EventEmitter } from "events";
 import { DestroyReasons } from "./Constants";
 import { LavalinkNode } from "./Node";
 import { MiniMap } from "./Utils";

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

@@ -134,7 +134,6 @@ export declare class Player {
      * @param repeatMode
      */
     setRepeatMode(repeatMode: RepeatMode): Promise<this>;
-    1: any;
     /**
      * Skip the current song, or a specific amount of songs
      * @param amount provide the index of the next track to skip to

package/dist/esm/structures/Player.js

@@ -1,3 +1,4 @@
+import { DebugEvents } from "./Constants";
 import { bandCampSearch } from "./CustomSearches/BandCampSearch";
 import { FilterManager } from "./Filters";
 import { Queue, QueueSaver } from "./Queue";
@@ -69,8 +70,17 @@ export class Player {
         this.guildId = this.options.guildId;
         this.voiceChannelId = this.options.voiceChannelId;
         this.textChannelId = this.options.textChannelId || null;
-        this.node = typeof this.options.node === "string" ? this.LavalinkManager.nodeManager.nodes.get(this.options.node) : this.options.node;
+        this.node = typeof this.options.node === "string"
+            ? this.LavalinkManager.nodeManager.nodes.get(this.options.node)
+            : this.options.node;
         if (!this.node || typeof this.node.request !== "function") {
+            if (typeof this.options.node === "string" && this.LavalinkManager.options?.advancedOptions?.enableDebugEvents) {
+                this.LavalinkManager.emit("debug", DebugEvents.PlayerCreateNodeNotFound, {
+                    state: "warn",
+                    message: `Player was created with provided node Id: ${this.options.node}, but no node with that Id was found.`,
+                    functionLayer: "Player > constructor()",
+                });
+            }
             const least = this.LavalinkManager.nodeManager.leastUsedNodes();
             this.node = least.filter(v => options.vcRegion ? v.options?.regions?.includes(options.vcRegion) : true)[0] || least[0] || null;
         }
@@ -125,13 +135,43 @@ export class Player {
      */
     async play(options = {}) {
         if (this.get("internal_queueempty")) {
+            if (this.LavalinkManager.options?.advancedOptions?.enableDebugEvents) {
+                this.LavalinkManager.emit("debug", DebugEvents.PlayerPlayQueueEmptyTimeoutClear, {
+                    state: "log",
+                    message: `Player was called to play something, while there was a queueEmpty Timeout set, clearing the timeout.`,
+                    functionLayer: "Player > play()",
+                });
+            }
             clearTimeout(this.get("internal_queueempty"));
             this.set("internal_queueempty", undefined);
         }
         // if clientTrack provided, override options.track object
         if (options?.clientTrack && (this.LavalinkManager.utils.isTrack(options?.clientTrack) || this.LavalinkManager.utils.isUnresolvedTrack(options.clientTrack))) {
-            if (this.LavalinkManager.utils.isUnresolvedTrack(options.clientTrack))
-                await options.clientTrack.resolve(this);
+            if (this.LavalinkManager.utils.isUnresolvedTrack(options.clientTrack)) {
+                try {
+                    // resolve the unresolved track
+                    await options.clientTrack.resolve(this);
+                }
+                catch (error) {
+                    if (this.LavalinkManager.options?.advancedOptions?.enableDebugEvents) {
+                        this.LavalinkManager.emit("debug", DebugEvents.PlayerPlayUnresolvedTrackFailed, {
+                            state: "error",
+                            error: error,
+                            message: `Player Play was called with clientTrack, Song is unresolved, but couldn't resolve it`,
+                            functionLayer: "Player > play() > resolve currentTrack",
+                        });
+                    }
+                    this.LavalinkManager.emit("trackError", this, this.queue.current, error);
+                    if (options && "clientTrack" in options)
+                        delete options.clientTrack;
+                    if (options && "track" in options)
+                        delete options.track;
+                    // try to play the next track if possible
+                    if (this.LavalinkManager.options?.autoSkipOnResolveError === true && this.queue.tracks[0])
+                        return this.play(options);
+                    return this;
+                }
+            }
             if ((typeof options.track?.userData === "object" || typeof options.clientTrack?.userData === "object") && options.clientTrack)
                 options.clientTrack.userData = { ...(options?.clientTrack.userData || {}), ...(options.track?.userData || {}) };
             options.track = {
@@ -165,6 +205,13 @@ export class Player {
                     ...(track.userData || {}),
                     requester: this.LavalinkManager.utils.getTransformedRequester(options?.track?.requester || {})
                 };
+            if (this.LavalinkManager.options?.advancedOptions?.enableDebugEvents) {
+                this.LavalinkManager.emit("debug", DebugEvents.PlayerPlayWithTrackReplace, {
+                    state: "log",
+                    message: `Player was called to play something, with a specific track provided. Replacing the current Track and resolving the track on trackStart Event.`,
+                    functionLayer: "Player > play()",
+                });
+            }
             return this.node.updatePlayer({
                 guildId: this.guildId,
                 noReplace: false,
@@ -182,6 +229,13 @@ export class Player {
         if (!this.queue.current && this.queue.tracks.length)
             await queueTrackEnd(this);
         if (this.queue.current && this.LavalinkManager.utils.isUnresolvedTrack(this.queue.current)) {
+            if (this.LavalinkManager.options?.advancedOptions?.enableDebugEvents) {
+                this.LavalinkManager.emit("debug", DebugEvents.PlayerPlayUnresolvedTrack, {
+                    state: "log",
+                    message: `Player Play was called, current Queue Song is unresolved, resolving the track.`,
+                    functionLayer: "Player > play()",
+                });
+            }
             try {
                 // resolve the unresolved track
                 await this.queue.current.resolve(this);
@@ -189,6 +243,14 @@ export class Player {
                     this.queue.current.userData = { ...(this.queue.current?.userData || {}), ...(options.track?.userData || {}) };
             }
             catch (error) {
+                if (this.LavalinkManager.options?.advancedOptions?.enableDebugEvents) {
+                    this.LavalinkManager.emit("debug", DebugEvents.PlayerPlayUnresolvedTrackFailed, {
+                        state: "error",
+                        error: error,
+                        message: `Player Play was called, current Queue Song is unresolved, but couldn't resolve it`,
+                        functionLayer: "Player > play() > resolve currentTrack",
+                    });
+                }
                 this.LavalinkManager.emit("trackError", this, this.queue.current, error);
                 if (options && "clientTrack" in options)
                     delete options.clientTrack;
@@ -255,6 +317,13 @@ export class Player {
             : this.volume), 1000), 0));
         const now = performance.now();
         if (this.LavalinkManager.options.playerOptions.applyVolumeAsFilter) {
+            if (this.LavalinkManager.options?.advancedOptions?.enableDebugEvents) {
+                this.LavalinkManager.emit("debug", DebugEvents.PlayerVolumeAsFilter, {
+                    state: "log",
+                    message: `Player Volume was set as a Filter, because LavalinkManager option "playerOptions.applyVolumeAsFilter" is true`,
+                    functionLayer: "Player > setVolume()",
+                });
+            }
             await this.node.updatePlayer({ guildId: this.guildId, playerOptions: { filters: { volume: this.lavalinkVolume / 100 } } });
         }
         else {
@@ -299,8 +368,16 @@ export class Player {
      */
     async search(query, requestUser, throwOnEmpty = false) {
         const Query = this.LavalinkManager.utils.transformQuery(query);
-        if (["bcsearch", "bandcamp"].includes(Query.source) && !this.node.info.sourceManagers.includes("bandcamp"))
+        if (["bcsearch", "bandcamp"].includes(Query.source) && !this.node.info.sourceManagers.includes("bandcamp")) {
+            if (this.LavalinkManager.options?.advancedOptions?.enableDebugEvents) {
+                this.LavalinkManager.emit("debug", DebugEvents.BandcampSearchLokalEngine, {
+                    state: "log",
+                    message: `Player.search was called with a Bandcamp Query, but no bandcamp search was enabled on lavalink, searching with the custom Search Engine.`,
+                    functionLayer: "Player > search()",
+                });
+            }
             return await bandCampSearch(this, Query.query, requestUser);
+        }
         return this.node.search(Query, requestUser, throwOnEmpty);
     }
     /**
@@ -359,7 +436,6 @@ export class Player {
         this.repeatMode = repeatMode;
         return this;
     }
-    1;
     /**
      * Skip the current song, or a specific amount of songs
      * @param amount provide the index of the next track to skip to
@@ -465,6 +541,13 @@ export class Player {
         if (this.LavalinkManager.options.advancedOptions?.debugOptions.playerDestroy.debugLog)
             console.log(`Lavalink-Client-Debug | PlayerDestroy [::] destroy Function, [guildId ${this.guildId}] - Destroy-Reason: ${String(reason)}`);
         if (this.get("internal_destroystatus") === true) {
+            if (this.LavalinkManager.options?.advancedOptions?.enableDebugEvents) {
+                this.LavalinkManager.emit("debug", DebugEvents.PlayerDestroyingSomewhereElse, {
+                    state: "warn",
+                    message: `Player is already destroying somewhere else..`,
+                    functionLayer: "Player > destroy()",
+                });
+            }
             if (this.LavalinkManager.options.advancedOptions?.debugOptions.playerDestroy.debugLog)
                 console.log(`Lavalink-Client-Debug | PlayerDestroy [::] destroy Function, [guildId ${this.guildId}] - Already destroying somewhere else..`);
             return;
@@ -496,10 +579,19 @@ export class Player {
         const updateNode = typeof newNode === "string" ? this.LavalinkManager.nodeManager.nodes.get(newNode) : newNode;
         if (!updateNode)
             throw new Error("Could not find the new Node");
+        if (this.LavalinkManager.options?.advancedOptions?.enableDebugEvents) {
+            this.LavalinkManager.emit("debug", DebugEvents.PlayerChangeNode, {
+                state: "log",
+                message: `Player.changeNode() was executed, trying to change from "${this.node.id}" to "${updateNode.id}"`,
+                functionLayer: "Player > changeNode()",
+            });
+        }
         const data = this.toJSON();
+        const currentTrack = this.queue.current;
         await this.node.destroyPlayer(this.guildId);
         this.node = updateNode;
         const now = performance.now();
+        await this.connect();
         await this.node.updatePlayer({
             guildId: this.guildId,
             noReplace: false,
@@ -508,9 +600,7 @@ export class Player {
                 volume: Math.round(Math.max(Math.min(data.volume, 1000), 0)),
                 paused: data.paused,
                 filters: { ...data.filters, equalizer: data.equalizer },
-                voice: this.voice,
-                track: this.queue.current ?? undefined
-                // track: this.queue.current,
+                track: currentTrack ?? undefined
             },
         });
         this.ping.lavalink = Math.round((performance.now() - now) / 10) / 100;