magmastream 2.9.0-dev.9 → 2.9.1-dev.0

package/dist/structures/Node.js

@@ -1,76 +1,70 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Node = exports.SponsorBlockSegment = void 0;
+exports.Node = void 0;
 const tslib_1 = require("tslib");
 const Utils_1 = require("./Utils");
-const Manager_1 = require("./Manager");
 const Rest_1 = require("./Rest");
 const nodeCheck_1 = tslib_1.__importDefault(require("../utils/nodeCheck"));
 const ws_1 = tslib_1.__importDefault(require("ws"));
 const fs_1 = tslib_1.__importDefault(require("fs"));
 const path_1 = tslib_1.__importDefault(require("path"));
-var SponsorBlockSegment;
-(function (SponsorBlockSegment) {
-    SponsorBlockSegment["Sponsor"] = "sponsor";
-    SponsorBlockSegment["SelfPromo"] = "selfpromo";
-    SponsorBlockSegment["Interaction"] = "interaction";
-    SponsorBlockSegment["Intro"] = "intro";
-    SponsorBlockSegment["Outro"] = "outro";
-    SponsorBlockSegment["Preview"] = "preview";
-    SponsorBlockSegment["MusicOfftopic"] = "music_offtopic";
-    SponsorBlockSegment["Filler"] = "filler";
-})(SponsorBlockSegment || (exports.SponsorBlockSegment = SponsorBlockSegment = {}));
-const validSponsorBlocks = Object.values(SponsorBlockSegment).map((v) => v.toLowerCase());
-const sessionIdsFilePath = path_1.default.join(process.cwd(), "magmastream", "dist", "sessionData", "sessionIds.json");
-let sessionIdsMap = new Map();
-const configDir = path_1.default.dirname(sessionIdsFilePath);
-if (!fs_1.default.existsSync(configDir)) {
-    fs_1.default.mkdirSync(configDir, { recursive: true });
-}
+const Enums_1 = require("./Enums");
+const validSponsorBlocks = Object.values(Enums_1.SponsorBlockSegment).map((v) => v.toLowerCase());
 class Node {
+    manager;
     options;
     /** The socket for the node. */
     socket = null;
     /** The stats for the node. */
     stats;
     /** The manager for the node */
-    manager;
+    // public manager: Manager;
     /** The node's session ID. */
     sessionId;
     /** The REST instance. */
     rest;
     /** Actual Lavalink information of the node. */
     info = null;
-    static _manager;
+    /** Whether the node is a NodeLink. */
+    isNodeLink = false;
     reconnectTimeout;
     reconnectAttempts = 1;
+    redisPrefix;
+    sessionIdsFilePath;
+    sessionIdsMap = new Map();
     /**
      * Creates an instance of Node.
-     * @param options
+     * @param manager - The manager for the node.
+     * @param options - The options for the node.
      */
-    constructor(options) {
+    constructor(manager, options) {
+        this.manager = manager;
         this.options = options;
         if (!this.manager)
-            this.manager = Utils_1.Structure.get("Node")._manager;
-        if (!this.manager)
-            throw new RangeError("Manager has not been initiated.");
+            throw new RangeError("Manager instance is required.");
         if (this.manager.nodes.has(options.identifier || options.host)) {
             return this.manager.nodes.get(options.identifier || options.host);
         }
         (0, nodeCheck_1.default)(options);
         this.options = {
-            port: 2333,
-            password: "youshallnotpass",
-            useSSL: false,
-            maxRetryAttempts: 30,
-            retryDelayMs: 60000,
-            nodePriority: 0,
             ...options,
+            host: options.host ?? "localhost",
+            port: options.port ?? 2333,
+            password: options.password ?? "youshallnotpass",
+            useSSL: options.useSSL ?? false,
+            identifier: options.identifier ?? options.host,
+            maxRetryAttempts: options.maxRetryAttempts ?? 30,
+            retryDelayMs: options.retryDelayMs ?? 60000,
+            enableSessionResumeOption: options.enableSessionResumeOption ?? false,
+            sessionTimeoutSeconds: options.sessionTimeoutSeconds ?? 60,
+            apiRequestTimeoutMs: options.apiRequestTimeoutMs ?? 10000,
+            nodePriority: options.nodePriority ?? 0,
+            isNodeLink: options.isNodeLink ?? false,
+            isBackup: options.isBackup ?? false,
         };
         if (this.options.useSSL) {
             this.options.port = 443;
         }
-        this.options.identifier = options.identifier || options.host;
         this.stats = {
             players: 0,
             playingPlayers: 0,
@@ -93,38 +87,48 @@ class Node {
             },
         };
         this.manager.nodes.set(this.options.identifier, this);
-        this.manager.emit(Manager_1.ManagerEventTypes.NodeCreate, this);
+        this.manager.emit(Enums_1.ManagerEventTypes.NodeCreate, this);
         this.rest = new Rest_1.Rest(this, this.manager);
-        this.createSessionIdsFile();
-        this.loadSessionIds();
-        // Create README file to inform the user about the magmastream folder
-        this.createReadmeFile();
+        switch (this.manager.options.stateStorage.type) {
+            case Enums_1.StateStorageType.Memory:
+            case Enums_1.StateStorageType.JSON:
+                this.sessionIdsFilePath = path_1.default.join(process.cwd(), "magmastream", "sessionData", "sessionIds.json");
+                const configDir = path_1.default.dirname(this.sessionIdsFilePath);
+                if (!fs_1.default.existsSync(configDir)) {
+                    fs_1.default.mkdirSync(configDir, { recursive: true });
+                }
+                this.createSessionIdsFile();
+                this.createReadmeFile();
+                break;
+            case Enums_1.StateStorageType.Redis:
+                this.redisPrefix = this.manager.options.stateStorage.redisConfig.prefix?.endsWith(":")
+                    ? this.manager.options.stateStorage.redisConfig.prefix
+                    : this.manager.options.stateStorage.redisConfig.prefix ?? "magmastream:";
+                break;
+        }
     }
-    /** Returns if connected to the Node. */
+    /**
+     * Checks if the Node is currently connected.
+     * This method returns true if the Node has an active WebSocket connection, indicating it is ready to receive and process commands.
+     */
     get connected() {
         if (!this.socket)
             return false;
         return this.socket.readyState === ws_1.default.OPEN;
     }
-    /** Returns the address for this node. */
+    /** Returns the full address for this node, including the host and port. */
     get address() {
         return `${this.options.host}:${this.options.port}`;
     }
-    /** @hidden */
-    static init(manager) {
-        this._manager = manager;
-    }
     /**
      * Creates the sessionIds.json file if it doesn't exist. This file is used to
      * store the session IDs for each node. The session IDs are used to identify
      * the node when resuming a session.
      */
     createSessionIdsFile() {
-        // If the sessionIds.json file does not exist, create it
-        if (!fs_1.default.existsSync(sessionIdsFilePath)) {
-            this.manager.emit(Manager_1.ManagerEventTypes.Debug, `[NODE] Creating sessionId file at: ${sessionIdsFilePath}`);
-            // Create the file with an empty object as the content
-            fs_1.default.writeFileSync(sessionIdsFilePath, JSON.stringify({}), "utf-8");
+        if (!fs_1.default.existsSync(this.sessionIdsFilePath)) {
+            this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[NODE] Creating sessionId file at: ${this.sessionIdsFilePath}`);
+            fs_1.default.writeFileSync(this.sessionIdsFilePath, JSON.stringify({}), "utf-8");
         }
     }
     /**
@@ -135,21 +139,49 @@ class Node {
      * of the node identifier and cluster ID. This allows multiple clusters to
      * be used with the same node identifier.
      */
-    loadSessionIds() {
-        // Check if the sessionIds.json file exists
-        if (fs_1.default.existsSync(sessionIdsFilePath)) {
-            // Emit a debug event indicating that session IDs are being loaded
-            this.manager.emit(Manager_1.ManagerEventTypes.Debug, `[NODE] Loading sessionIds from file: ${sessionIdsFilePath}`);
-            // Read the content of the sessionIds.json file as a string
-            const sessionIdsData = fs_1.default.readFileSync(sessionIdsFilePath, "utf-8");
-            // Parse the JSON string into an object and convert it into a Map
-            sessionIdsMap = new Map(Object.entries(JSON.parse(sessionIdsData)));
-            // Check if the session IDs Map contains the session ID for this node
-            const compositeKey = `${this.options.identifier}::${this.manager.options.clusterId}`;
-            if (sessionIdsMap.has(compositeKey)) {
-                // Set the session ID on this node if it exists in the session IDs Map
-                this.sessionId = sessionIdsMap.get(compositeKey);
+    async loadSessionIds() {
+        switch (this.manager.options.stateStorage.type) {
+            case Enums_1.StateStorageType.Memory:
+            case Enums_1.StateStorageType.JSON: {
+                if (fs_1.default.existsSync(this.sessionIdsFilePath)) {
+                    this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[NODE] Loading sessionIds from file: ${this.sessionIdsFilePath}`);
+                    const sessionIdsData = fs_1.default.readFileSync(this.sessionIdsFilePath, "utf-8");
+                    this.sessionIdsMap = new Map(Object.entries(JSON.parse(sessionIdsData)));
+                    const compositeKey = `${this.options.identifier}::${this.manager.options.clusterId}`;
+                    if (this.sessionIdsMap.has(compositeKey)) {
+                        this.sessionId = this.sessionIdsMap.get(compositeKey);
+                    }
+                }
+                break;
             }
+            case Enums_1.StateStorageType.Redis:
+                const key = `${this.redisPrefix}node:sessionIds`;
+                this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[NODE] Loading sessionIds from Redis key: ${key}`);
+                const currentRaw = await this.manager.redis.get(key);
+                if (currentRaw) {
+                    try {
+                        const sessionIds = JSON.parse(currentRaw);
+                        if (typeof sessionIds !== "object" || Array.isArray(sessionIds)) {
+                            throw new Error("[NODE] loadSessionIds invalid data type from Redis.");
+                        }
+                        this.sessionIdsMap = new Map(Object.entries(sessionIds));
+                        const compositeKey = `${this.options.identifier}::${this.manager.options.clusterId}`;
+                        if (this.sessionIdsMap.has(compositeKey)) {
+                            this.sessionId = this.sessionIdsMap.get(compositeKey) || null;
+                            this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[NODE] Restored sessionId for ${compositeKey}: ${this.sessionId}`);
+                        }
+                    }
+                    catch (err) {
+                        this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[NODE] Failed to parse Redis sessionIds: ${err.message}`);
+                        this.sessionIdsMap = new Map();
+                    }
+                }
+                else {
+                    this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[NODE] No sessionIds found in Redis — creating new key.`);
+                    await this.manager.redis.set(key, JSON.stringify({}));
+                    this.sessionIdsMap = new Map();
+                }
+                break;
         }
     }
     /**
@@ -163,15 +195,74 @@ class Node {
      * of the node identifier and cluster ID. This allows multiple clusters to
      * be used with the same node identifier.
      */
