magmastream 2.9.0-dev.31 → 2.9.0-dev.33

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 import { Collection } from '@discordjs/collection';
 import { GatewayVoiceStateUpdate } from 'discord-api-types/v10';
 import { EventEmitter } from 'events';
-import WebSocket from 'ws';
+import WebSocket, { WebSocket as WebSocket$1 } from 'ws';
 import { User, ClientUser, Message, Client } from 'discord.js';
 import { Redis } from 'ioredis';
 import { Client as Client$1 } from 'eris';
@@ -28,6 +28,8 @@ declare class Rest {
     private readonly url;
     /** The Manager instance. */
     manager: Manager;
+    /** Whether the node is a NodeLink. */
+    isNodeLink: boolean;
     constructor(node: Node$1, manager: Manager);
     /**
      * Sets the session ID.
@@ -285,7 +287,12 @@ declare enum ManagerEventTypes {
     TrackEnd = "trackEnd",
     TrackError = "trackError",
     TrackStart = "trackStart",
-    TrackStuck = "trackStuck"
+    TrackStuck = "trackStuck",
+    VoiceReceiverDisconnect = "voiceReceiverDisconnect",
+    VoiceReceiverConnect = "voiceReceiverConnect",
+    VoiceReceiverError = "voiceReceiverError",
+    VoiceReceiverStartSpeaking = "voiceReceiverStartSpeaking",
+    VoiceReceiverEndSpeaking = "voiceReceiverEndSpeaking"
 }
 /**
  * Track End Reason Enum
@@ -729,15 +736,40 @@ interface LavaPlayer {
     filters: Record<string, unknown>;
 }
 /**
- * Search Result
+ * Error or Empty Search Result
  */
-interface SearchResult {
+interface ErrorOrEmptySearchResult {
     /** The load type of the result. */
-    loadType: LoadTypes;
-    /** The array of tracks from the result. */
+    loadType: LoadTypes.Empty | LoadTypes.Error;
+}
+/**
+ * Track Search Result
+ */
+interface TrackSearchResult {
+    /** The load type is always 'track' */
+    loadType: LoadTypes.Track;
+    /** The track obtained */
+    tracks: [Track];
+}
+/**
+ * Search Result
+ */
+interface SearchSearchResult {
+    /** The load type is always 'search' */
+    loadType: LoadTypes.Search;
+    /** The tracks of the search result */
+    tracks: Track[];
+}
+/**
+ * Playlist Search Result
+ */
+interface PlaylistSearchResult {
+    /** The playlist load type */
+    loadType: LoadTypes.Playlist;
+    /** The tracks of the playlist */
     tracks: Track[];
-    /** The playlist info if the load type is 'playlist'. */
-    playlist?: PlaylistData;
+    /** The playlist info */
+    playlist: PlaylistData;
 }
 /**
  * Playlist Data
@@ -801,6 +833,11 @@ interface ManagerEvents {
     [ManagerEventTypes.TrackError]: [player: Player, track: Track, payload: TrackExceptionEvent];
     [ManagerEventTypes.TrackStart]: [player: Player, track: Track, payload: TrackStartEvent];
     [ManagerEventTypes.TrackStuck]: [player: Player, track: Track, payload: TrackStuckEvent];
+    [ManagerEventTypes.VoiceReceiverDisconnect]: [player: Player];
+    [ManagerEventTypes.VoiceReceiverConnect]: [player: Player];
+    [ManagerEventTypes.VoiceReceiverError]: [player: Player, error: Error];
+    [ManagerEventTypes.VoiceReceiverStartSpeaking]: [player: Player, data: unknown];
+    [ManagerEventTypes.VoiceReceiverEndSpeaking]: [player: Player, data: unknown];
 }
 /**
  * Voice Packet
@@ -997,6 +1034,8 @@ interface NodeOptions {
     apiRequestTimeoutMs?: number;
     /** Priority of the node. */
     nodePriority?: number;
+    /** Whether the node is a NodeLink. */
+    isNodeLink?: boolean;
 }
 /**
  * NodeOptions interface
@@ -1139,6 +1178,100 @@ interface Lyrics {
     lines: LyricsLine[];
     plugin: object[];
 }
+/**
+ * NodeLink Get Lyrics Multiple interface
+ */
+interface NodeLinkGetLyricsMultiple {
+    loadType: "lyricsMultiple";
+    data: NodeLinkGetLyricsData[];
+}
+/**
+ * NodeLink Get Lyrics Empty interface
+ */
+interface NodeLinkGetLyricsEmpty {
+    loadType: "empty";
+    data: Record<never, never>;
+}
+/**
+ * NodeLink Get Lyrics Data interface
+ */
+interface NodeLinkGetLyricsData {
+    name: string;
+    synced: boolean;
+    data: {
+        startTime?: number;
+        endTime?: number;
+        text: string;
+    }[];
+    rtl: boolean;
+}
+/**
+ * NodeLink Get Lyrics Single interface
+ */
+interface NodeLinkGetLyricsSingle {
+    loadType: "lyricsSingle";
+    data: NodeLinkGetLyricsData;
+}
+/**
+ * NodeLink Get Lyrics Error interface
+ */
+interface NodeLinkGetLyricsError {
+    loadType: "error";
+    data: {
+        message: string;
+        severity: Severity;
+        cause: string;
+        trace?: string;
+    };
+}
+interface StartSpeakingEventVoiceReceiverData {
+    /**
+     * The user ID of the user who started speaking.
+     */
+    userId: string;
+    /**
+     * The guild ID of the guild where the user started speaking.
+     */
+    guildId: string;
+}
+interface EndSpeakingEventVoiceReceiverData {
+    /**
+     * The user ID of the user who stopped speaking.
+     */
+    userId: string;
+    /**
+     * The guild ID of the guild where the user stopped speaking.
+     */
+    guildId: string;
+    /**
+     * The audio data received from the user in base64.
+     */
+    data: string;
+    /**
+     * The type of the audio data. Can be either opus or pcm. Older versions may include ogg/opus.
+     */
+    type: "opus" | "pcm";
+}
+/**
+ * Base Voice Receiver Event interface
+ */
+interface BaseVoiceReceiverEvent {
+    op: "speak";
+}
+/**
+ * Start Speaking Event Voice Receiver interface
+ */
+interface StartSpeakingEventVoiceReceiver extends BaseVoiceReceiverEvent {
+    type: "startSpeakingEvent";
+    data: StartSpeakingEventVoiceReceiverData;
+}
+/**
+ * End Speaking Event Voice Receiver interface
+ */
+interface EndSpeakingEventVoiceReceiver extends BaseVoiceReceiverEvent {
+    type: "endSpeakingEvent";
+    data: EndSpeakingEventVoiceReceiverData;
+}
 /**
  * PlayerOptions interface
  */
@@ -1179,25 +1312,6 @@ interface EqualizerBand {
     /** The gain amount being -0.25 to 1.00, 0.25 being double. */
     gain: number;
 }
-/**
- * PlayerStore interface
- */
-interface PlayerStore {
-    get(guildId: string): Promise<Player | undefined>;
-    set(guildId: string, player: Player): Promise<void>;
-    delete(guildId: string): Promise<void>;
-    keys(): Promise<string[]>;
-    has(guildId: string): Promise<boolean>;
-    filter(predicate: (player: Player, guildId: string) => boolean | Promise<boolean>): Promise<Map<string, Player>>;
-    find(predicate: (player: Player, guildId: string) => boolean | Promise<boolean>): Promise<Player | undefined>;
-    map<T>(callback: (player: Player, guildId: string) => T | Promise<T>): Promise<T[]>;
-    forEach(callback: (player: Player, guildId: string) => void | Promise<void>): Promise<void>;
-    some(predicate: (player: Player, guildId: string) => boolean | Promise<boolean>): Promise<boolean>;
-    every(predicate: (player: Player, guildId: string) => boolean | Promise<boolean>): Promise<boolean>;
-    size(): Promise<number>;
-    clear(): Promise<void>;
-    entries(): AsyncIterableIterator<[string, Player]>;
-}
 /**
  * Queue interface
  */
@@ -1270,6 +1384,18 @@ type PlayerEvents = TrackStartEvent | TrackEndEvent | TrackStuckEvent | TrackExc
  * Load Type Enum type
  */
 type LoadType = keyof typeof LoadTypes;
+/**
+ * NodeLink Get Lyrics Enum type
+ */
+type NodeLinkGetLyrics = NodeLinkGetLyricsSingle | NodeLinkGetLyricsMultiple | NodeLinkGetLyricsEmpty | NodeLinkGetLyricsError;
+/**
+ * Voice Receiver Event Enum type
+ */
+type VoiceReceiverEvent = StartSpeakingEventVoiceReceiver | EndSpeakingEventVoiceReceiver;
+/**
+ * Search Result Enum type
+ */
+type SearchResult = TrackSearchResult | SearchSearchResult | PlaylistSearchResult | ErrorOrEmptySearchResult;
 
 declare class Node$1 {
     manager: Manager;
@@ -1285,11 +1411,14 @@ declare class Node$1 {
     readonly rest: Rest;
     /** Actual Lavalink information of the node. */
     info: LavalinkInfo | null;
+    /** Whether the node is a NodeLink. */
+    isNodeLink: boolean;
     private reconnectTimeout?;
     private reconnectAttempts;
     /**
      * Creates an instance of Node.
-     * @param options
+     * @param manager - The manager for the node.
+     * @param options - The options for the node.
      */
     constructor(manager: Manager, options: NodeOptions);
     /** Returns if connected to the Node. */
@@ -1361,6 +1490,12 @@ declare class Node$1 {
      * @emits {nodeDestroy} - Emits a nodeDestroy event if the maximum number of retry attempts is reached.
      */
     private reconnect;
+    /**
+     * Upgrades the node to a NodeLink.
+     *
+     * @param request - The incoming message.
+     */
+    private upgrade;
     /**
      * Handles the "open" event emitted by the WebSocket connection.
      *
@@ -1492,9 +1627,9 @@ declare class Node$1 {
      *
      * @param {Track} track - The track to fetch the lyrics for.
      * @param {boolean} [skipTrackSource=false] - Whether to skip using the track's source URL.
-     * @returns {Promise<Lyrics>} A promise that resolves with the lyrics data.
+     * @returns {Promise<Lyrics | NodeLinkGetLyrics>} A promise that resolves with the lyrics data.
      */
-    getLyrics(track: Track, skipTrackSource?: boolean): Promise<Lyrics>;
+    getLyrics(track: Track, skipTrackSource?: boolean): Promise<Lyrics | NodeLinkGetLyrics>;
     /**
      * Handles the event when a track becomes stuck during playback.
      * Stops the current track and emits a `trackStuck` event.
@@ -1808,6 +1943,11 @@ declare class Manager extends EventEmitter {
      * This is done to prevent stale state files from accumulating on the file system.
      */
     private cleanupInactivePlayers;
+    /**
+     * Clears all player states from the file system.
+     * This is done to prevent stale state files from accumulating on the file system.
+     */
+    private clearAllPlayerStates;
     /**
      * Returns the nodes that has the least load.
      * The load is calculated by dividing the lavalink load by the number of cores.
@@ -1884,6 +2024,12 @@ declare class Player {
     private dynamicLoopInterval;
     dynamicRepeatIntervalMs: number | null;
     private static _manager;
+    /** Should only be used when the node is a NodeLink */
+    protected voiceReceiverWsClient: WebSocket$1 | null;
+    protected isConnectToVoiceReceiver: boolean;
+    protected voiceReceiverReconnectTimeout: NodeJS.Timeout | null;
+    protected voiceReceiverAttempt: number;
+    protected voiceReceiverReconnectTries: number;
     /**
      * Creates a new player, returns one if it already exists.
      * @param options The player options.
@@ -2116,11 +2262,51 @@ declare class Player {
      */
     getCurrentLyrics(skipTrackSource?: boolean): Promise<Lyrics>;
     /**
-     * Sleeps for a specified amount of time.
-     * @param ms The amount of time to sleep in milliseconds.
-     * @returns A promise that resolves after the specified amount of time.
+     * Sets up the voice receiver for the player.
+     * @returns {Promise<void>} - A promise that resolves when the voice receiver is set up.
+     * @throws {Error} - If the node is not a NodeLink.
      */
-    private sleep;
+    setupVoiceReceiver(): Promise<void>;
+    /**
+     * Removes the voice receiver for the player.
+     * @returns {Promise<void>} - A promise that resolves when the voice receiver is removed.
+     * @throws {Error} - If the node is not a NodeLink.
+     */
+    removeVoiceReceiver(): Promise<void>;
+    /**
+     * Closes the voice receiver for the player.
+     * @param {number} code - The code to close the voice receiver with.
+     * @param {string} reason - The reason to close the voice receiver with.
+     * @returns {Promise<void>} - A promise that resolves when the voice receiver is closed.
+     */
+    private closeVoiceReceiver;
+    /**
+     * Reconnects the voice receiver for the player.
+     * @returns {Promise<void>} - A promise that resolves when the voice receiver is reconnected.
+     */
+    private reconnectVoiceReceiver;
+    /**
+     * Disconnects the voice receiver for the player.
+     * @returns {Promise<void>} - A promise that resolves when the voice receiver is disconnected.
+     */
+    private disconnectVoiceReceiver;
+    /**
+     * Opens the voice receiver for the player.
+     * @returns {Promise<void>} - A promise that resolves when the voice receiver is opened.
+     */
+    private openVoiceReceiver;
+    /**
+     * Handles a voice receiver message.
+     * @param {string} payload - The payload to handle.
+     * @returns {Promise<void>} - A promise that resolves when the voice receiver message is handled.
+     */
+    private onVoiceReceiverMessage;
+    /**
+     * Handles a voice receiver error.
+     * @param {Error} error - The error to handle.
+     * @returns {Promise<void>} - A promise that resolves when the voice receiver error is handled.
+     */
+    private onVoiceReceiverError;
 }
 
 declare class Filters {
@@ -2575,6 +2761,12 @@ declare abstract class TrackUtils {
      * @returns The built Track.
      */
     static build<T = User | ClientUser>(data: TrackData, requester?: T): Track;
+    /**
+     * Validates a search result.
+     * @param result The search result to validate.
+     * @returns Whether the search result is valid.
+     */
+    static isErrorOrEmptySearchResult(result: SearchResult): result is ErrorOrEmptySearchResult;
 }
 declare abstract class AutoPlayUtils {
     private static manager;
@@ -2583,7 +2775,7 @@ declare abstract class AutoPlayUtils {
      * @param manager The manager instance to use.
      * @hidden
      */
-    static init(manager: Manager): void;
+    static init(manager: Manager): Promise<void>;
     /**
      * Gets recommended tracks for the given track.
      * @param track The track to get recommended tracks for.
@@ -2603,10 +2795,8 @@ declare abstract class AutoPlayUtils {
      * @param platform The source to get recommended tracks from.
      * @returns An array of recommended tracks.
      */
-    static getRecommendedTracksFromSource(track: Track, platform: string): Promise<Track[]>;
-    static fetchSecretArray(): Promise<Buffer<ArrayBuffer>>;
-    static transformSecret(buffer: Buffer): Buffer<ArrayBuffer>;
-    static generateTotp(secretBuffer: Buffer): string;
+    static getRecommendedTracksFromSource(track: Track, platform: AutoPlayPlatform): Promise<Track[]>;
+    static buildTracksFromResponse<T>(recommendedResult: LavalinkResponse, requester?: T): Track[];
 }
 /** Gets or extends structures to extend the built in, or already extended, classes to add more functionality. */
 declare abstract class Structure {
@@ -2660,4 +2850,4 @@ declare class OceanicManager extends Manager {
 }
 
 export { AutoPlayPlatform, AutoPlayUtils, AvailableFilters, DetritusManager, DiscordJSManager, ErisManager, Filters, LoadTypes, Manager, ManagerEventTypes, Node$1 as Node, OceanicManager, Player, PlayerStateEventTypes, Plugin$1 as Plugin, Queue, Rest, SearchPlatform, SeverityTypes, SponsorBlockSegment, StateStorageType, StateTypes, Structure, TrackEndReasonTypes, TrackPartial, TrackSourceTypes, TrackUtils, UseNodeOptions };
-export type { CPUStats, DiscordPacket, EqualizerBand, Exception, Extendable, FrameStats, IQueue, LavaPlayer, LavalinkInfo, LavalinkResponse, LoadType, Lyrics, LyricsLine, ManagerEvents, ManagerInitOptions, ManagerOptions, MemoryStats, NodeMessage, NodeOptions, NodeStats, Payload, PlayOptions, PlayerEvent, PlayerEventType, PlayerEvents, PlayerOptions, PlayerStateUpdateEvent, PlayerStore, PlayerUpdate, PlayerUpdateVoiceState, PlaylistData, PlaylistInfoData, PlaylistRawData, RedisConfig, SearchQuery, SearchResult, Severity, Sizes, SponsorBlockChapterStarted, SponsorBlockChaptersLoaded, SponsorBlockSegmentEventType, SponsorBlockSegmentEvents, SponsorBlockSegmentSkipped, SponsorBlockSegmentsLoaded, StateStorageOptions, Track, TrackData, TrackDataInfo, TrackEndEvent, TrackEndReason, TrackExceptionEvent, TrackPluginInfo, TrackSourceName, TrackStartEvent, TrackStuckEvent, UseNodeOption, VoicePacket, VoiceServer, VoiceServerUpdate, VoiceState, WebSocketClosedEvent };
+export type { CPUStats, DiscordPacket, EndSpeakingEventVoiceReceiver, EndSpeakingEventVoiceReceiverData, EqualizerBand, ErrorOrEmptySearchResult, Exception, Extendable, FrameStats, IQueue, LavaPlayer, LavalinkInfo, LavalinkResponse, LoadType, Lyrics, LyricsLine, ManagerEvents, ManagerInitOptions, ManagerOptions, MemoryStats, NodeLinkGetLyrics, NodeLinkGetLyricsEmpty, NodeLinkGetLyricsError, NodeLinkGetLyricsMultiple, NodeLinkGetLyricsSingle, NodeMessage, NodeOptions, NodeStats, Payload, PlayOptions, PlayerEvent, PlayerEventType, PlayerEvents, PlayerOptions, PlayerStateUpdateEvent, PlayerUpdate, PlayerUpdateVoiceState, PlaylistData, PlaylistInfoData, PlaylistRawData, PlaylistSearchResult, RedisConfig, SearchQuery, SearchResult, SearchSearchResult, Severity, Sizes, SponsorBlockChapterStarted, SponsorBlockChaptersLoaded, SponsorBlockSegmentEventType, SponsorBlockSegmentEvents, SponsorBlockSegmentSkipped, SponsorBlockSegmentsLoaded, StartSpeakingEventVoiceReceiver, StartSpeakingEventVoiceReceiverData, StateStorageOptions, Track, TrackData, TrackDataInfo, TrackEndEvent, TrackEndReason, TrackExceptionEvent, TrackPluginInfo, TrackSearchResult, TrackSourceName, TrackStartEvent, TrackStuckEvent, UseNodeOption, VoicePacket, VoiceReceiverEvent, VoiceServer, VoiceServerUpdate, VoiceState, WebSocketClosedEvent };

package/dist/structures/Enums.js

@@ -163,6 +163,11 @@ var ManagerEventTypes;
     ManagerEventTypes["TrackError"] = "trackError";
     ManagerEventTypes["TrackStart"] = "trackStart";
     ManagerEventTypes["TrackStuck"] = "trackStuck";
+    ManagerEventTypes["VoiceReceiverDisconnect"] = "voiceReceiverDisconnect";
+    ManagerEventTypes["VoiceReceiverConnect"] = "voiceReceiverConnect";
+    ManagerEventTypes["VoiceReceiverError"] = "voiceReceiverError";
+    ManagerEventTypes["VoiceReceiverStartSpeaking"] = "voiceReceiverStartSpeaking";
+    ManagerEventTypes["VoiceReceiverEndSpeaking"] = "voiceReceiverEndSpeaking";
 })(ManagerEventTypes || (exports.ManagerEventTypes = ManagerEventTypes = {}));
 /**
  * Track End Reason Enum

package/dist/structures/Manager.js

@@ -47,7 +47,6 @@ class Manager extends events_1.EventEmitter {
         // Initialize structures
         Utils_1.Structure.get("Player").init(this);
         Utils_1.TrackUtils.init(this);
-        Utils_1.AutoPlayUtils.init(this);
         if (options.trackPartial) {
             Utils_1.TrackUtils.setTrackPartial(options.trackPartial);
             delete options.trackPartial;
@@ -77,6 +76,7 @@ class Manager extends events_1.EventEmitter {
             stateStorage: { type: Enums_1.StateStorageType.Collection },
             ...options,
         };
+        Utils_1.AutoPlayUtils.init(this);
         if (this.options.nodes) {
             for (const nodeOptions of this.options.nodes)
                 new Node_1.Node(this, nodeOptions);
@@ -216,7 +216,20 @@ class Manager extends events_1.EventEmitter {
                     tracks = tracks.map(processTrack);
                 }
             }
-            const result = { loadType: res.loadType, tracks, playlist };
+            let result;
+            switch (res.loadType) {
+                case Enums_1.LoadTypes.Playlist:
+                    result = { loadType: res.loadType, tracks, playlist };
+                    break;
+                case Enums_1.LoadTypes.Search:
+                    result = { loadType: res.loadType, tracks };
+                    break;
+                case Enums_1.LoadTypes.Track:
+                    result = { loadType: res.loadType, tracks: [tracks[0]] };
+                    break;
+                default:
+                    return { loadType: res.loadType };
+            }
             this.emit(Enums_1.ManagerEventTypes.Debug, `[MANAGER] Result ${_source} search for: ${_query.query}: ${JSON.stringify(result)}`);
             return result;
         }
@@ -791,6 +804,9 @@ class Manager extends events_1.EventEmitter {
     async handleShutdown() {
         console.warn("\x1b[31m%s\x1b[0m", "MAGMASTREAM WARNING: Shutting down! Please wait, saving active players...");
         try {
+            if (this.options.stateStorage.type === Enums_1.StateStorageType.Collection) {
+                await this.clearAllPlayerStates();
+            }
             const savePromises = Array.from(this.players.keys()).map(async (guildId) => {
                 try {
                     await this.savePlayerState(guildId);
@@ -925,6 +941,7 @@ class Manager extends events_1.EventEmitter {
             guildId: player.guildId,
             data: { voice: { token, endpoint, sessionId } },
         });
+        this.emit(Enums_1.ManagerEventTypes.Debug, `Updated voice server for player ${player.guildId} with token ${token} and endpoint ${endpoint} and sessionId ${sessionId}`);
         return;
     }
     /**
@@ -935,6 +952,7 @@ class Manager extends events_1.EventEmitter {
      * @emits {playerDisconnect} - Emits a player disconnect event if the channel ID is null.
      */
     async handleVoiceStateUpdate(player, update) {
+        this.emit(Enums_1.ManagerEventTypes.Debug, `Updated voice state for player ${player.guildId} with channel id ${update.channel_id} and session id ${update.session_id}`);
         if (update.channel_id) {
             if (player.voiceChannelId !== update.channel_id) {
                 this.emit(Enums_1.ManagerEventTypes.PlayerMove, player, player.voiceChannelId, update.channel_id);
@@ -1052,6 +1070,64 @@ class Manager extends events_1.EventEmitter {
             this.emit(Enums_1.ManagerEventTypes.Debug, `[MANAGER] Error cleaning up inactive players: ${error}`);
         }
     }
+    /**
+     * Clears all player states from the file system.
+     * This is done to prevent stale state files from accumulating on the file system.
+     */
+    async clearAllPlayerStates() {
+        switch (this.options.stateStorage.type) {
+            case Enums_1.StateStorageType.Collection: {
+                const configDir = path_1.default.join(process.cwd(), "magmastream", "dist", "sessionData", "players");
+                try {
+                    // Check if the directory exists, and create it if it doesn't
+                    await promises_1.default.access(configDir).catch(async () => {
+                        await promises_1.default.mkdir(configDir, { recursive: true });
+                        this.emit(Enums_1.ManagerEventTypes.Debug, `[MANAGER] Created directory: ${configDir}`);
+                    });
+                    const files = await promises_1.default.readdir(configDir);
+                    await Promise.all(files.map((file) => promises_1.default.unlink(path_1.default.join(configDir, file)).catch((err) => console.warn(`Failed to delete file ${file}:`, err))));
+                    this.emit(Enums_1.ManagerEventTypes.Debug, `[MANAGER] Cleared all player state files in ${configDir}`);
+                }
+                catch (err) {
+                    console.error("Error clearing player state files:", err);
+                }
+                break;
+            }
+            case Enums_1.StateStorageType.Redis: {
+                const prefix = this.options.stateStorage.redisConfig.prefix?.endsWith(":")
+                    ? this.options.stateStorage.redisConfig.prefix
+                    : this.options.stateStorage.redisConfig.prefix ?? "magmastream:";
+                const pattern = `${prefix}playerstore:*`;
+                try {
+                    const stream = this.redis.scanStream({
+                        match: pattern,
+                        count: 100,
+                    });
+                    let totalDeleted = 0;
+                    stream.on("data", async (keys) => {
+                        if (keys.length) {
+                            const pipeline = this.redis.pipeline();
+                            keys.forEach((key) => pipeline.unlink(key));
+                            await pipeline.exec();
+                            totalDeleted += keys.length;
+                        }
+                    });
+                    stream.on("end", () => {
+                        this.emit(Enums_1.ManagerEventTypes.Debug, `[MANAGER] Cleared ${totalDeleted} Redis player state keys (pattern: ${pattern})`);
+                    });
+                    stream.on("error", (err) => {
+                        console.error("Error during Redis SCAN stream:", err);
+                    });
+                }
+                catch (err) {
+                    console.error("Failed to clear Redis player state keys:", err);
+                }
+                break;
+            }
+            default:
+                console.warn("[MANAGER] No valid stateStorage.type set, skipping state clearing.");
+        }
+    }
     /**
      * Returns the nodes that has the least load.
      * The load is calculated by dividing the lavalink load by the number of cores.

package/dist/structures/Node.js

@@ -31,11 +31,14 @@ class Node {
     rest;
     /** Actual Lavalink information of the node. */
     info = null;
+    /** Whether the node is a NodeLink. */
+    isNodeLink = false;
     reconnectTimeout;
     reconnectAttempts = 1;
     /**
      * Creates an instance of Node.
-     * @param options
+     * @param manager - The manager for the node.
+     * @param options - The options for the node.
      */
     constructor(manager, options) {
         this.manager = manager;
@@ -185,6 +188,7 @@ class Node {
         this.socket = new ws_1.default(`ws${this.options.useSSL ? "s" : ""}://${this.address}/v4/websocket`, { headers });
         this.socket.on("open", this.open.bind(this));
         this.socket.on("close", this.close.bind(this));
+        this.socket.on("upgrade", (request) => this.upgrade(request));
         this.socket.on("message", this.message.bind(this));
         this.socket.on("error", this.error.bind(this));
         const debugInfo = {
@@ -287,6 +291,14 @@ class Node {
             this.reconnectAttempts++;
         }, this.options.retryDelayMs);
     }
+    /**
+     * Upgrades the node to a NodeLink.
+     *
+     * @param request - The incoming message.
+     */
+    upgrade(request) {
+        this.isNodeLink = this.options.isNodeLink ?? Boolean(request.headers.isnodelink) ?? false;
+    }
     /**
      * Handles the "open" event emitted by the WebSocket connection.
      *
@@ -727,13 +739,14 @@ class Node {
      *
      * @param {Track} track - The track to fetch the lyrics for.
      * @param {boolean} [skipTrackSource=false] - Whether to skip using the track's source URL.
-     * @returns {Promise<Lyrics>} A promise that resolves with the lyrics data.
+     * @returns {Promise<Lyrics | NodeLinkGetLyrics>} A promise that resolves with the lyrics data.
      */
     async getLyrics(track, skipTrackSource = false) {
+        if (this.isNodeLink) {
+            return (await this.rest.get(`/v4/lyrics?track=${encodeURIComponent(track.track)}&skipTrackSource=${skipTrackSource}`));
+        }
         if (!this.info.plugins.some((plugin) => plugin.name === "lavalyrics-plugin"))
             throw new RangeError(`there is no lavalyrics-plugin available in the lavalink node: ${this.options.identifier}`);
-        // Make a GET request to the Lavalink node to fetch the lyrics
-        // The request includes the track URL and the skipTrackSource parameter
         return ((await this.rest.get(`/v4/lyrics?track=${encodeURIComponent(track.track)}&skipTrackSource=${skipTrackSource}`)) || {
             source: null,
             provider: null,