lavalink-client 2.2.2 → 2.3.0

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

@@ -1,68 +1,56 @@
 /// <reference types="node" />
 import { EventEmitter } from "stream";
-import { LavalinkManager } from "./LavalinkManager";
-import { LavalinkNode, LavalinkNodeOptions } from "./Node";
-import { DestroyReasonsType } from "./Player";
-import { LavalinkPlayer, MiniMap } from "./Utils";
-type LavalinkNodeIdentifier = string;
-export interface NodeManagerEvents {
+import { LavalinkNode } from "./Node";
+import { MiniMap } from "./Utils";
+import type { LavalinkNodeIdentifier, LavalinkNodeOptions, NodeManagerEvents } from "./Types/Node";
+import type { LavalinkManager } from "./LavalinkManager";
+export declare class NodeManager extends EventEmitter {
     /**
-     * Emitted when a Node is created.
-     * @event Manager.nodeManager#create
+     * Emit an event
+     * @param event The event to emit
+     * @param args The arguments to pass to the event
+     * @returns
      */
-    "create": (node: LavalinkNode) => void;
+    emit<Event extends keyof NodeManagerEvents>(event: Event, ...args: Parameters<NodeManagerEvents[Event]>): boolean;
     /**
-     * Emitted when a Node is destroyed.
-     * @event Manager.nodeManager#destroy
+     * Add an event listener
+     * @param event The event to listen to
+     * @param listener The listener to add
+     * @returns
      */
-    "destroy": (node: LavalinkNode, destroyReason?: DestroyReasonsType) => void;
+    on<Event extends keyof NodeManagerEvents>(event: Event, listener: NodeManagerEvents[Event]): this;
     /**
-     * Emitted when a Node is connected.
-     * @event Manager.nodeManager#connect
+     * Add an event listener that only fires once
+     * @param event The event to listen to
+     * @param listener The listener to add
+     * @returns
      */
-    "connect": (node: LavalinkNode) => void;
-    /**
-     * Emitted when a Node is reconnecting.
-     * @event Manager.nodeManager#reconnecting
-    */
-    "reconnecting": (node: LavalinkNode) => void;
-    /**
-     * Emitted when a Node is disconnects.
-     * @event Manager.nodeManager#disconnect
-    */
-    "disconnect": (node: LavalinkNode, reason: {
-        code?: number;
-        reason?: string;
-    }) => void;
+    once<Event extends keyof NodeManagerEvents>(event: Event, listener: NodeManagerEvents[Event]): this;
     /**
-     * Emitted when a Node is error.
-     * @event Manager.nodeManager#error
-    */
-    "error": (node: LavalinkNode, error: Error, payload?: unknown) => void;
+     * Remove an event listener
+     * @param event The event to remove the listener from
+     * @param listener The listener to remove
+     * @returns
+     */
+    off<Event extends keyof NodeManagerEvents>(event: Event, listener: NodeManagerEvents[Event]): this;
     /**
-     * Emits every single Node event.
-     * @event Manager.nodeManager#raw
-    */
-    "raw": (node: LavalinkNode, payload: unknown) => void;
+     * Remove an event listener
+     * @param event The event to remove the listener from
+     * @param listener The listener to remove
+     * @returns
+     */
+    removeListener<Event extends keyof NodeManagerEvents>(event: Event, listener: NodeManagerEvents[Event]): this;
     /**
-     * Emits when the node connects resumed. You then need to create all players within this event for your usecase.
-     * Aka for that you need to be able to save player data like vc channel + text channel in a db and then sync it again
-     * @event Manager.nodeManager#nodeResumed
+     * The LavalinkManager that created this NodeManager
      */
-    "resumed": (node: LavalinkNode, paylaod: {
-        resumed: true;
-        sessionId: string;
-        op: "ready";
-    }, players: LavalinkPlayer[]) => void;
-}
-export declare interface NodeManager {
-    on<U extends keyof NodeManagerEvents>(event: U, listener: NodeManagerEvents[U]): this;
-    emit<U extends keyof NodeManagerEvents>(event: U, ...args: Parameters<NodeManagerEvents[U]>): boolean;
-    /** @private */
     LavalinkManager: LavalinkManager;
-}
-export declare class NodeManager extends EventEmitter {
+    /**
+     * A map of all nodes in the nodeManager
+     */
     nodes: MiniMap<string, LavalinkNode>;
+    /**
+     * @param LavalinkManager The LavalinkManager that created this NodeManager
+     */
     constructor(LavalinkManager: LavalinkManager);
     /**
      * Disconnects all Nodes from lavalink ws sockets
@@ -80,8 +68,22 @@ export declare class NodeManager extends EventEmitter {
      * @returns amount of nodes
      */
     reconnectAll(): Promise<number>;
+    /**
+     * Create a node and add it to the nodeManager
+     * @param options The options for the node
+     * @returns The node that was created
+     */
     createNode(options: LavalinkNodeOptions): LavalinkNode;
+    /**
+     * Get the nodes sorted for the least usage, by a sorttype
+     * @param sortType The type of sorting to use
+     * @returns
+     */
     leastUsedNodes(sortType?: "memory" | "cpuLavalink" | "cpuSystem" | "calls" | "playingPlayers" | "players"): LavalinkNode[];
+    /**
+     * Delete a node from the nodeManager and destroy it
+     * @param node The node to delete
+     * @returns
+     */
     deleteNode(node: LavalinkNodeIdentifier | LavalinkNode): void;
 }
-export {};

package/dist/esm/structures/NodeManager.js

@@ -1,9 +1,64 @@
 import { EventEmitter } from "stream";
+import { DestroyReasons } from "./Constants";
 import { LavalinkNode } from "./Node";
-import { DestroyReasons } from "./Player";
 import { MiniMap } from "./Utils";
 export class NodeManager extends EventEmitter {
+    /**
+     * Emit an event
+     * @param event The event to emit
+     * @param args The arguments to pass to the event
+     * @returns
+     */
+    emit(event, ...args) {
+        return super.emit(event, ...args);
+    }
+    /**
+     * Add an event listener
+     * @param event The event to listen to
+     * @param listener The listener to add
+     * @returns
+     */
+    on(event, listener) {
+        return super.on(event, listener);
+    }
+    /**
+     * Add an event listener that only fires once
+     * @param event The event to listen to
+     * @param listener The listener to add
+     * @returns
+     */
+    once(event, listener) {
+        return super.once(event, listener);
+    }
+    /**
+     * Remove an event listener
+     * @param event The event to remove the listener from
+     * @param listener The listener to remove
+     * @returns
+     */
+    off(event, listener) {
+        return super.off(event, listener);
+    }
+    /**
+     * Remove an event listener
+     * @param event The event to remove the listener from
+     * @param listener The listener to remove
+     * @returns
+     */
+    removeListener(event, listener) {
+        return super.removeListener(event, listener);
+    }
+    /**
+     * The LavalinkManager that created this NodeManager
+     */
+    LavalinkManager;
+    /**
+     * A map of all nodes in the nodeManager
+     */
     nodes = new MiniMap();
+    /**
+     * @param LavalinkManager The LavalinkManager that created this NodeManager
+     */
     constructor(LavalinkManager) {
         super();
         this.LavalinkManager = LavalinkManager;
@@ -65,6 +120,11 @@ export class NodeManager extends EventEmitter {
         }
         return counter;
     }
+    /**
+     * Create a node and add it to the nodeManager
+     * @param options The options for the node
+     * @returns The node that was created
+     */
     createNode(options) {
         if (this.nodes.has(options.id || `${options.host}:${options.port}`))
             return this.nodes.get(options.id || `${options.host}:${options.port}`);
@@ -72,6 +132,11 @@ export class NodeManager extends EventEmitter {
         this.nodes.set(newNode.id, newNode);
         return newNode;
     }
+    /**
+     * Get the nodes sorted for the least usage, by a sorttype
+     * @param sortType The type of sorting to use
+     * @returns
+     */
     leastUsedNodes(sortType = "players") {
         switch (sortType) {
             case "memory":
@@ -125,6 +190,11 @@ export class NodeManager extends EventEmitter {
                 break;
         }
     }
+    /**
+     * Delete a node from the nodeManager and destroy it
+     * @param node The node to delete
+     * @returns
+     */
     deleteNode(node) {
         const decodeNode = typeof node === "string" ? this.nodes.get(node) : node || this.leastUsedNodes()[0];
         if (!decodeNode)

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

@@ -1,123 +1,12 @@
-import { EQBand, FilterData, FilterManager, LavalinkFilterData } from "./Filters";
-import { LavalinkManager } from "./LavalinkManager";
-import { LavalinkNode, SponsorBlockSegment } from "./Node";
+import { FilterManager } from "./Filters";
 import { Queue } from "./Queue";
-import { Track, UnresolvedTrack } from "./Track";
-import { Base64, LavalinkPlayerVoiceOptions, LavaSearchQuery, SearchQuery } from "./Utils";
-export declare enum DestroyReasons {
-    QueueEmpty = "QueueEmpty",
-    NodeDestroy = "NodeDestroy",
-    NodeDeleted = "NodeDeleted",
-    LavalinkNoVoice = "LavalinkNoVoice",
-    NodeReconnectFail = "NodeReconnectFail",
-    Disconnected = "Disconnected",
-    PlayerReconnectFail = "PlayerReconnectFail",
-    ChannelDeleted = "ChannelDeleted",
-    DisconnectAllNodes = "DisconnectAllNodes",
-    ReconnectAllNodes = "ReconnectAllNodes"
-}
-export type DestroyReasonsType = keyof typeof DestroyReasons | string;
-export interface PlayerJson {
-    /** Guild Id where the player was playing in */
-    guildId: string;
-    /** Options provided to the player */
-    options: PlayerOptions;
-    /** Voice Channel Id the player was playing in */
-    voiceChannelId: string;
-    /** Text Channel Id the player was synced to */
-    textChannelId?: string;
-    /** Position the player was at */
-    position: number;
-    /** Lavalink's position the player was at */
-    lastPosition: number;
-    /** Last time the position was sent from lavalink */
-    lastPositionChange: number;
-    /** Volume in % from the player (without volumeDecrementer) */
-    volume: number;
-    /** Real Volume used in lavalink (with the volumeDecrementer) */
-    lavalinkVolume: number;
-    /** The repeatmode from the player */
-    repeatMode: RepeatMode;
-    /** Pause state */
-    paused: boolean;
-    /** Wether the player was playing or not */
-    playing: boolean;
-    /** When the player was created */
-    createdTimeStamp?: number;
-    /** All current used fitlers Data */
-    filters: FilterData;
-    /** The player's ping object */
-    ping: {
-        /** Ping to the voice websocket server */
-        ws: number;
-        /** Avg. calc. Ping to the lavalink server */
-        lavalink: number;
-    };
-    /** Equalizer Bands used in lavalink */
-    equalizer: EQBand[];
-    /** The Id of the last used node */
-    nodeId?: string;
-}
-export type RepeatMode = "queue" | "track" | "off";
-export interface PlayerOptions {
-    /** Guild id of the player */
-    guildId: string;
-    /** The Voice Channel Id */
-    voiceChannelId: string;
-    /** The Text Channel Id of the Player */
-    textChannelId?: string;
-    /** instantly change volume with the one play request */
-    volume?: number;
-    /** VC Region for node selections */
-    vcRegion?: string;
-    /** if it should join deafened */
-    selfDeaf?: boolean;
-    /** If it should join muted */
-    selfMute?: boolean;
-    /** If it should use a specific lavalink node */
-    node?: LavalinkNode | string;
-    /** If when applying filters, it should use the insta apply filters fix  */
-    instaUpdateFiltersFix?: boolean;
-    /** If a volume should be applied via filters instead of lavalink-volume */
-    applyVolumeAsFilter?: boolean;
-}
-export type anyObject = {
-    [key: string | number]: string | number | null | anyObject;
-};
-export interface BasePlayOptions {
-    /** The position to start the track. */
-    position?: number;
-    /** The position to end the track. */
-    endTime?: number;
-    /** If to start "paused" */
-    paused?: boolean;
-    /** The Volume to start with */
-    volume?: number;
-    /** The Lavalink Filters to use | only with the new REST API */
-    filters?: Partial<LavalinkFilterData>;
-    /** Voice Update for Lavalink */
-    voice?: LavalinkPlayerVoiceOptions;
-}
-export interface LavalinkPlayOptions extends BasePlayOptions {
-    /** Which Track to play | don't provide, if it should pick from the Queue */
-    track?: {
-        /** The track encoded base64 string to use instead of the one from the queue system */
-        encoded?: Base64 | null;
-        /** The identifier of the track to use */
-        identifier?: string;
-        /** Custom User Data for the track to provide, will then be on the userData object from the track */
-        userData?: anyObject;
-        /** The Track requester for when u provide encodedTrack / identifer */
-        requester?: unknown;
-    };
-}
-export interface PlayOptions extends LavalinkPlayOptions {
-    /** Whether to not replace the track if a play payload is sent. */
-    noReplace?: boolean;
-    /** Adds track on queue and skips to it */
-    clientTrack?: Track | UnresolvedTrack;
-}
-export interface Player {
+import type { DestroyReasons } from "./Constants";
+import type { LavalinkNode } from "./Node";
+import type { SponsorBlockSegment } from "./Types/Node";
+import type { PlayerJson, PlayerOptions, PlayOptions, RepeatMode } from "./Types/Player";
+import type { LavalinkManager } from "./LavalinkManager";
+import type { LavalinkPlayerVoiceOptions, LavaSearchQuery, SearchQuery } from "./Types/Utils";
+export declare class Player {
     /** Filter Manager per player */
     filterManager: FilterManager;
     /** circular reference to the lavalink Manager from the Player for easier use */
@@ -128,8 +17,6 @@ export interface Player {
     node: LavalinkNode;
     /** The queue from the player */
     queue: Queue;
-}
-export declare class Player {
     /** The Guild Id of the Player */
     guildId: string;
     /** The Voice Channel Id of the Player */
@@ -157,12 +44,14 @@ export declare class Player {
     lastPositionChange: number;
     /** The current Positin of the player (from Lavalink) */
     lastPosition: number;
+    lastSavedPosition: number;
     /** When the player was created [Timestamp in Ms] (from lavalink) */
     createdTimeStamp: number;
     /** The Player Connection's State (from Lavalink) */
     connected: boolean | undefined;
     /** Voice Server Data (from Lavalink) */
     voice: LavalinkPlayerVoiceOptions;
+    /** Custom data for the player */
     private readonly data;
     /**
      * Create a new Player
@@ -200,16 +89,33 @@ export declare class Player {
      * @param ignoreVolumeDecrementer If it should ignore the volumedecrementer option
      */
     setVolume(volume: number, ignoreVolumeDecrementer?: boolean): Promise<this>;
-    lavaSearch(query: LavaSearchQuery, requestUser: unknown, throwOnEmpty?: boolean): Promise<import("./Utils").SearchResult | import("./Utils").LavaSearchResponse>;
+    /**
+     * Search for a track
+     * @param query The query to search for
+     * @param requestUser The user that requested the track
+     * @param throwOnEmpty If an error should be thrown if no track is found
+     * @returns The search result
+     */
+    lavaSearch(query: LavaSearchQuery, requestUser: unknown, throwOnEmpty?: boolean): Promise<import("./Types/Utils").SearchResult | import("./Types/Utils").LavaSearchResponse>;
+    /**
+     * Set the SponsorBlock
+     * @param segments The segments to set
+     */
     setSponsorBlock(segments?: SponsorBlockSegment[]): Promise<void>;
+    /**
+     * Get the SponsorBlock
+     */
     getSponsorBlock(): Promise<SponsorBlockSegment[]>;
+    /**
+     * Delete the SponsorBlock
+     */
     deleteSponsorBlock(): Promise<void>;
     /**
      *
      * @param query Query for your data
      * @param requestUser
      */
-    search(query: SearchQuery, requestUser: unknown, throwOnEmpty?: boolean): Promise<import("./Utils").SearchResult | import("./Utils").UnresolvedSearchResult>;
+    search(query: SearchQuery, requestUser: unknown, throwOnEmpty?: boolean): Promise<import("./Types/Utils").UnresolvedSearchResult | import("./Types/Utils").SearchResult>;
     /**
      * Pause the player
      */
@@ -228,11 +134,12 @@ 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
      */
-    skip(skipTo?: number, throwError?: boolean): any;
+    skip(skipTo?: number, throwError?: boolean): Promise<this>;
     /**
      * Clears the queue and stops playing. Does not destroy the Player and not leave the channel
      * @returns

package/dist/esm/structures/Player.js

@@ -2,21 +2,17 @@ import { bandCampSearch } from "./CustomSearches/BandCampSearch";
 import { FilterManager } from "./Filters";
 import { Queue, QueueSaver } from "./Queue";
 import { queueTrackEnd } from "./Utils";
-export var DestroyReasons;
-(function (DestroyReasons) {
-    DestroyReasons["QueueEmpty"] = "QueueEmpty";
-    DestroyReasons["NodeDestroy"] = "NodeDestroy";
-    DestroyReasons["NodeDeleted"] = "NodeDeleted";
-    DestroyReasons["LavalinkNoVoice"] = "LavalinkNoVoice";
-    DestroyReasons["NodeReconnectFail"] = "NodeReconnectFail";
-    DestroyReasons["Disconnected"] = "Disconnected";
-    DestroyReasons["PlayerReconnectFail"] = "PlayerReconnectFail";
-    DestroyReasons["ChannelDeleted"] = "ChannelDeleted";
-    DestroyReasons["DisconnectAllNodes"] = "DisconnectAllNodes";
-    DestroyReasons["ReconnectAllNodes"] = "ReconnectAllNodes";
-})(DestroyReasons || (DestroyReasons = {}));
-;
 export class Player {
+    /** Filter Manager per player */
+    filterManager;
+    /** circular reference to the lavalink Manager from the Player for easier use */
+    LavalinkManager;
+    /** Player options currently used, mutation doesn't affect player's state */
+    options;
+    /** The lavalink node assigned the the player, don't change it manually */
+    node;
+    /** The queue from the player */
+    queue;
     /** The Guild Id of the Player */
     guildId;
     /** The Voice Channel Id of the Player */
@@ -48,6 +44,7 @@ export class Player {
     lastPositionChange = null;
     /** The current Positin of the player (from Lavalink) */
     lastPosition = 0;
+    lastSavedPosition = 0;
     /** When the player was created [Timestamp in Ms] (from lavalink) */
     createdTimeStamp;
     /** The Player Connection's State (from Lavalink) */
@@ -58,6 +55,7 @@ export class Player {
         sessionId: null,
         token: null
     };
+    /** Custom data for the player */
     data = {};
     /**
      * Create a new Player
@@ -130,39 +128,56 @@ export class Player {
             clearTimeout(this.get("internal_queueempty"));
             this.set("internal_queueempty", undefined);
         }
-        let replaced = false;
-        // if clientTrack provided, play it
+        // 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 ((typeof options.track?.userData === "object" || typeof options.clientTrack?.userData === "object") && options.clientTrack)
                 options.clientTrack.userData = { ...(options?.clientTrack.userData || {}), ...(options.track?.userData || {}) };
-            await this.queue.add(options?.clientTrack, 0);
-            return await this.skip();
+            options.track = {
+                encoded: options.clientTrack?.encoded,
+                requester: options.clientTrack?.requester,
+                userData: options.clientTrack?.userData,
+            };
         }
-        else if (options?.track?.encoded) {
-            // handle play encoded options manually // TODO let it resolve by lavalink!
-            const track = await this.node.decode.singleTrack(options.track?.encoded, options.track?.requester || this.queue?.current?.requester || this.queue.previous?.[0]?.requester || this.queue.tracks?.[0]?.requester || this.LavalinkManager.options.client);
-            if (track) {
-                if (typeof options.track?.userData === "object")
-                    track.userData = { ...(track.userData || {}), ...(options.track.userData || {}) };
-                replaced = true;
-                this.queue.add(track, 0);
-                await queueTrackEnd(this);
-            }
-        }
-        else if (options?.track?.identifier) {
-            // handle play identifier options manually // TODO let it resolve by lavalink!
-            const res = await this.search({
-                query: options?.track?.identifier
-            }, options?.track?.requester || this.queue?.current?.requester || this.queue.previous?.[0]?.requester || this.queue.tracks?.[0]?.requester || this.LavalinkManager.options.client);
-            if (res.tracks[0]) {
-                if (typeof options.track?.userData === "object")
-                    res.tracks[0].userData = { ...(res.tracks[0].userData || {}), ...(options.track.userData || {}) };
-                replaced = true;
-                this.queue.add(res.tracks[0], 0);
-                await queueTrackEnd(this);
+        // if either encoded or identifier is provided generate the data to play them
+        if (options?.track?.encoded || options?.track?.identifier) {
+            this.queue.current = options.clientTrack || null;
+            this.queue.utils.save();
+            if (typeof options?.volume === "number" && !isNaN(options?.volume)) {
+                this.volume = Math.max(Math.min(options?.volume, 500), 0);
+                let vol = Number(this.volume);
+                if (this.LavalinkManager.options.playerOptions.volumeDecrementer)
+                    vol *= this.LavalinkManager.options.playerOptions.volumeDecrementer;
+                this.lavalinkVolume = Math.round(vol);
+                options.volume = this.lavalinkVolume;
             }
+            const track = Object.fromEntries(Object.entries({
+                encoded: options.track.encoded,
+                identifier: options.track.identifier,
+            }).filter(v => typeof v[1] !== "undefined"));
+            if (typeof options.track.userData === "object")
+                track.userData = {
+                    ...(options.track.userData || {})
+                };
+            if (typeof options?.track?.requester === "object")
+                track.userData = {
+                    ...(track.userData || {}),
+                    requester: this.LavalinkManager.utils.getTransformedRequester(options?.track?.requester || {})
+                };
+            return this.node.updatePlayer({
+                guildId: this.guildId,
+                noReplace: false,
+                playerOptions: Object.fromEntries(Object.entries({
+                    track,
+                    position: options.position ?? undefined,
+                    paused: options.paused ?? undefined,
+                    endTime: options?.endTime ?? undefined,
+                    filters: options?.filters ?? undefined,
+                    volume: options.volume ?? this.lavalinkVolume ?? undefined,
+                    voice: options.voice ?? undefined,
+                }).filter(v => typeof v[1] !== "undefined")),
+            });
         }
         if (!this.queue.current && this.queue.tracks.length)
             await queueTrackEnd(this);
@@ -219,7 +234,7 @@ export class Player {
         const now = performance.now();
         await this.node.updatePlayer({
             guildId: this.guildId,
-            noReplace: replaced ? replaced : (options?.noReplace ?? false),
+            noReplace: (options?.noReplace ?? false),
             playerOptions: finalOptions,
         });
         this.ping.lavalink = Math.round((performance.now() - now) / 10) / 100;
@@ -248,15 +263,32 @@ export class Player {
         this.ping.lavalink = Math.round((performance.now() - now) / 10) / 100;
         return this;
     }
+    /**
+     * Search for a track
+     * @param query The query to search for
+     * @param requestUser The user that requested the track
+     * @param throwOnEmpty If an error should be thrown if no track is found
+     * @returns The search result
+     */
     async lavaSearch(query, requestUser, throwOnEmpty = false) {
         return this.node.lavaSearch(query, requestUser, throwOnEmpty);
     }
+    /**
+     * Set the SponsorBlock
+     * @param segments The segments to set
+     */
     async setSponsorBlock(segments = ["sponsor", "selfpromo"]) {
         return this.node.setSponsorBlock(this, segments);
     }
+    /**
+     * Get the SponsorBlock
+     */
     async getSponsorBlock() {
         return this.node.getSponsorBlock(this);
     }
+    /**
+     * Delete the SponsorBlock
+     */
     async deleteSponsorBlock() {
         return this.node.deleteSponsorBlock(this);
     }
@@ -327,6 +359,7 @@ 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
@@ -340,7 +373,7 @@ export class Player {
             await this.queue.splice(0, skipTo - 1);
         }
         if (!this.playing)
-            return await this.play();
+            return (this.play(), this);
         const now = performance.now();
         this.set("internal_skipped", true);
         await this.node.updatePlayer({ guildId: this.guildId, playerOptions: { track: { encoded: null } } });
@@ -502,6 +535,7 @@ export class Player {
             filters: this.filterManager?.data || {},
             equalizer: this.filterManager?.equalizerBands || [],
             nodeId: this.node?.id,
+            nodeSessionId: this.node?.sessionId,
             ping: this.ping,
             queue: this.queue.utils.toJSON(),
         };