-    updateSessionId() {
-        // Emit a debug event indicating that the session IDs are being updated
-        this.manager.emit(Manager_1.ManagerEventTypes.Debug, `[NODE] Updating sessionIds to file: ${sessionIdsFilePath}`);
-        // Create a composite key using identifier and clusterId
-        const compositeKey = `${this.options.identifier}::${this.manager.options.clusterId}`;
-        // Update the session IDs Map with the new session ID
-        sessionIdsMap.set(compositeKey, this.sessionId);
-        // Write the updated session IDs Map to the sessionIds.json file
-        fs_1.default.writeFileSync(sessionIdsFilePath, JSON.stringify(Object.fromEntries(sessionIdsMap)));
+    async updateSessionId() {
+        switch (this.manager.options.stateStorage.type) {
+            case Enums_1.StateStorageType.Memory:
+            case Enums_1.StateStorageType.JSON: {
+                this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[NODE] Updating sessionIds to file: ${this.sessionIdsFilePath}`);
+                const compositeKey = `${this.options.identifier}::${this.manager.options.clusterId}`;
+                const filePath = this.sessionIdsFilePath;
+                let updated = false;
+                let retries = 3;
+                while (!updated && retries > 0) {
+                    try {
+                        let fileData = {};
+                        if (fs_1.default.existsSync(filePath)) {
+                            try {
+                                const raw = fs_1.default.readFileSync(filePath, "utf-8");
+                                fileData = raw.trim() ? JSON.parse(raw) : {};
+                            }
+                            catch (err) {
+                                this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[NODE] Failed to read/parse sessionIds.json: ${err.message}`);
+                                fileData = {};
+                            }
+                        }
+                        fileData[compositeKey] = this.sessionId;
+                        const tmpPath = `${filePath}.tmp`;
+                        fs_1.default.writeFileSync(tmpPath, JSON.stringify(fileData, null, 2), "utf-8");
+                        fs_1.default.renameSync(tmpPath, filePath);
+                        this.sessionIdsMap = new Map(Object.entries(fileData));
+                        updated = true;
+                    }
+                    catch (err) {
+                        retries--;
+                        if (retries === 0) {
+                            this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[NODE] Failed to update sessionIds after retries: ${err.message}`);
+                            throw err;
+                        }
+                        await new Promise((r) => setTimeout(r, 50));
+                    }
+                }
+                break;
+            }
+            case Enums_1.StateStorageType.Redis: {
+                const key = `${this.redisPrefix}node:sessionIds`;
+                const compositeKey = `${this.options.identifier}::${this.manager.options.clusterId}`;
+                this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[NODE] Updating sessionIds in Redis key: ${key}`);
+                const currentRaw = await this.manager.redis.get(key);
+                let sessionIds;
+                if (currentRaw) {
+                    try {
+                        sessionIds = JSON.parse(currentRaw);
+                        if (typeof sessionIds !== "object" || Array.isArray(sessionIds)) {
+                            throw new Error("Invalid data type in Redis");
+                        }
+                    }
+                    catch (err) {
+                        this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[NODE] Corrupted Redis sessionIds, reinitializing: ${err.message}`);
+                        sessionIds = {};
+                    }
+                }
+                else {
+                    this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[NODE] Redis key not found — creating new sessionIds key.`);
+                    sessionIds = {};
+                }
+                sessionIds[compositeKey] = this.sessionId;
+                this.sessionIdsMap = new Map(Object.entries(sessionIds));
+                await this.manager.redis.set(key, JSON.stringify(sessionIds));
+                break;
+            }
+        }
     }
     /**
      * Connects to the Node.
@@ -182,7 +273,8 @@ class Node {
      * If the node has no session ID but the `enableSessionResumeOption` option is true, it will use the session ID
      * stored in the sessionIds.json file if it exists.
      */
-    connect() {
+    async connect() {
+        await this.loadSessionIds();
         if (this.connected)
             return;
         const headers = {
@@ -194,13 +286,14 @@ class Node {
         if (this.sessionId) {
             headers["Session-Id"] = this.sessionId;
         }
-        else if (this.options.enableSessionResumeOption && sessionIdsMap.has(compositeKey)) {
-            this.sessionId = sessionIdsMap.get(compositeKey) || null;
+        else if (this.options.enableSessionResumeOption && this.sessionIdsMap.has(compositeKey)) {
+            this.sessionId = this.sessionIdsMap.get(compositeKey) || null;
             headers["Session-Id"] = this.sessionId;
         }
         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 = {
@@ -214,7 +307,7 @@ class Node {
                 identifier: this.options.identifier,
             },
         };
-        this.manager.emit(Manager_1.ManagerEventTypes.Debug, `[NODE] Connecting ${JSON.stringify(debugInfo)}`);
+        this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[NODE] Connecting ${JSON.stringify(debugInfo)}`);
     }
     /**
      * Destroys the node and cleans up associated resources.
@@ -229,33 +322,27 @@ class Node {
     async destroy() {
         if (!this.connected)
             return;
-        // Emit a debug event indicating that the node is being destroyed
         const debugInfo = {
             connected: this.connected,
             identifier: this.options.identifier,
             address: this.address,
             sessionId: this.sessionId,
-            playerCount: (await this.manager.players.filter((p) => p.node == this)).size,
+            playerCount: this.manager.players.filter((p) => p.node == this).size,
         };
-        this.manager.emit(Manager_1.ManagerEventTypes.Debug, `[NODE] Destroying node: ${JSON.stringify(debugInfo)}`);
+        this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[NODE] Destroying node: ${JSON.stringify(debugInfo)}`);
         // Automove all players connected to that node
-        const players = await this.manager.players.filter((p) => p.node == this);
+        const players = this.manager.players.filter((p) => p.node == this);
         if (players.size) {
-            players.forEach(async (player) => {
+            for (const player of players.values()) {
                 await player.autoMoveNode();
-            });
+            }
         }
-        // Close the WebSocket connection
         this.socket.close(1000, "destroy");
-        // Remove all event listeners on the WebSocket
         this.socket.removeAllListeners();
-        // Clear the reconnect timeout
         this.reconnectAttempts = 1;
         clearTimeout(this.reconnectTimeout);
-        // Emit a "nodeDestroy" event with the node as the argument
-        this.manager.emit(Manager_1.ManagerEventTypes.NodeDestroy, this);
-        // Destroy the node from the manager
-        await this.manager.destroyNode(this.options.identifier);
+        this.manager.emit(Enums_1.ManagerEventTypes.NodeDestroy, this);
+        this.manager.nodes.delete(this.options.identifier);
     }
     /**
      * Attempts to reconnect to the node if the connection is lost.
@@ -274,7 +361,6 @@ class Node {
      * @emits {nodeDestroy} - Emits a nodeDestroy event if the maximum number of retry attempts is reached.
      */
     async reconnect() {
-        // Collect debug information regarding the current state of the node
         const debugInfo = {
             identifier: this.options.identifier,
             connected: this.connected,
@@ -282,27 +368,28 @@ class Node {
             maxRetryAttempts: this.options.maxRetryAttempts,
             retryDelayMs: this.options.retryDelayMs,
         };
-        // Emit a debug event indicating the node is attempting to reconnect
-        this.manager.emit(Manager_1.ManagerEventTypes.Debug, `[NODE] Reconnecting node: ${JSON.stringify(debugInfo)}`);
-        // Schedule the reconnection attempt after the specified retry delay
+        this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[NODE] Reconnecting node: ${JSON.stringify(debugInfo)}`);
         this.reconnectTimeout = setTimeout(async () => {
-            // Check if the maximum number of retry attempts has been reached
             if (this.reconnectAttempts >= this.options.maxRetryAttempts) {
-                // Emit an error event and destroy the node if retries are exhausted
                 const error = new Error(`Unable to connect after ${this.options.maxRetryAttempts} attempts.`);
-                this.manager.emit(Manager_1.ManagerEventTypes.NodeError, this, error);
+                this.manager.emit(Enums_1.ManagerEventTypes.NodeError, this, error);
                 return await this.destroy();
             }
-            // Remove all listeners from the current WebSocket and reset it
             this.socket?.removeAllListeners();
             this.socket = null;
-            // Emit a nodeReconnect event and attempt to connect again
-            this.manager.emit(Manager_1.ManagerEventTypes.NodeReconnect, this);
+            this.manager.emit(Enums_1.ManagerEventTypes.NodeReconnect, this);
             this.connect();
-            // Increment the reconnect attempts counter
             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.
      *
@@ -312,18 +399,18 @@ class Node {
      * with the node as the argument.
      */
     open() {
-        // Clear any existing reconnect timeouts
         if (this.reconnectTimeout)
             clearTimeout(this.reconnectTimeout);
-        // Collect debug information regarding the current state of the node
         const debugInfo = {
             identifier: this.options.identifier,
             connected: this.connected,
         };
-        // Emit a debug event indicating the node is connected
-        this.manager.emit(Manager_1.ManagerEventTypes.Debug, `[NODE] Connected node: ${JSON.stringify(debugInfo)}`);
-        // Emit a "nodeConnect" event with the node as the argument
-        this.manager.emit(Manager_1.ManagerEventTypes.NodeConnect, this);
+        this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[NODE] Connected node: ${JSON.stringify(debugInfo)}`);
+        this.manager.emit(Enums_1.ManagerEventTypes.NodeConnect, this);
+        const playersOnBackupNode = this.manager.players.filter((p) => p.node.options.isBackup);
+        if (playersOnBackupNode.size) {
+            Promise.all(Array.from(playersOnBackupNode.values(), (player) => player.moveNode(this.options.identifier)));
+        }
     }
     /**
      * Handles the "close" event emitted by the WebSocket connection.
@@ -344,18 +431,21 @@ class Node {
             code,
             reason,
         };
-        // Emit a "nodeDisconnect" event with the node and the close event as arguments
-        this.manager.emit(Manager_1.ManagerEventTypes.NodeDisconnect, this, { code, reason });
-        // Emit a debug event indicating the node is disconnected
-        this.manager.emit(Manager_1.ManagerEventTypes.Debug, `[NODE] Disconnected node: ${JSON.stringify(debugInfo)}`);
-        // Try moving all players connected to that node to a useable one
+        this.manager.emit(Enums_1.ManagerEventTypes.NodeDisconnect, this, { code, reason });
+        this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[NODE] Disconnected node: ${JSON.stringify(debugInfo)}`);
         if (this.manager.useableNode) {
-            const players = await this.manager.players.filter((p) => p.node.options.identifier == this.options.identifier);
+            const players = this.manager.players.filter((p) => p.node.options.identifier == this.options.identifier);
             if (players.size) {
                 await Promise.all(Array.from(players.values(), (player) => player.autoMoveNode()));
             }
         }
-        // If the close event was not initiated by the user, attempt to reconnect
+        else {
+            const backUpNodes = this.manager.nodes.filter((node) => node.options.isBackup && node.connected);
+            const backupNode = backUpNodes.first();
+            if (backupNode) {
+                await Promise.all(Array.from(this.manager.players.values(), (player) => player.moveNode(backupNode.options.identifier)));
+            }
+        }
         if (code !== 1000 || reason !== "destroy")
             await this.reconnect();
     }
@@ -370,15 +460,12 @@ class Node {
     error(error) {
         if (!error)
             return;
-        // Collect debug information regarding the error
         const debugInfo = {
             identifier: this.options.identifier,
             error: error.message,
         };
-        // Emit a debug event indicating the error on the node
-        this.manager.emit(Manager_1.ManagerEventTypes.Debug, `[NODE] Error on node: ${JSON.stringify(debugInfo)}`);
-        // Emit a "nodeError" event with the node and the error as arguments
-        this.manager.emit(Manager_1.ManagerEventTypes.NodeError, this, error);
+        this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[NODE] Error on node: ${JSON.stringify(debugInfo)}`);
+        this.manager.emit(Enums_1.ManagerEventTypes.NodeError, this, error);
     }
     /**
      * Handles incoming messages from the Lavalink WebSocket connection.
@@ -397,7 +484,7 @@ class Node {
         const payload = JSON.parse(d.toString());
         if (!payload.op)
             return;
-        this.manager.emit(Manager_1.ManagerEventTypes.NodeRaw, payload);
+        this.manager.emit(Enums_1.ManagerEventTypes.NodeRaw, payload);
         let player;
         switch (payload.op) {
             case "stats":
@@ -405,7 +492,7 @@ class Node {
                 this.stats = { ...payload };
                 break;
             case "playerUpdate":
-                player = await this.manager.players.get(payload.guildId);
+                player = this.manager.players.get(payload.guildId);
                 if (player && player.node.options.identifier !== this.options.identifier) {
                     return;
                 }
@@ -413,33 +500,31 @@ class Node {
                     player.position = payload.state.position || 0;
                 break;
             case "event":
-                player = await this.manager.players.get(payload.guildId);
+                player = this.manager.players.get(payload.guildId);
                 if (player && player.node.options.identifier !== this.options.identifier) {
                     return;
                 }
-                this.manager.emit(Manager_1.ManagerEventTypes.Debug, `[NODE] Node message: ${JSON.stringify(payload)}`);
+                this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[NODE] Node message: ${JSON.stringify(payload)}`);
                 await this.handleEvent(payload);
                 break;
             case "ready":
-                this.manager.emit(Manager_1.ManagerEventTypes.Debug, `[NODE] Node message: ${JSON.stringify(payload)}`);
+                this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[NODE] Node message: ${JSON.stringify(payload)}`);
                 this.rest.setSessionId(payload.sessionId);
                 this.sessionId = payload.sessionId;
-                this.updateSessionId(); // Call to update session ID
+                await this.updateSessionId();
                 this.info = await this.fetchInfo();
-                // Log if the session was resumed successfully
                 if (payload.resumed) {
-                    // Load player states from the JSON file
                     await this.manager.loadPlayerStates(this.options.identifier);
                 }
                 if (this.options.enableSessionResumeOption) {
                     await this.rest.patch(`/v4/sessions/${this.sessionId}`, {
                         resuming: this.options.enableSessionResumeOption,
-                        timeout: this.options.sessionTimeoutMs,
+                        timeout: this.options.sessionTimeoutSeconds,
                     });
                 }
                 break;
             default:
-                this.manager.emit(Manager_1.ManagerEventTypes.NodeError, this, new Error(`Unexpected op "${payload.op}" with data: ${payload.message}`));
+                this.manager.emit(Enums_1.ManagerEventTypes.NodeError, this, new Error(`Unexpected op "${payload.op}" with data: ${payload.message}`));
                 return;
         }
     }
@@ -452,7 +537,7 @@ class Node {
     async handleEvent(payload) {
         if (!payload.guildId)
             return;
-        const player = await this.manager.players.get(payload.guildId);
+        const player = this.manager.players.get(payload.guildId);
         if (!player)
             return;
         const track = await player.queue.getCurrent();
@@ -489,9 +574,18 @@ class Node {
             case "ChapterStarted":
                 this.sponsorBlockChapterStarted(player, track, payload);
                 break;
+            case "LyricsFoundEvent":
+                this.lyricsFound(player, track, payload);
+                break;
+            case "LyricsNotFoundEvent":
+                this.lyricsNotFound(player, track, payload);
+                break;
+            case "LyricsLineEvent":
+                this.lyricsLine(player, track, payload);
+                break;
             default:
                 error = new Error(`Node#event unknown event '${type}'.`);
-                this.manager.emit(Manager_1.ManagerEventTypes.NodeError, this, error);
+                this.manager.emit(Enums_1.ManagerEventTypes.NodeError, this, error);
                 break;
         }
     }
@@ -506,22 +600,24 @@ class Node {
         const oldPlayer = player;
         player.playing = true;
         player.paused = false;
-        this.manager.emit(Manager_1.ManagerEventTypes.TrackStart, player, track, payload);
+        this.manager.emit(Enums_1.ManagerEventTypes.TrackStart, player, track, payload);
         const botUser = player.get("Internal_BotUser");
         if (botUser && botUser.id === track.requester.id) {
-            this.manager.emit(Manager_1.ManagerEventTypes.PlayerStateUpdate, oldPlayer, player, {
-                changeType: Manager_1.PlayerStateEventTypes.TrackChange,
+            this.manager.emit(Enums_1.ManagerEventTypes.PlayerStateUpdate, oldPlayer, player, {
+                changeType: Enums_1.PlayerStateEventTypes.TrackChange,
                 details: {
-                    changeType: "autoPlay",
+                    type: "track",
+                    action: "autoPlay",
                     track: track,
                 },
             });
             return;
         }
-        this.manager.emit(Manager_1.ManagerEventTypes.PlayerStateUpdate, oldPlayer, player, {
-            changeType: Manager_1.PlayerStateEventTypes.TrackChange,
+        this.manager.emit(Enums_1.ManagerEventTypes.PlayerStateUpdate, oldPlayer, player, {
+            changeType: Enums_1.PlayerStateEventTypes.TrackChange,
             details: {
-                changeType: "start",
+                type: "track",
+                action: "start",
                 track: track,
             },
         });
@@ -539,26 +635,23 @@ class Node {
         const previous = await player.queue.getPrevious();
         const current = await player.queue.getCurrent();
         if (!skipFlag && (previous.length === 0 || (previous[0] && previous[0].track !== current?.track))) {
-            // Store the current track in the previous tracks queue
-            await player.queue.addPrevious(await player.queue.getCurrent());
-            // Limit the previous tracks queue to maxPreviousTracks
-            if ((await player.queue.getPrevious()).length > this.manager.options.maxPreviousTracks) {
-                (await player.queue.getPrevious()).shift();
+            await player.queue.addPrevious(current);
+            const updated = await player.queue.getPrevious();
+            if (updated.length > this.manager.options.maxPreviousTracks) {
+                const trimmed = updated.slice(0, this.manager.options.maxPreviousTracks);
+                await player.queue.setPrevious(trimmed);
             }
         }
+        player.set("skipFlag", false);
         const oldPlayer = player;
-        // Handle track end events
         switch (reason) {
-            case Utils_1.TrackEndReasonTypes.LoadFailed:
-            case Utils_1.TrackEndReasonTypes.Cleanup:
-                // Handle the case when a track failed to load or was cleaned up
+            case Enums_1.TrackEndReasonTypes.LoadFailed:
+            case Enums_1.TrackEndReasonTypes.Cleanup:
                 await this.handleFailedTrack(player, track, payload);
                 break;
-            case Utils_1.TrackEndReasonTypes.Replaced:
-                // Handle the case when a track was replaced
+            case Enums_1.TrackEndReasonTypes.Replaced:
                 break;
-            case Utils_1.TrackEndReasonTypes.Stopped:
-                // If the track was forcibly replaced
+            case Enums_1.TrackEndReasonTypes.Stopped:
                 if (await player.queue.size()) {
                     await this.playNextTrack(player, track, payload);
                 }
@@ -566,7 +659,7 @@ class Node {
                     await this.queueEnd(player, track, payload);
                 }
                 break;
-            case Utils_1.TrackEndReasonTypes.Finished:
+            case Enums_1.TrackEndReasonTypes.Finished:
                 // If the track ended and it's set to repeat (track or queue)
                 if (track && (player.trackRepeat || player.queueRepeat)) {
                     await this.handleRepeatedTrack(player, track, payload);
@@ -581,13 +674,14 @@ class Node {
                 }
                 break;
             default:
-                this.manager.emit(Manager_1.ManagerEventTypes.NodeError, this, new Error(`Unexpected track end reason "${reason}"`));
+                this.manager.emit(Enums_1.ManagerEventTypes.NodeError, this, new Error(`Unexpected track end reason "${reason}"`));
                 break;
         }
-        this.manager.emit(Manager_1.ManagerEventTypes.PlayerStateUpdate, oldPlayer, player, {
-            changeType: Manager_1.PlayerStateEventTypes.TrackChange,
+        this.manager.emit(Enums_1.ManagerEventTypes.PlayerStateUpdate, oldPlayer, player, {
+            changeType: Enums_1.PlayerStateEventTypes.TrackChange,
             details: {
-                changeType: "end",
+                type: "track",
+                action: "end",
                 track: track,
             },
         });
@@ -606,13 +700,20 @@ class Node {
         // If autoplay is not enabled or all attempts have failed, early exit
         if (!player.isAutoplay || attempt > player.autoplayTries || !(await player.queue.getPrevious()).length)
             return false;
-        const lastTrack = await player.queue.getPrevious()[(await player.queue.getPrevious()).length - 1];
+        const PreviousQueue = await player.queue.getPrevious();
+        const lastTrack = PreviousQueue?.at(-1);
         lastTrack.requester = player.get("Internal_BotUser");
         if (!lastTrack)
             return false;
         const tracks = await Utils_1.AutoPlayUtils.getRecommendedTracks(lastTrack);
-        if (tracks.length) {
-            await player.queue.add(tracks[0]);
+        const normalize = (str) => str
+            .toLowerCase()
+            .replace(/\s+/g, "")
+            .replace(/[^a-z0-9]/g, "");
+        const filteredTracks = tracks.filter((track) => track.identifier !== lastTrack.identifier && track.uri !== lastTrack.uri && normalize(track.title) !== normalize(lastTrack.title));
+        if (filteredTracks.length) {
+            const randomTrack = filteredTracks[Math.floor(Math.random() * filteredTracks.length)];
+            await player.queue.add(randomTrack);
             await player.play();
             return true;
         }
@@ -638,7 +739,7 @@ class Node {
             await this.queueEnd(player, track, payload);
             return;
         }
-        this.manager.emit(Manager_1.ManagerEventTypes.TrackEnd, player, track, payload);
+        this.manager.emit(Enums_1.ManagerEventTypes.TrackEnd, player, track, payload);
         if (this.manager.options.playNextOnEnd)
             await player.play();
     }
@@ -671,10 +772,8 @@ class Node {
         }
         // Move to the next track
         await queue.setCurrent(await queue.dequeue());
-        // Emit track end event
-        this.manager.emit(Manager_1.ManagerEventTypes.TrackEnd, player, track, payload);
-        // If the track was stopped manually and no more tracks exist, end the queue
-        if (payload.reason === Utils_1.TrackEndReasonTypes.Stopped) {
+        this.manager.emit(Enums_1.ManagerEventTypes.TrackEnd, player, track, payload);
+        if (payload.reason === Enums_1.TrackEndReasonTypes.Stopped) {
             const next = await queue.dequeue();
             await queue.setCurrent(next ?? null);
             if (!next) {
@@ -682,7 +781,6 @@ class Node {
                 return;
             }
         }
-        // If autoplay is enabled, play the next track
         if (playNextOnEnd)
             await player.play();
     }
@@ -700,9 +798,7 @@ class Node {
     async playNextTrack(player, track, payload) {
         // Shift the queue to set the next track as current
         await player.queue.setCurrent(await player.queue.dequeue());
-        // Emit the track end event
-        this.manager.emit(Manager_1.ManagerEventTypes.TrackEnd, player, track, payload);
-        // If autoplay is enabled, play the next track
+        this.manager.emit(Enums_1.ManagerEventTypes.TrackEnd, player, track, payload);
         if (this.manager.options.playNextOnEnd)
             await player.play();
     }
@@ -719,7 +815,7 @@ class Node {
         await player.queue.setCurrent(null);
         if (!player.isAutoplay) {
             player.playing = false;
-            this.manager.emit(Manager_1.ManagerEventTypes.QueueEnd, player, track, payload);
+            this.manager.emit(Enums_1.ManagerEventTypes.QueueEnd, player, track, payload);
             return;
         }
         let attempt = 1;
@@ -730,24 +826,34 @@ class Node {
                 return;
             attempt++;
         }
-        // If all attempts fail, reset the player state and emit queueEnd
         player.playing = false;
-        this.manager.emit(Manager_1.ManagerEventTypes.QueueEnd, player, track, payload);
+        this.manager.emit(Enums_1.ManagerEventTypes.QueueEnd, player, track, payload);
     }
     /**
      * Fetches the lyrics of a track from the Lavalink node.
-     * This method uses the `lavalyrics-plugin` to fetch the lyrics.
-     * If the plugin is not available, it will throw a RangeError.
+     *
+     * If the node is a NodeLink, it will use the `NodeLinkGetLyrics` method to fetch the lyrics.
+     *
+     * Requires the `lavalyrics-plugin` to be present in the Lavalink node.
+     * Requires the `lavasrc-plugin` or `java-lyrics-plugin` to be present in the Lavalink 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.
+     * @param {string} [language="en"] - The language of the lyrics.
+     * @returns {Promise<Lyrics | NodeLinkGetLyrics>} A promise that resolves with the lyrics data.
      */
-    async getLyrics(track, skipTrackSource = false) {
-        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
+    async getLyrics(track, skipTrackSource = false, language) {
+        if (!this.connected)
+            throw new RangeError(`The node is not connected to the lavalink server: ${this.options.identifier}`);
+        if (this.isNodeLink) {
+            return (await this.rest.get(`/v4/loadlyrics?encodedTrack=${encodeURIComponent(track.track)}${language ? `&language=${language}` : ""}`));
+        }
+        if (!this.info.plugins.some((plugin) => plugin.name === "lavalyrics-plugin")) {
+            throw new RangeError(`The plugin "lavalyrics-plugin" must be present in the lavalink node: ${this.options.identifier}`);
+        }
+        if (!this.info.plugins.some((plugin) => plugin.name === "lavasrc-plugin" || plugin.name === "java-lyrics-plugin")) {
+            throw new RangeError(`One of the following plugins must also be present in the lavalink node: "lavasrc-plugin" or "java-lyrics-plugin" (Node: ${this.options.identifier})`);
+        }
         return ((await this.rest.get(`/v4/lyrics?track=${encodeURIComponent(track.track)}&skipTrackSource=${skipTrackSource}`)) || {
             source: null,
             provider: null,
@@ -756,6 +862,42 @@ class Node {
             plugin: [],
         });
     }
+    /**
+     * Subscribes to lyrics for a player.
+     * @param {string} guildId - The ID of the guild to subscribe to lyrics for.
+     * @param {boolean} [skipTrackSource=false] - Whether to skip using the track's source URL.
+     * @returns {Promise<unknown>} A promise that resolves when the subscription is complete.
+     * @throws {RangeError} If the node is not connected to the lavalink server or if the java-lyrics-plugin is not available.
+     */
+    async lyricsSubscribe(guildId, skipTrackSource = false) {
+        if (!this.connected)
+            throw new RangeError(`The node is not connected to the lavalink server: ${this.options.identifier}`);
+        if (this.isNodeLink)
+            throw new RangeError(`The node is a node link: ${this.options.identifier}`);
+        if (!this.info.plugins.some((plugin) => plugin.name === "lavalyrics-plugin")) {
+            throw new RangeError(`The plugin "lavalyrics-plugin" must be present in the lavalink node: ${this.options.identifier}`);
+        }
+        if (!this.info.plugins.some((plugin) => plugin.name === "lavasrc-plugin" || plugin.name === "java-lyrics-plugin")) {
+            throw new RangeError(`One of the following plugins must also be present in the lavalink node: "lavasrc-plugin" or "java-lyrics-plugin" (Node: ${this.options.identifier})`);
+        }
+        return await this.rest.post(`/v4/sessions/${this.sessionId}/players/${guildId}/lyrics/subscribe?skipTrackSource=${skipTrackSource}`, {});
+    }
+    /**
+     * Unsubscribes from lyrics for a player.
+     * @param {string} guildId - The ID of the guild to unsubscribe from lyrics for.
+     * @returns {Promise<unknown>} A promise that resolves when the unsubscription is complete.
+     * @throws {RangeError} If the node is not connected to the lavalink server or if the java-lyrics-plugin is not available.
+     */
+    async lyricsUnsubscribe(guildId) {
+        if (!this.connected)
+            throw new RangeError(`The node is not connected to the lavalink server: ${this.options.identifier}`);
+        if (this.isNodeLink)
+            throw new RangeError(`The node is a node link: ${this.options.identifier}`);
+        if (!this.info.plugins.some((plugin) => plugin.name === "java-lyrics-plugin")) {
+            throw new RangeError(`there is no java-lyrics-plugin available in the lavalink node: ${this.options.identifier}`);
+        }
+        return await this.rest.delete(`/v4/sessions/${this.sessionId}/players/${guildId}/lyrics/subscribe`);
+    }
     /**
      * Handles the event when a track becomes stuck during playback.
      * Stops the current track and emits a `trackStuck` event.
@@ -768,7 +910,7 @@ class Node {
      */
     async trackStuck(player, track, payload) {
         await player.stop();
-        this.manager.emit(Manager_1.ManagerEventTypes.TrackStuck, player, track, payload);
+        this.manager.emit(Enums_1.ManagerEventTypes.TrackStuck, player, track, payload);
     }
     /**
      * Handles the event when a track has an error during playback.
@@ -782,7 +924,7 @@ class Node {
      */
     async trackError(player, track, payload) {
         await player.stop();
-        this.manager.emit(Manager_1.ManagerEventTypes.TrackError, player, track, payload);
+        this.manager.emit(Enums_1.ManagerEventTypes.TrackError, player, track, payload);
     }
     /**
      * Emitted when the WebSocket connection for a player closes.
@@ -791,8 +933,8 @@ class Node {
      * @param {WebSocketClosedEvent} payload - The event payload containing additional data about the WebSocket close event.
      */
     socketClosed(player, payload) {
-        this.manager.emit(Manager_1.ManagerEventTypes.SocketClosed, player, payload);
-        this.manager.emit(Manager_1.ManagerEventTypes.Debug, `[NODE] Websocket closed for player: ${player.guildId} with payload: ${JSON.stringify(payload)}`);
+        this.manager.emit(Enums_1.ManagerEventTypes.SocketClosed, player, payload);
+        this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[NODE] Websocket closed for player: ${player.guildId} with payload: ${JSON.stringify(payload)}`);
     }
     /**
      * Emitted when the segments for a track are loaded.
@@ -802,7 +944,7 @@ class Node {
      * @param {SponsorBlockSegmentsLoaded} payload - The event payload containing additional data about the segments loaded event.
      */
     sponsorBlockSegmentLoaded(player, track, payload) {
-        return this.manager.emit(Manager_1.ManagerEventTypes.SegmentsLoaded, player, track, payload);
+        return this.manager.emit(Enums_1.ManagerEventTypes.SegmentsLoaded, player, track, payload);
     }
     /**
      * Emitted when a segment of a track is skipped using the sponsorblock plugin.
@@ -812,7 +954,7 @@ class Node {
      * @param {SponsorBlockSegmentSkipped} payload - The event payload containing additional data about the segment skipped event.
      */
     sponsorBlockSegmentSkipped(player, track, payload) {
-        return this.manager.emit(Manager_1.ManagerEventTypes.SegmentSkipped, player, track, payload);
+        return this.manager.emit(Enums_1.ManagerEventTypes.SegmentSkipped, player, track, payload);
     }
     /**
      * Emitted when chapters for a track are loaded using the sponsorblock plugin.
@@ -822,7 +964,7 @@ class Node {
      * @param {SponsorBlockChaptersLoaded} payload - The event payload containing additional data about the chapters loaded event.
      */
     sponsorBlockChaptersLoaded(player, track, payload) {
-        return this.manager.emit(Manager_1.ManagerEventTypes.ChaptersLoaded, player, track, payload);
+        return this.manager.emit(Enums_1.ManagerEventTypes.ChaptersLoaded, player, track, payload);
     }
     /**
      * Emitted when a chapter of a track is started using the sponsorblock plugin.
@@ -832,7 +974,37 @@ class Node {
      * @param {SponsorBlockChapterStarted} payload - The event payload containing additional data about the chapter started event.
      */
     sponsorBlockChapterStarted(player, track, payload) {
-        return this.manager.emit(Manager_1.ManagerEventTypes.ChapterStarted, player, track, payload);
+        return this.manager.emit(Enums_1.ManagerEventTypes.ChapterStarted, player, track, payload);
+    }
+    /**
+     * Emitted when lyrics for a track are found.
+     * The payload of the event will contain the lyrics.
+     * @param {Player} player - The player associated with the lyrics.
+     * @param {Track} track - The track associated with the lyrics.
+     * @param {LyricsFoundEvent} payload - The event payload containing additional data about the lyrics found event.
+     */
+    lyricsFound(player, track, payload) {
+        return this.manager.emit(Enums_1.ManagerEventTypes.LyricsFound, player, track, payload);
+    }
+    /**
+     * Emitted when lyrics for a track are not found.
+     * The payload of the event will contain the track.
+     * @param {Player} player - The player associated with the lyrics.
+     * @param {Track} track - The track associated with the lyrics.
+     * @param {LyricsNotFoundEvent} payload - The event payload containing additional data about the lyrics not found event.
+     */
+    lyricsNotFound(player, track, payload) {
+        return this.manager.emit(Enums_1.ManagerEventTypes.LyricsNotFound, player, track, payload);
+    }
+    /**
+     * Emitted when a line of lyrics for a track is received.
+     * The payload of the event will contain the lyrics line.
+     * @param {Player} player - The player associated with the lyrics line.
+     * @param {Track} track - The track associated with the lyrics line.
+     * @param {LyricsLineEvent} payload - The event payload containing additional data about the lyrics line event.
+     */
+    lyricsLine(player, track, payload) {
+        return this.manager.emit(Enums_1.ManagerEventTypes.LyricsLine, player, track, payload);
     }
     /**
      * Fetches Lavalink node information.
@@ -866,7 +1038,7 @@ class Node {
      * player.setSponsorBlock([SponsorBlockSegment.Sponsor, SponsorBlockSegment.SelfPromo]);
      * ```
      */
-    async setSponsorBlock(player, segments = [SponsorBlockSegment.Sponsor, SponsorBlockSegment.SelfPromo]) {
+    async setSponsorBlock(player, segments = [Enums_1.SponsorBlockSegment.Sponsor, Enums_1.SponsorBlockSegment.SelfPromo]) {
         if (!this.info.plugins.some((plugin) => plugin.name === "sponsorblock-plugin"))
             throw new RangeError(`there is no sponsorblock-plugin available in the lavalink node: ${this.options.identifier}`);
         if (!segments.length)
@@ -899,7 +1071,7 @@ class Node {
         const message = "Please do NOT delete the magmastream/ folder as it is used to store player data for autoresume etc.";
         if (!fs_1.default.existsSync(readmeFilePath)) {
             fs_1.default.writeFileSync(readmeFilePath, message, "utf-8");
-            this.manager.emit(Manager_1.ManagerEventTypes.Debug, `[NODE] Created README file at: ${readmeFilePath}`);
+            this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[NODE] Created README file at: ${readmeFilePath}`);
         }
     }
 }