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

package/dist/structures/Manager.js

@@ -1,18 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ManagerEventTypes = exports.PlayerStateEventTypes = exports.AutoPlayPlatform = exports.SearchPlatform = exports.UseNodeOptions = exports.TrackPartial = exports.StateStorageType = exports.Manager = void 0;
+exports.Manager = void 0;
 const tslib_1 = require("tslib");
 const Utils_1 = require("./Utils");
 const collection_1 = require("@discordjs/collection");
 const events_1 = require("events");
+const Node_1 = require("./Node");
 const __1 = require("..");
 const managerCheck_1 = tslib_1.__importDefault(require("../utils/managerCheck"));
 const blockedWords_1 = require("../config/blockedWords");
 const promises_1 = tslib_1.__importDefault(require("fs/promises"));
 const path_1 = tslib_1.__importDefault(require("path"));
 const ioredis_1 = tslib_1.__importDefault(require("ioredis"));
+const Enums_1 = require("./Enums");
+const package_json_1 = require("../../package.json");
 /**
- * The main hub for interacting with Lavalink and using Magmastream,
+ * The main hub for interacting with Lavalink and using Magmastream.
  */
 class Manager extends events_1.EventEmitter {
     /** The map of players. */
@@ -23,6 +26,8 @@ class Manager extends events_1.EventEmitter {
     options;
     initiated = false;
     redis;
+    _send;
+    loadedPlugins = new Set();
     /**
      * Initiates the Manager class.
      * @param options
@@ -41,36 +46,54 @@ class Manager extends events_1.EventEmitter {
     constructor(options) {
         super();
         (0, managerCheck_1.default)(options);
+        // Initialize structures
         Utils_1.Structure.get("Player").init(this);
-        Utils_1.Structure.get("Node").init(this);
         Utils_1.TrackUtils.init(this);
-        Utils_1.AutoPlayUtils.init(this);
+        Utils_1.PlayerUtils.init(this);
         if (options.trackPartial) {
             Utils_1.TrackUtils.setTrackPartial(options.trackPartial);
             delete options.trackPartial;
         }
+        if (options.clientId)
+            this.options.clientId = options.clientId;
+        if (options.clusterId)
+            this.options.clusterId = options.clusterId;
+        if (options.send && !this._send)
+            this._send = options.send;
         this.options = {
-            enabledPlugins: [],
-            nodes: [
+            ...options,
+            enabledPlugins: options.enabledPlugins ?? [],
+            nodes: options.nodes ?? [
                 {
-                    identifier: "default",
-                    host: "localhost",
+                    identifier: "Cheap lavalink hosting @",
+                    host: "https://blackforthosting.com/products?category=lavalink",
+                    port: 443,
+                    password: "Try BlackForHosting",
+                    useSSL: true,
                     enableSessionResumeOption: false,
-                    sessionTimeoutMs: 1000,
+                    sessionTimeoutSeconds: 1000,
+                    nodePriority: 69,
                 },
             ],
-            playNextOnEnd: true,
-            enablePriorityMode: false,
-            clientName: "Magmastream",
-            defaultSearchPlatform: SearchPlatform.YouTube,
-            useNode: UseNodeOptions.LeastPlayers,
+            playNextOnEnd: options.playNextOnEnd ?? true,
+            enablePriorityMode: options.enablePriorityMode ?? false,
+            clientName: options.clientName ?? `Magmastream/${package_json_1.version}`,
+            defaultSearchPlatform: options.defaultSearchPlatform ?? Enums_1.SearchPlatform.YouTube,
+            useNode: options.useNode ?? Enums_1.UseNodeOptions.LeastPlayers,
             maxPreviousTracks: options.maxPreviousTracks ?? 20,
-            stateStorage: { type: StateStorageType.Collection },
-            ...options,
+            normalizeYouTubeTitles: options.normalizeYouTubeTitles ?? false,
+            stateStorage: {
+                ...options.stateStorage,
+                type: options.stateStorage?.type ?? Enums_1.StateStorageType.Memory,
+                deleteInactivePlayers: options.stateStorage?.deleteInactivePlayers ?? true,
+            },
+            autoPlaySearchPlatforms: options.autoPlaySearchPlatforms ?? [Enums_1.AutoPlayPlatform.YouTube],
+            send: this._send,
         };
+        Utils_1.AutoPlayUtils.init(this);
         if (this.options.nodes) {
             for (const nodeOptions of this.options.nodes)
-                new (Utils_1.Structure.get("Node"))(nodeOptions);
+                new Node_1.Node(this, nodeOptions);
         }
         process.on("SIGINT", async () => {
             console.warn("\x1b[33mSIGINT received! Graceful shutdown initiated...\x1b[0m");
@@ -83,7 +106,7 @@ class Manager extends events_1.EventEmitter {
                 }, 2000);
             }
             catch (error) {
-                console.error("Error during shutdown:", error);
+                console.error(`[MANAGER] Error during shutdown: ${error}`);
                 process.exit(1);
             }
         });
@@ -95,46 +118,36 @@ class Manager extends events_1.EventEmitter {
                 process.exit(0);
             }
             catch (error) {
-                console.error("Error during SIGTERM shutdown:", error);
+                console.error(`[MANAGER] Error during SIGTERM shutdown: ${error}`);
                 process.exit(1);
             }
         });
     }
     /**
      * Initiates the Manager.
-     * @param clientId - The Discord client ID (required).
+     * @param clientId - The Discord client ID (only required when not using any of the magmastream wrappers).
      * @param clusterId - The cluster ID which runs the current process (required).
      * @returns The manager instance.
      */
-    init(clientId, clusterId = 0) {
+    async init(options = {}) {
         if (this.initiated) {
             return this;
         }
-        if (typeof clientId !== "string" || !/^\d+$/.test(clientId)) {
-            throw new Error('"clientId" must be a valid Discord client ID.');
+        const { clientId, clusterId = 0 } = options;
+        if (clientId !== undefined) {
+            if (typeof clientId !== "string" || !/^\d+$/.test(clientId)) {
+                throw new Error('"clientId" must be a valid Discord client ID.');
+            }
+            this.options.clientId = clientId;
         }
-        this.options.clientId = clientId;
         if (typeof clusterId !== "number") {
-            console.warn('"clusterId" is not a valid number, defaulting to 0.');
-            clusterId = 0;
-        }
-        this.options.clusterId = clusterId;
-        for (const node of this.nodes.values()) {
-            try {
-                node.connect();
-            }
-            catch (err) {
-                this.emit(ManagerEventTypes.NodeError, node, err);
-            }
+            console.warn(`[MANAGER] "clusterId" is not a valid number, defaulting to 0.`);
+            this.options.clusterId = 0;
         }
-        if (this.options.enabledPlugins) {
-            for (const [index, plugin] of this.options.enabledPlugins.entries()) {
-                if (!(plugin instanceof __1.Plugin))
-                    throw new RangeError(`Plugin at index ${index} does not extend Plugin.`);
-                plugin.load(this);
-            }
+        else {
+            this.options.clusterId = clusterId;
         }
-        if (this.options.stateStorage?.type === StateStorageType.Redis) {
+        if (this.options.stateStorage.type === Enums_1.StateStorageType.Redis) {
             const config = this.options.stateStorage.redisConfig;
             this.redis = new ioredis_1.default({
                 host: config.host,
@@ -143,6 +156,15 @@ class Manager extends events_1.EventEmitter {
                 db: config.db ?? 0,
             });
         }
+        for (const node of this.nodes.values()) {
+            try {
+                await node.connect();
+            }
+            catch (err) {
+                this.emit(Enums_1.ManagerEventTypes.NodeError, node, err);
+            }
+        }
+        this.loadPlugins();
         this.initiated = true;
         return this;
     }
@@ -159,7 +181,7 @@ class Manager extends events_1.EventEmitter {
         const _query = typeof query === "string" ? { query } : query;
         const _source = _query.source ?? this.options.defaultSearchPlatform;
         let search = /^https?:\/\//.test(_query.query) ? _query.query : `${_source}:${_query.query}`;
-        this.emit(ManagerEventTypes.Debug, `[MANAGER] Performing ${_source} search for: ${_query.query}`);
+        this.emit(Enums_1.ManagerEventTypes.Debug, `[MANAGER] Performing ${_source} search for: ${_query.query}`);
         try {
             const res = (await node.rest.get(`/v4/loadtracks?identifier=${encodeURIComponent(search)}`));
             if (!res)
@@ -167,13 +189,19 @@ class Manager extends events_1.EventEmitter {
             let tracks = [];
             let playlist = null;
             switch (res.loadType) {
-                case Utils_1.LoadTypes.Search:
+                case Enums_1.LoadTypes.Search:
                     tracks = res.data.map((track) => Utils_1.TrackUtils.build(track, requester));
                     break;
-                case Utils_1.LoadTypes.Track:
+                case Enums_1.LoadTypes.Short:
+                case Enums_1.LoadTypes.Track:
                     tracks = [Utils_1.TrackUtils.build(res.data, requester)];
                     break;
-                case Utils_1.LoadTypes.Playlist: {
+                case Enums_1.LoadTypes.Album:
+                case Enums_1.LoadTypes.Artist:
+                case Enums_1.LoadTypes.Station:
+                case Enums_1.LoadTypes.Podcast:
+                case Enums_1.LoadTypes.Show:
+                case Enums_1.LoadTypes.Playlist: {
                     const playlistData = res.data;
                     tracks = playlistData.tracks.map((track) => Utils_1.TrackUtils.build(track, requester));
                     playlist = {
@@ -202,8 +230,27 @@ class Manager extends events_1.EventEmitter {
                     tracks = tracks.map(processTrack);
                 }
             }
-            const result = { loadType: res.loadType, tracks, playlist };
-            this.emit(ManagerEventTypes.Debug, `[MANAGER] Result ${_source} search for: ${_query.query}: ${JSON.stringify(result)}`);
+            let result;
+            switch (res.loadType) {
+                case Enums_1.LoadTypes.Album:
+                case Enums_1.LoadTypes.Artist:
+                case Enums_1.LoadTypes.Station:
+                case Enums_1.LoadTypes.Podcast:
+                case Enums_1.LoadTypes.Show:
+                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.Short:
+                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;
         }
         catch (err) {
@@ -218,15 +265,6 @@ class Manager extends events_1.EventEmitter {
     getPlayer(guildId) {
         return this.players.get(guildId);
     }
-    /**
-     * @deprecated - Will be removed with v2.10.0 use {@link getPlayer} instead
-     * Returns a player or undefined if it does not exist.
-     * @param guildId The guild ID of the player to retrieve.
-     * @returns The player if it exists, undefined otherwise.
-     */
-    async get(guildId) {
-        return this.players.get(guildId);
-    }
     /**
      * Creates a player or returns one if it already exists.
      * @param options The options to create the player with.
@@ -237,7 +275,7 @@ class Manager extends events_1.EventEmitter {
             return this.players.get(options.guildId);
         }
         // Create a new player with the given options
-        this.emit(ManagerEventTypes.Debug, `[MANAGER] Creating new player with options: ${JSON.stringify(options)}`);
+        this.emit(Enums_1.ManagerEventTypes.Debug, `[MANAGER] Creating new player with options: ${JSON.stringify(options)}`);
         return new (Utils_1.Structure.get("Player"))(options);
     }
     /**
@@ -246,12 +284,11 @@ class Manager extends events_1.EventEmitter {
      * @returns A promise that resolves when the player has been destroyed.
      */
     async destroy(guildId) {
-        // Emit debug message for player destruction
-        this.emit(ManagerEventTypes.Debug, `[MANAGER] Destroying player: ${guildId}`);
-        // Remove the player from the manager's collection
-        this.players.delete(guildId);
-        // Clean up any inactive players
-        await this.cleanupInactivePlayers();
+        this.emit(Enums_1.ManagerEventTypes.Debug, `[MANAGER] Destroying player: ${guildId}`);
+        const player = this.getPlayer(guildId);
+        if (!player)
+            return;
+        await player.destroy();
     }
     /**
      * Creates a new node or returns an existing one if it already exists.
@@ -259,15 +296,19 @@ class Manager extends events_1.EventEmitter {
      * @returns The created node.
      */
     createNode(options) {
+        const key = options.identifier || options.host;
         // Check if the node already exists in the manager's collection
-        if (this.nodes.has(options.identifier || options.host)) {
+        if (this.nodes.has(key)) {
             // Return the existing node if it does
-            return this.nodes.get(options.identifier || options.host);
+            return this.nodes.get(key);
         }
+        const node = new Node_1.Node(this, options);
+        // Set the node in the manager's collection
+        this.nodes.set(key, node);
         // Emit a debug event for node creation
-        this.emit(ManagerEventTypes.Debug, `[MANAGER] Creating new node with options: ${JSON.stringify(options)}`);
-        // Create a new node with the given options
-        return new (Utils_1.Structure.get("Node"))(options);
+        this.emit(Enums_1.ManagerEventTypes.Debug, `[MANAGER] Creating new node with options: ${JSON.stringify(options)}`);
+        // Return the created node
+        return node;
     }
     /**
      * Destroys a node if it exists. Emits a debug event if the node is found and destroyed.
@@ -277,11 +318,13 @@ class Manager extends events_1.EventEmitter {
      */
     async destroyNode(identifier) {
         const node = this.nodes.get(identifier);
-        if (!node)
+        if (!node) {
+            this.emit(Enums_1.ManagerEventTypes.Debug, `[MANAGER] Tried to destroy non-existent node: ${identifier}`);
             return;
-        this.emit(ManagerEventTypes.Debug, `[MANAGER] Destroying node: ${identifier}`);
-        await node.destroy();
+        }
+        this.emit(Enums_1.ManagerEventTypes.Debug, `[MANAGER] Destroying node: ${identifier}`);
         this.nodes.delete(identifier);
+        await node.destroy();
     }
     /**
      * Attaches an event listener to the manager.
@@ -307,18 +350,12 @@ class Manager extends events_1.EventEmitter {
         const player = this.getPlayer(update.guild_id);
         if (!player)
             return;
-        this.emit(ManagerEventTypes.Debug, `[MANAGER] Updating voice state: ${JSON.stringify(update)}`);
+        this.emit(Enums_1.ManagerEventTypes.Debug, `[MANAGER] Updating voice state: ${JSON.stringify(update)}`);
         if ("token" in update) {
             return await this.handleVoiceServerUpdate(player, update);
         }
         if (update.user_id !== this.options.clientId)
             return;
-        if (!player.voiceState.sessionId && player.voiceState.event) {
-            if (player.state !== Utils_1.StateTypes.Disconnected) {
-                await player.destroy();
-            }
-            return;
-        }
         return await this.handleVoiceStateUpdate(player, update);
     }
     /**
@@ -328,8 +365,8 @@ class Manager extends events_1.EventEmitter {
      * @returns A promise that resolves to an array of TrackData objects.
      * @throws Will throw an error if no nodes are available or if the API request fails.
      */
-    decodeTracks(tracks) {
-        this.emit(ManagerEventTypes.Debug, `[MANAGER] Decoding tracks: ${JSON.stringify(tracks)}`);
+    async decodeTracks(tracks) {
+        this.emit(Enums_1.ManagerEventTypes.Debug, `[MANAGER] Decoding tracks: ${JSON.stringify(tracks)}`);
         return new Promise(async (resolve, reject) => {
             const node = this.nodes.first();
             if (!node)
@@ -353,201 +390,467 @@ class Manager extends events_1.EventEmitter {
         return res[0];
     }
     /**
-     * Saves player states to the JSON file.
+     * Saves player states.
      * @param {string} guildId - The guild ID of the player to save
      */
     async savePlayerState(guildId) {
-        try {
-            const playerStateFilePath = await this.getPlayerFilePath(guildId);
-            const player = this.getPlayer(guildId);
-            if (!player || player.state === Utils_1.StateTypes.Disconnected || !player.voiceChannelId) {
-                console.warn(`Skipping save for inactive player: ${guildId}`);
+        switch (this.options.stateStorage.type) {
+            case Enums_1.StateStorageType.Memory:
+            case Enums_1.StateStorageType.JSON:
+                {
+                    try {
+                        const playerStateFilePath = Utils_1.PlayerUtils.getPlayerStatePath(guildId);
+                        const player = this.getPlayer(guildId);
+                        if (!player || player.state === Enums_1.StateTypes.Disconnected || !player.voiceChannelId) {
+                            this.emit(Enums_1.ManagerEventTypes.Debug, `[MANAGER] Skipping save for inactive player: ${guildId}`);
+                            return;
+                        }
+                        const serializedPlayer = await Utils_1.PlayerUtils.serializePlayer(player);
+                        await promises_1.default.mkdir(path_1.default.dirname(playerStateFilePath), { recursive: true });
+                        await promises_1.default.writeFile(playerStateFilePath, JSON.stringify(serializedPlayer, null, 2), "utf-8");
+                        this.emit(Enums_1.ManagerEventTypes.Debug, `[MANAGER] Player state saved: ${guildId}`);
+                    }
+                    catch (error) {
+                        this.emit(Enums_1.ManagerEventTypes.Debug, `[MANAGER] Error saving player state for guild ${guildId}: ${error}`);
+                    }
+                }
+                break;
+            case Enums_1.StateStorageType.Redis:
+                {
+                    try {
+                        const player = this.getPlayer(guildId);
+                        if (!player || player.state === Enums_1.StateTypes.Disconnected || !player.voiceChannelId) {
+                            console.warn(`[MANAGER] Skipping save for inactive player: ${guildId}`);
+                            return;
+                        }
+                        const serializedPlayer = await Utils_1.PlayerUtils.serializePlayer(player);
+                        const redisKey = `${this.options.stateStorage.redisConfig.prefix?.endsWith(":")
+                            ? this.options.stateStorage.redisConfig.prefix
+                            : this.options.stateStorage.redisConfig.prefix ?? "magmastream:"}playerstore:${guildId}`;
+                        await this.redis.set(redisKey, JSON.stringify(serializedPlayer));
+                        this.emit(Enums_1.ManagerEventTypes.Debug, `[MANAGER] Player state saved to Redis: ${guildId}`);
+                    }
+                    catch (error) {
+                        this.emit(Enums_1.ManagerEventTypes.Debug, `[MANAGER] Error saving player state to Redis for guild ${guildId}: ${error}`);
+                    }
+                }
+                break;
+            default:
                 return;
-            }
-            const serializedPlayer = this.serializePlayer(player);
-            await promises_1.default.writeFile(playerStateFilePath, JSON.stringify(serializedPlayer, null, 2), "utf-8");
-            this.emit(ManagerEventTypes.Debug, `[MANAGER] Player state saved: ${guildId}`);
-        }
-        catch (error) {
-            console.error(`Error saving player state for guild ${guildId}:`, error);
         }
     }
+    /**
+     * 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.
+     */
+    async sleep(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
     /**
      * Loads player states from the JSON file.
      * @param nodeId The ID of the node to load player states from.
      * @returns A promise that resolves when the player states have been loaded.
      */
     async loadPlayerStates(nodeId) {
-        this.emit(ManagerEventTypes.Debug, "[MANAGER] Loading saved players.");
+        this.emit(Enums_1.ManagerEventTypes.Debug, "[MANAGER] Loading saved players.");
         const node = this.nodes.get(nodeId);
         if (!node)
             throw new Error(`Could not find node: ${nodeId}`);
         const info = (await node.rest.getAllPlayers());
-        const playerStatesDir = 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(playerStatesDir).catch(async () => {
-                await promises_1.default.mkdir(playerStatesDir, { recursive: true });
-                this.emit(ManagerEventTypes.Debug, `[MANAGER] Created directory: ${playerStatesDir}`);
-            });
-            // Read the contents of the directory
-            const playerFiles = await promises_1.default.readdir(playerStatesDir);
-            // Process each file in the directory
-            for (const file of playerFiles) {
-                const filePath = path_1.default.join(playerStatesDir, file);
-                try {
-                    // Check if the file exists (though readdir should only return valid files)
-                    await promises_1.default.access(filePath);
-                    // Read the file asynchronously
-                    const data = await promises_1.default.readFile(filePath, "utf-8");
-                    const state = JSON.parse(data);
-                    if (state && typeof state === "object" && state.guildId && state.node.options.identifier === nodeId) {
-                        const lavaPlayer = info.find((player) => player.guildId === state.guildId);
-                        if (!lavaPlayer) {
-                            await this.destroy(state.guildId);
-                        }
-                        const playerOptions = {
-                            guildId: state.options.guildId,
-                            textChannelId: state.options.textChannelId,
-                            voiceChannelId: state.options.voiceChannelId,
-                            selfDeafen: state.options.selfDeafen,
-                            volume: lavaPlayer.volume || state.options.volume,
-                            node: nodeId,
-                        };
-                        this.emit(ManagerEventTypes.Debug, `[MANAGER] Recreating player: ${state.guildId} from saved file: ${JSON.stringify(state.options)}`);
-                        const player = this.create(playerOptions);
-                        await player.node.rest.updatePlayer({
-                            guildId: state.options.guildId,
-                            data: { voice: { token: state.voiceState.event.token, endpoint: state.voiceState.event.endpoint, sessionId: state.voiceState.sessionId } },
+        switch (this.options.stateStorage.type) {
+            case Enums_1.StateStorageType.Memory:
+            case Enums_1.StateStorageType.JSON:
+                {
+                    const playersBaseDir = Utils_1.PlayerUtils.getPlayersBaseDir();
+                    try {
+                        // Ensure base players directory exists
+                        await promises_1.default.access(playersBaseDir).catch(async () => {
+                            await promises_1.default.mkdir(playersBaseDir, { recursive: true });
+                            this.emit(Enums_1.ManagerEventTypes.Debug, `[MANAGER] Created directory: ${playersBaseDir}`);
                         });
-                        player.connect();
-                        const tracks = [];
-                        const currentTrack = state.queue.current;
-                        const queueTracks = state.queue.tracks;
-                        if (lavaPlayer) {
-                            if (lavaPlayer.track) {
-                                tracks.push(...queueTracks);
-                                if (currentTrack && currentTrack.uri === lavaPlayer.track.info.uri) {
-                                    await player.queue.setCurrent(Utils_1.TrackUtils.build(lavaPlayer.track, currentTrack.requester));
+                        // Read guild directories inside players base dir
+                        const guildDirs = await promises_1.default.readdir(playersBaseDir, { withFileTypes: true });
+                        for (const dirent of guildDirs) {
+                            if (!dirent.isDirectory())
+                                continue;
+                            const guildId = dirent.name;
+                            const stateFilePath = Utils_1.PlayerUtils.getPlayerStatePath(guildId);
+                            try {
+                                await promises_1.default.access(stateFilePath);
+                                const rawData = await promises_1.default.readFile(stateFilePath, "utf-8");
+                                const state = JSON.parse(rawData);
+                                if (state.clusterId !== this.options.clusterId)
+                                    continue;
+                                if (!state.guildId || state.node?.options?.identifier !== nodeId)
+                                    continue;
+                                const lavaPlayer = info.find((player) => player.guildId === state.guildId);
+                                if (!lavaPlayer) {
+                                    await this.destroy(state.guildId);
+                                    continue;
                                 }
-                            }
-                            else {
-                                if (!currentTrack) {
-                                    const payload = {
-                                        reason: Utils_1.TrackEndReasonTypes.Finished,
-                                    };
-                                    await node.queueEnd(player, currentTrack, payload);
+                                const playerOptions = {
+                                    guildId: state.options.guildId,
+                                    textChannelId: state.options.textChannelId,
+                                    voiceChannelId: state.options.voiceChannelId,
+                                    selfDeafen: state.options.selfDeafen,
+                                    volume: lavaPlayer.volume || state.options.volume,
+                                    nodeIdentifier: nodeId,
+                                };
+                                this.emit(Enums_1.ManagerEventTypes.Debug, `[MANAGER] Recreating player: ${state.guildId} from saved file: ${JSON.stringify(state.options)}`);
+                                const player = this.create(playerOptions);
+                                await player.node.rest.updatePlayer({
+                                    guildId: state.options.guildId,
+                                    data: {
+                                        voice: {
+                                            token: state.voiceState.event.token,
+                                            endpoint: state.voiceState.event.endpoint,
+                                            sessionId: state.voiceState.sessionId,
+                                        },
+                                    },
+                                });
+                                player.connect();
+                                const tracks = [];
+                                const currentTrack = state.queue.current;
+                                const queueTracks = state.queue.tracks;
+                                if (state.isAutoplay) {
+                                    Object.setPrototypeOf(state.data.clientUser, { constructor: { name: "User" } });
+                                    player.setAutoplay(true, state.data.clientUser, state.autoplayTries);
+                                }
+                                if (lavaPlayer?.track) {
+                                    tracks.push(...queueTracks);
+                                    if (currentTrack && currentTrack.uri === lavaPlayer.track.info.uri) {
+                                        await player.queue.setCurrent(Utils_1.TrackUtils.build(lavaPlayer.track, currentTrack.requester));
+                                    }
+                                    if (tracks.length > 0) {
+                                        await player.queue.clear();
+                                        await player.queue.add(tracks);
+                                    }
                                 }
                                 else {
-                                    tracks.push(currentTrack, ...queueTracks);
+                                    if (currentTrack) {
+                                        if (queueTracks.length > 0) {
+                                            tracks.push(...queueTracks);
+                                            await player.queue.clear();
+                                            await player.queue.add(tracks);
+                                        }
+                                        await node.trackEnd(player, currentTrack, {
+                                            reason: Enums_1.TrackEndReasonTypes.Finished,
+                                            type: "TrackEndEvent",
+                                        });
+                                    }
+                                    else {
+                                        const previousQueue = await player.queue.getPrevious();
+                                        const lastTrack = previousQueue?.at(-1);
+                                        if (lastTrack) {
+                                            if (queueTracks.length === 0) {
+                                                await node.trackEnd(player, lastTrack, {
+                                                    reason: Enums_1.TrackEndReasonTypes.Finished,
+                                                    type: "TrackEndEvent",
+                                                });
+                                            }
+                                            else {
+                                                tracks.push(...queueTracks);
+                                                if (tracks.length > 0) {
+                                                    await player.queue.clear();
+                                                    await player.queue.add(tracks);
+                                                }
+                                            }
+                                        }
+                                        else if (queueTracks.length > 0) {
+                                            tracks.push(...queueTracks);
+                                            if (tracks.length > 0) {
+                                                await player.queue.clear();
+                                                await player.queue.add(tracks);
+                                            }
+                                            await node.trackEnd(player, lastTrack, {
+                                                reason: Enums_1.TrackEndReasonTypes.Finished,
+                                                type: "TrackEndEvent",
+                                            });
+                                        }
+                                    }
                                 }
-                            }
-                        }
-                        else {
-                            if (!currentTrack) {
-                                const payload = {
-                                    reason: Utils_1.TrackEndReasonTypes.Finished,
+                                if (state.queue.previous.length > 0) {
+                                    await player.queue.addPrevious(state.queue.previous);
+                                }
+                                else {
+                                    await player.queue.clearPrevious();
+                                }
+                                if (state.paused) {
+                                    await player.pause(true);
+                                }
+                                else {
+                                    player.paused = false;
+                                }
+                                if (state.trackRepeat)
+                                    player.setTrackRepeat(true);
+                                if (state.queueRepeat)
+                                    player.setQueueRepeat(true);
+                                if (state.dynamicRepeat) {
+                                    player.setDynamicRepeat(state.dynamicRepeat, state.dynamicLoopInterval._idleTimeout);
+                                }
+                                if (state.data) {
+                                    for (const [name, value] of Object.entries(state.data)) {
+                                        player.set(name, value);
+                                    }
+                                }
+                                const filterActions = {
+                                    bassboost: () => player.filters.bassBoost(state.filters.bassBoostlevel),
+                                    distort: (enabled) => player.filters.distort(enabled),
+                                    setDistortion: () => player.filters.setDistortion(state.filters.distortion),
+                                    eightD: (enabled) => player.filters.eightD(enabled),
+                                    setKaraoke: () => player.filters.setKaraoke(state.filters.karaoke),
+                                    nightcore: (enabled) => player.filters.nightcore(enabled),
+                                    slowmo: (enabled) => player.filters.slowmo(enabled),
+                                    soft: (enabled) => player.filters.soft(enabled),
+                                    trebleBass: (enabled) => player.filters.trebleBass(enabled),
+                                    setTimescale: () => player.filters.setTimescale(state.filters.timescale),
+                                    tv: (enabled) => player.filters.tv(enabled),
+                                    vibrato: () => player.filters.setVibrato(state.filters.vibrato),
+                                    vaporwave: (enabled) => player.filters.vaporwave(enabled),
+                                    pop: (enabled) => player.filters.pop(enabled),
+                                    party: (enabled) => player.filters.party(enabled),
+                                    earrape: (enabled) => player.filters.earrape(enabled),
+                                    electronic: (enabled) => player.filters.electronic(enabled),
+                                    radio: (enabled) => player.filters.radio(enabled),
+                                    setRotation: () => player.filters.setRotation(state.filters.rotation),
+                                    tremolo: (enabled) => player.filters.tremolo(enabled),
+                                    china: (enabled) => player.filters.china(enabled),
+                                    chipmunk: (enabled) => player.filters.chipmunk(enabled),
+                                    darthvader: (enabled) => player.filters.darthvader(enabled),
+                                    daycore: (enabled) => player.filters.daycore(enabled),
+                                    doubletime: (enabled) => player.filters.doubletime(enabled),
+                                    demon: (enabled) => player.filters.demon(enabled),
                                 };
-                                await node.queueEnd(player, currentTrack, payload);
+                                for (const [filter, isEnabled] of Object.entries(state.filters.filterStatus)) {
+                                    if (isEnabled && filterActions[filter]) {
+                                        filterActions[filter](true);
+                                    }
+                                }
+                                this.emit(Enums_1.ManagerEventTypes.PlayerRestored, player, node);
+                                await this.sleep(1000);
                             }
-                            else {
-                                tracks.push(currentTrack, ...queueTracks);
+                            catch (error) {
+                                this.emit(Enums_1.ManagerEventTypes.Debug, `[MANAGER] Error processing player state for guild ${guildId}: ${error}`);
+                                continue;
                             }
                         }
-                        if (tracks.length > 0) {
-                            await player.queue.add(tracks);
-                        }
-                        if (state.queue.previous.length > 0) {
-                            await player.queue.addPrevious(state.queue.previous);
-                        }
-                        else {
-                            await player.queue.clearPrevious();
-                        }
-                        if (state.paused) {
-                            await player.pause(true);
-                        }
-                        else {
-                            player.paused = false;
-                        }
-                        if (state.trackRepeat)
-                            player.setTrackRepeat(true);
-                        if (state.queueRepeat)
-                            player.setQueueRepeat(true);
-                        if (state.dynamicRepeat) {
-                            player.setDynamicRepeat(state.dynamicRepeat, state.dynamicLoopInterval._idleTimeout);
-                        }
-                        if (state.isAutoplay) {
-                            Object.setPrototypeOf(state.data.clientUser, { constructor: { name: "User" } });
-                            player.setAutoplay(true, state.data.clientUser, state.autoplayTries);
-                        }
-                        if (state.data) {
-                            for (const [name, value] of Object.entries(state.data)) {
-                                player.set(name, value);
+                        // Cleanup old player state files from guild directories whose nodeId matches
+                        for (const dirent of guildDirs) {
+                            if (!dirent.isDirectory())
+                                continue;
+                            const guildId = dirent.name;
+                            const stateFilePath = Utils_1.PlayerUtils.getPlayerStatePath(guildId);
+                            try {
+                                await promises_1.default.access(stateFilePath);
+                                const data = await promises_1.default.readFile(stateFilePath, "utf-8");
+                                const state = JSON.parse(data);
+                                if (state && typeof state === "object" && state.node?.options?.identifier === nodeId) {
+                                    await promises_1.default.rm(Utils_1.PlayerUtils.getPlayerStatePath(guildId), { force: true });
+                                    this.emit(Enums_1.ManagerEventTypes.Debug, `[MANAGER] Deleted player state folder for guild ${guildId}`);
+                                }
                             }
-                        }
-                        const filterActions = {
-                            bassboost: () => player.filters.bassBoost(state.filters.bassBoostlevel),
-                            distort: (enabled) => player.filters.distort(enabled),
-                            setDistortion: () => player.filters.setDistortion(state.filters.distortion),
-                            eightD: (enabled) => player.filters.eightD(enabled),
-                            setKaraoke: () => player.filters.setKaraoke(state.filters.karaoke),
-                            nightcore: (enabled) => player.filters.nightcore(enabled),
-                            slowmo: (enabled) => player.filters.slowmo(enabled),
-                            soft: (enabled) => player.filters.soft(enabled),
-                            trebleBass: (enabled) => player.filters.trebleBass(enabled),
-                            setTimescale: () => player.filters.setTimescale(state.filters.timescale),
-                            tv: (enabled) => player.filters.tv(enabled),
-                            vibrato: () => player.filters.setVibrato(state.filters.vibrato),
-                            vaporwave: (enabled) => player.filters.vaporwave(enabled),
-                            pop: (enabled) => player.filters.pop(enabled),
-                            party: (enabled) => player.filters.party(enabled),
-                            earrape: (enabled) => player.filters.earrape(enabled),
-                            electronic: (enabled) => player.filters.electronic(enabled),
-                            radio: (enabled) => player.filters.radio(enabled),
-                            setRotation: () => player.filters.setRotation(state.filters.rotation),
-                            tremolo: (enabled) => player.filters.tremolo(enabled),
-                            china: (enabled) => player.filters.china(enabled),
-                            chipmunk: (enabled) => player.filters.chipmunk(enabled),
-                            darthvader: (enabled) => player.filters.darthvader(enabled),
-                            daycore: (enabled) => player.filters.daycore(enabled),
-                            doubletime: (enabled) => player.filters.doubletime(enabled),
-                            demon: (enabled) => player.filters.demon(enabled),
-                        };
-                        // Iterate through filterStatus and apply the enabled filters
-                        for (const [filter, isEnabled] of Object.entries(state.filters.filterStatus)) {
-                            if (isEnabled && filterActions[filter]) {
-                                filterActions[filter](true);
+                            catch (error) {
+                                this.emit(Enums_1.ManagerEventTypes.Debug, `[MANAGER] Error deleting player state for guild ${guildId}: ${error}`);
+                                continue;
                             }
                         }
                     }
-                }
-                catch (error) {
-                    this.emit(ManagerEventTypes.Debug, `[MANAGER] Error processing file ${filePath}: ${error}`);
-                    continue; // Skip to the next file if there's an error
-                }
-            }
-            // Delete all files inside playerStatesDir where nodeId matches
-            for (const file of playerFiles) {
-                const filePath = path_1.default.join(playerStatesDir, file);
-                try {
-                    await promises_1.default.access(filePath); // Check if the file exists
-                    const data = await promises_1.default.readFile(filePath, "utf-8");
-                    const state = JSON.parse(data);
-                    if (state && typeof state === "object" && state.node.options.identifier === nodeId) {
-                        await promises_1.default.unlink(filePath); // Delete the file asynchronously
-                        this.emit(ManagerEventTypes.Debug, `[MANAGER] Deleted player state file: ${filePath}`);
+                    catch (error) {
+                        this.emit(Enums_1.ManagerEventTypes.Debug, `[MANAGER] Error loading player states: ${error}`);
                     }
                 }
-                catch (error) {
-                    this.emit(ManagerEventTypes.Debug, `[MANAGER] Error deleting file ${filePath}: ${error}`);
-                    continue; // Skip to the next file if there's an error
+                break;
+            case Enums_1.StateStorageType.Redis:
+                {
+                    try {
+                        // Get all keys matching our pattern
+                        const redisKeyPattern = `${this.options.stateStorage.redisConfig.prefix?.endsWith(":")
+                            ? this.options.stateStorage.redisConfig.prefix
+                            : this.options.stateStorage.redisConfig.prefix ?? "magmastream:"}playerstore:*`;
+                        const keys = await this.redis.keys(redisKeyPattern);
+                        for (const key of keys) {
+                            try {
+                                const data = await this.redis.get(key);
+                                if (!data)
+                                    continue;
+                                const state = JSON.parse(data);
+                                if (!state || typeof state !== "object" || state.clusterId !== this.options.clusterId)
+                                    continue;
+                                const guildId = key.split(":").pop();
+                                if (!guildId)
+                                    continue;
+                                if (state.node?.options?.identifier === nodeId) {
+                                    const lavaPlayer = info.find((player) => player.guildId === guildId);
+                                    if (!lavaPlayer) {
+                                        await this.destroy(guildId);
+                                    }
+                                    const playerOptions = {
+                                        guildId: state.options.guildId,
+                                        textChannelId: state.options.textChannelId,
+                                        voiceChannelId: state.options.voiceChannelId,
+                                        selfDeafen: state.options.selfDeafen,
+                                        volume: lavaPlayer?.volume || state.options.volume,
+                                        nodeIdentifier: nodeId,
+                                    };
+                                    this.emit(Enums_1.ManagerEventTypes.Debug, `[MANAGER] Recreating player: ${guildId} from Redis`);
+                                    const player = this.create(playerOptions);
+                                    await player.node.rest.updatePlayer({
+                                        guildId: state.options.guildId,
+                                        data: { voice: { token: state.voiceState.event.token, endpoint: state.voiceState.event.endpoint, sessionId: state.voiceState.sessionId } },
+                                    });
+                                    player.connect();
+                                    // Rest of the player state restoration code (tracks, filters, etc.)
+                                    const tracks = [];
+                                    const currentTrack = state.queue.current;
+                                    const queueTracks = state.queue.tracks;
+                                    if (state.isAutoplay) {
+                                        Object.setPrototypeOf(state.data.clientUser, { constructor: { name: "User" } });
+                                        player.setAutoplay(true, state.data.clientUser, state.autoplayTries);
+                                    }
+                                    if (lavaPlayer?.track) {
+                                        // If lavaPlayer has a track, push all queue tracks
+                                        tracks.push(...queueTracks);
+                                        // Set current track if matches lavaPlayer's track URI
+                                        if (currentTrack && currentTrack.uri === lavaPlayer.track.info.uri) {
+                                            await player.queue.setCurrent(Utils_1.TrackUtils.build(lavaPlayer.track, currentTrack.requester));
+                                        }
+                                        // Add tracks to queue
+                                        if (tracks.length > 0) {
+                                            await player.queue.clear();
+                                            await player.queue.add(tracks);
+                                        }
+                                    }
+                                    else {
+                                        // LavaPlayer missing track or lavaPlayer is falsy
+                                        if (currentTrack) {
+                                            if (queueTracks.length > 0) {
+                                                tracks.push(...queueTracks);
+                                                await player.queue.clear();
+                                                await player.queue.add(tracks);
+                                            }
+                                            await node.trackEnd(player, currentTrack, {
+                                                reason: Enums_1.TrackEndReasonTypes.Finished,
+                                                type: "TrackEndEvent",
+                                            });
+                                        }
+                                        else {
+                                            // No current track, check previous queue for last track
+                                            const previousQueue = await player.queue.getPrevious();
+                                            const lastTrack = previousQueue?.at(-1);
+                                            if (lastTrack) {
+                                                if (queueTracks.length === 0) {
+                                                    // If no tracks in queue, end last track
+                                                    await node.trackEnd(player, lastTrack, {
+                                                        reason: Enums_1.TrackEndReasonTypes.Finished,
+                                                        type: "TrackEndEvent",
+                                                    });
+                                                }
+                                                else {
+                                                    // If there are queued tracks, add them
+                                                    tracks.push(...queueTracks);
+                                                    if (tracks.length > 0) {
+                                                        await player.queue.clear();
+                                                        await player.queue.add(tracks);
+                                                    }
+                                                }
+                                            }
+                                            else {
+                                                if (queueTracks.length > 0) {
+                                                    tracks.push(...queueTracks);
+                                                    if (tracks.length > 0) {
+                                                        await player.queue.clear();
+                                                        await player.queue.add(tracks);
+                                                    }
+                                                    await node.trackEnd(player, lastTrack, {
+                                                        reason: Enums_1.TrackEndReasonTypes.Finished,
+                                                        type: "TrackEndEvent",
+                                                    });
+                                                }
+                                            }
+                                        }
+                                    }
+                                    if (state.queue.previous.length > 0) {
+                                        await player.queue.addPrevious(state.queue.previous);
+                                    }
+                                    else {
+                                        await player.queue.clearPrevious();
+                                    }
+                                    if (state.paused) {
+                                        await player.pause(true);
+                                    }
+                                    else {
+                                        player.paused = false;
+                                    }
+                                    if (state.trackRepeat)
+                                        player.setTrackRepeat(true);
+                                    if (state.queueRepeat)
+                                        player.setQueueRepeat(true);
+                                    if (state.dynamicRepeat) {
+                                        player.setDynamicRepeat(state.dynamicRepeat, state.dynamicLoopInterval._idleTimeout);
+                                    }
+                                    if (state.data) {
+                                        for (const [name, value] of Object.entries(state.data)) {
+                                            player.set(name, value);
+                                        }
+                                    }
+                                    const filterActions = {
+                                        bassboost: () => player.filters.bassBoost(state.filters.bassBoostlevel),
+                                        distort: (enabled) => player.filters.distort(enabled),
+                                        setDistortion: () => player.filters.setDistortion(state.filters.distortion),
+                                        eightD: (enabled) => player.filters.eightD(enabled),
+                                        setKaraoke: () => player.filters.setKaraoke(state.filters.karaoke),
+                                        nightcore: (enabled) => player.filters.nightcore(enabled),
+                                        slowmo: (enabled) => player.filters.slowmo(enabled),
+                                        soft: (enabled) => player.filters.soft(enabled),
+                                        trebleBass: (enabled) => player.filters.trebleBass(enabled),
+                                        setTimescale: () => player.filters.setTimescale(state.filters.timescale),
+                                        tv: (enabled) => player.filters.tv(enabled),
+                                        vibrato: () => player.filters.setVibrato(state.filters.vibrato),
+                                        vaporwave: (enabled) => player.filters.vaporwave(enabled),
+                                        pop: (enabled) => player.filters.pop(enabled),
+                                        party: (enabled) => player.filters.party(enabled),
+                                        earrape: (enabled) => player.filters.earrape(enabled),
+                                        electronic: (enabled) => player.filters.electronic(enabled),
+                                        radio: (enabled) => player.filters.radio(enabled),
+                                        setRotation: () => player.filters.setRotation(state.filters.rotation),
+                                        tremolo: (enabled) => player.filters.tremolo(enabled),
+                                        china: (enabled) => player.filters.china(enabled),
+                                        chipmunk: (enabled) => player.filters.chipmunk(enabled),
+                                        darthvader: (enabled) => player.filters.darthvader(enabled),
+                                        daycore: (enabled) => player.filters.daycore(enabled),
+                                        doubletime: (enabled) => player.filters.doubletime(enabled),
+                                        demon: (enabled) => player.filters.demon(enabled),
+                                    };
+                                    // Iterate through filterStatus and apply the enabled filters
+                                    for (const [filter, isEnabled] of Object.entries(state.filters.filterStatus)) {
+                                        if (isEnabled && filterActions[filter]) {
+                                            filterActions[filter](true);
+                                        }
+                                    }
+                                    // After processing, delete the Redis key
+                                    await this.redis.del(key);
+                                    this.emit(Enums_1.ManagerEventTypes.Debug, `[MANAGER] Deleted player state from Redis: ${key}`);
+                                    this.emit(Enums_1.ManagerEventTypes.PlayerRestored, player, node);
+                                    await this.sleep(1000);
+                                }
+                            }
+                            catch (error) {
+                                this.emit(Enums_1.ManagerEventTypes.Debug, `[MANAGER] Error processing Redis key ${key}: ${error}`);
+                                continue;
+                            }
+                        }
+                    }
+                    catch (error) {
+                        this.emit(Enums_1.ManagerEventTypes.Debug, `[MANAGER] Error loading player states from Redis: ${error}`);
+                    }
                 }
-            }
-        }
-        catch (error) {
-            this.emit(ManagerEventTypes.Debug, `[MANAGER] Error loading player states: ${error}`);
+                break;
+            default:
+                break;
         }
-        this.emit(ManagerEventTypes.Debug, "[MANAGER] Finished loading saved players.");
+        this.emit(Enums_1.ManagerEventTypes.Debug, "[MANAGER] Finished loading saved players.");
+        this.emit(Enums_1.ManagerEventTypes.RestoreComplete, node);
     }
     /**
      * Returns the node to use based on the configured `useNode` and `enablePriorityMode` options.
@@ -559,7 +862,7 @@ class Manager extends events_1.EventEmitter {
     get useableNode() {
         return this.options.enablePriorityMode
             ? this.priorityNode
-            : this.options.useNode === UseNodeOptions.LeastLoad
+            : this.options.useNode === Enums_1.UseNodeOptions.LeastLoad
                 ? this.leastLoadNode.first()
                 : this.leastPlayersNode.first();
     }
@@ -571,25 +874,28 @@ class Manager extends events_1.EventEmitter {
      * After saving and cleaning up, it exits the process.
      */
     async handleShutdown() {
+        this.unloadPlugins();
         console.warn("\x1b[31m%s\x1b[0m", "MAGMASTREAM WARNING: Shutting down! Please wait, saving active players...");
         try {
+            await this.clearAllStoredPlayers();
             const savePromises = Array.from(this.players.keys()).map(async (guildId) => {
                 try {
                     await this.savePlayerState(guildId);
                 }
                 catch (error) {
-                    console.error(`Error saving player state for guild ${guildId}:`, error);
+                    console.error(`[MANAGER] Error saving player state for guild ${guildId}:`, error);
                 }
             });
+            if (this.options.stateStorage.deleteInactivePlayers)
+                await this.cleanupInactivePlayers();
             await Promise.allSettled(savePromises);
-            await this.cleanupInactivePlayers();
             setTimeout(() => {
                 console.warn("\x1b[32m%s\x1b[0m", "MAGMASTREAM INFO: Shutting down complete, exiting...");
                 process.exit(0);
             }, 500);
         }
         catch (error) {
-            console.error("Unexpected error during shutdown:", error);
+            console.error(`[MANAGER] Unexpected error during shutdown:`, error);
             process.exit(1);
         }
     }
@@ -707,6 +1013,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;
     }
     /**
@@ -717,121 +1024,222 @@ 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(ManagerEventTypes.PlayerMove, player, player.voiceChannelId, update.channel_id);
+                this.emit(Enums_1.ManagerEventTypes.PlayerMove, player, player.voiceChannelId, update.channel_id);
             }
             player.voiceState.sessionId = update.session_id;
             player.voiceChannelId = update.channel_id;
+            player.options.voiceChannelId = update.channel_id;
             return;
         }
-        this.emit(ManagerEventTypes.PlayerDisconnect, player, player.voiceChannelId);
+        this.emit(Enums_1.ManagerEventTypes.PlayerDisconnect, player, player.voiceChannelId);
         player.voiceChannelId = null;
         player.voiceState = Object.assign({});
-        await player.destroy();
+        await player.pause(true);
         return;
     }
     /**
-     * Gets each player's JSON file
-     * @param {string} guildId - The guild ID
-     * @returns {string} The path to the player's JSON file
+     * Cleans up inactive players by removing their state files from the file system.
+     * This is done to prevent stale state files from accumulating on the file system.
      */
-    async getPlayerFilePath(guildId) {
-        const configDir = path_1.default.join(process.cwd(), "magmastream", "dist", "sessionData", "players");
-        try {
-            await promises_1.default.mkdir(configDir, { recursive: true });
-            return path_1.default.join(configDir, `${guildId}.json`);
+    async cleanupInactivePlayers() {
+        switch (this.options.stateStorage.type) {
+            case Enums_1.StateStorageType.JSON:
+                {
+                    const playersBaseDir = Utils_1.PlayerUtils.getPlayersBaseDir();
+                    try {
+                        await promises_1.default.mkdir(playersBaseDir, { recursive: true });
+                        const activeGuildIds = new Set(this.players.keys());
+                        // Cleanup inactive guild directories inside playersBaseDir
+                        const guildDirs = await promises_1.default.readdir(playersBaseDir, { withFileTypes: true });
+                        for (const dirent of guildDirs) {
+                            if (!dirent.isDirectory())
+                                continue;
+                            const guildId = dirent.name;
+                            if (!activeGuildIds.has(guildId)) {
+                                const guildPath = Utils_1.PlayerUtils.getGuildDir(guildId);
+                                await promises_1.default.rm(guildPath, { recursive: true, force: true });
+                                this.emit(Enums_1.ManagerEventTypes.Debug, `[MANAGER] Deleted inactive player data folder: ${guildId}`);
+                            }
+                        }
+                    }
+                    catch (error) {
+                        this.emit(Enums_1.ManagerEventTypes.Debug, `[MANAGER] Error cleaning up inactive JSON players: ${error}`);
+                    }
+                    return;
+                }
+                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}queue:*:current`;
+                    const stream = this.redis.scanStream({
+                        match: pattern,
+                        count: 100,
+                    });
+                    for await (const keys of stream) {
+                        for (const key of keys) {
+                            // Extract guildId from queue key
+                            const match = key.match(new RegExp(`^${prefix}queue:(.+):current$`));
+                            if (!match)
+                                continue;
+                            const guildId = match[1];
+                            // If player is not active in memory, clean up all keys
+                            if (!this.players.has(guildId)) {
+                                await this.redis.del(`${prefix}playerstore:${guildId}`, `${prefix}queue:${guildId}:current`, `${prefix}queue:${guildId}:tracks`, `${prefix}queue:${guildId}:previous`);
+                                this.emit(Enums_1.ManagerEventTypes.Debug, `[MANAGER] Cleaned inactive Redis player data: ${guildId}`);
+                            }
+                        }
+                    }
+                    return;
+                }
+                break;
+            default:
+                break;
         }
-        catch (err) {
-            console.error("Error ensuring player data directory exists:", err);
-            throw new Error(`Failed to resolve player file path for guild ${guildId}`);
+    }
+    /**
+     * Cleans up an inactive player by removing its state data.
+     * This is done to prevent stale state data from accumulating.
+     * @param guildId The guild ID of the player to clean up.
+     */
+    async cleanupInactivePlayer(guildId) {
+        switch (this.options.stateStorage.type) {
+            case Enums_1.StateStorageType.JSON:
+                {
+                    try {
+                        if (!this.players.has(guildId)) {
+                            const guildDir = Utils_1.PlayerUtils.getGuildDir(guildId);
+                            await promises_1.default.rm(guildDir, { recursive: true, force: true });
+                            this.emit(Enums_1.ManagerEventTypes.Debug, `[MANAGER] Deleted inactive player data folder: ${guildId}`);
+                        }
+                    }
+                    catch (error) {
+                        if (error.code !== "ENOENT") {
+                            this.emit(Enums_1.ManagerEventTypes.Debug, `[MANAGER] Error deleting player files for ${guildId}: ${error}`);
+                        }
+                    }
+                }
+                break;
+            case Enums_1.StateStorageType.Redis:
+                {
+                    const player = this.getPlayer(guildId);
+                    if (!player) {
+                        const prefix = this.options.stateStorage.redisConfig.prefix?.endsWith(":")
+                            ? this.options.stateStorage.redisConfig.prefix
+                            : `${this.options.stateStorage.redisConfig.prefix ?? "magmastream"}:`;
+                        const keysToDelete = [
+                            `${prefix}playerstore:${guildId}`,
+                            `${prefix}queue:${guildId}:tracks`,
+                            `${prefix}queue:${guildId}:current`,
+                            `${prefix}queue:${guildId}:previous`,
+                        ];
+                        await this.redis.del(...keysToDelete);
+                        this.emit(Enums_1.ManagerEventTypes.Debug, `[MANAGER] Deleted Redis player and queue data for: ${guildId}`);
+                    }
+                }
+                break;
+            default:
+                break;
         }
     }
     /**
-     * Serializes a Player instance to avoid circular references.
-     * @param player The Player instance to serialize
-     * @returns The serialized Player instance
-     */
-    serializePlayer(player) {
-        const seen = new WeakSet();
-        /**
-         * Recursively serializes an object, avoiding circular references.
-         * @param obj The object to serialize
-         * @returns The serialized object
-         */
-        const serialize = (obj) => {
-            if (obj && typeof obj === "object") {
-                if (seen.has(obj))
-                    return;
-                seen.add(obj);
+     * Loads the enabled plugins.
+     */
+    loadPlugins() {
+        if (!Array.isArray(this.options.enabledPlugins))
+            return;
+        for (const [index, plugin] of this.options.enabledPlugins.entries()) {
+            if (!(plugin instanceof __1.Plugin)) {
+                throw new RangeError(`Plugin at index ${index} does not extend Plugin.`);
             }
-            return obj;
-        };
-        return JSON.parse(JSON.stringify(player, (key, value) => {
-            if (key === "manager") {
-                return null;
+            try {
+                plugin.load(this);
+                this.loadedPlugins.add(plugin);
+                this.emit(Enums_1.ManagerEventTypes.Debug, `[PLUGIN] Loaded plugin: ${plugin.name}`);
             }
-            if (key === "filters") {
-                if (!value || typeof value !== "object")
-                    return null;
-                return {
-                    distortion: value.distortion ?? null,
-                    equalizer: value.equalizer ?? [],
-                    karaoke: value.karaoke ?? null,
-                    rotation: value.rotation ?? null,
-                    timescale: value.timescale ?? null,
-                    vibrato: value.vibrato ?? null,
-                    reverb: value.reverb ?? null,
-                    volume: value.volume ?? 1.0,
-                    bassBoostlevel: value.bassBoostlevel ?? null,
-                    filterStatus: value.filtersStatus ? { ...value.filtersStatus } : {},
-                };
+            catch (err) {
+                this.emit(Enums_1.ManagerEventTypes.Debug, `[PLUGIN] Failed to load plugin "${plugin.name}": ${err}`);
             }
-            if (key === "queue") {
-                return {
-                    current: value.current || null,
-                    tracks: Array.isArray(value) ? [...value] : [],
-                    previous: Array.isArray(value.previous) ? [...value.previous] : [],
-                };
+        }
+    }
+    /**
+     * Unloads the enabled plugins.
+     */
+    unloadPlugins() {
+        for (const plugin of this.loadedPlugins) {
+            try {
+                plugin.unload(this);
+                this.emit(Enums_1.ManagerEventTypes.Debug, `[PLUGIN] Unloaded plugin: ${plugin.name}`);
             }
-            if (key === "data") {
-                return {
-                    clientUser: value.Internal_BotUser ?? null,
-                };
+            catch (err) {
+                this.emit(Enums_1.ManagerEventTypes.Debug, `[PLUGIN] Failed to unload plugin "${plugin.name}": ${err}`);
             }
-            return serialize(value);
-        }));
+        }
+        this.loadedPlugins.clear();
     }
     /**
-     * Checks for players that are no longer active and deletes their saved state files.
+     * Clears all player states from the file system.
      * This is done to prevent stale state files from accumulating on the file system.
      */
-    async cleanupInactivePlayers() {
-        const playerStatesDir = 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(playerStatesDir).catch(async () => {
-                await promises_1.default.mkdir(playerStatesDir, { recursive: true });
-                this.emit(ManagerEventTypes.Debug, `[MANAGER] Created directory: ${playerStatesDir}`);
-            });
-            // Get the list of player state files
-            const playerFiles = await promises_1.default.readdir(playerStatesDir);
-            // Get the set of active guild IDs from the manager's player collection
-            const activeGuildIds = new Set(this.players.keys());
-            // Iterate over the player state files
-            for (const file of playerFiles) {
-                // Get the guild ID from the file name
-                const guildId = path_1.default.basename(file, ".json");
-                // If the guild ID is not in the set of active guild IDs, delete the file
-                if (!activeGuildIds.has(guildId)) {
-                    const filePath = path_1.default.join(playerStatesDir, file);
-                    await promises_1.default.unlink(filePath); // Delete the file asynchronously
-                    this.emit(ManagerEventTypes.Debug, `[MANAGER] Deleting inactive player: ${guildId}`);
+    async clearAllStoredPlayers() {
+        switch (this.options.stateStorage.type) {
+            case Enums_1.StateStorageType.Memory:
+            case Enums_1.StateStorageType.JSON: {
+                const playersBaseDir = Utils_1.PlayerUtils.getPlayersBaseDir();
+                try {
+                    await promises_1.default.access(playersBaseDir).catch(async () => {
+                        await promises_1.default.mkdir(playersBaseDir, { recursive: true });
+                        this.emit(Enums_1.ManagerEventTypes.Debug, `[MANAGER] Created directory: ${playersBaseDir}`);
+                    });
+                    const files = await promises_1.default.readdir(playersBaseDir);
+                    await Promise.all(files.map((file) => promises_1.default.unlink(path_1.default.join(playersBaseDir, file)).catch((err) => this.emit(Enums_1.ManagerEventTypes.Debug, `[MANAGER] Failed to delete file ${file}: ${err}`))));
+                    this.emit(Enums_1.ManagerEventTypes.Debug, `[MANAGER] Cleared all player state files in ${playersBaseDir}`);
                 }
+                catch (err) {
+                    this.emit(Enums_1.ManagerEventTypes.Debug, `[MANAGER] Error clearing player state files: ${err}`);
+                }
+                break;
             }
-        }
-        catch (error) {
-            this.emit(ManagerEventTypes.Debug, `[MANAGER] Error cleaning up inactive players: ${error}`);
+            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 patterns = [`${prefix}playerstore:*`, `${prefix}queue:*`];
+                try {
+                    for (const pattern of patterns) {
+                        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 keys (pattern: ${pattern})`);
+                        });
+                        stream.on("error", (err) => {
+                            console.error(`[MANAGER] Error during Redis SCAN stream (${pattern}):`, err);
+                        });
+                    }
+                }
+                catch (err) {
+                    console.error("[MANAGER] Failed to clear Redis keys:", err);
+                }
+                break;
+            }
+            default:
+                console.warn("[MANAGER] No valid stateStorage.type set, skipping state clearing.");
         }
     }
     /**
@@ -842,7 +1250,7 @@ class Manager extends events_1.EventEmitter {
      */
     get leastLoadNode() {
         return this.nodes
-            .filter((node) => node.connected)
+            .filter((node) => node.connected && !node.options.isBackup)
             .sort((a, b) => {
             const aload = a.stats.cpu ? (a.stats.cpu.lavalinkLoad / a.stats.cpu.cores) * 100 : 0;
             const bload = b.stats.cpu ? (b.stats.cpu.lavalinkLoad / b.stats.cpu.cores) * 100 : 0;
@@ -857,9 +1265,7 @@ class Manager extends events_1.EventEmitter {
      * @returns {Collection<string, Node>} A collection of nodes sorted by player count.
      */
     get leastPlayersNode() {
-        return this.nodes
-            .filter((node) => node.connected) // Filter out nodes that are not connected
-            .sort((a, b) => a.stats.players - b.stats.players); // Sort by the number of players
+        return this.nodes.filter((node) => node.connected && !node.options.isBackup).sort((a, b) => a.stats.players - b.stats.players);
     }
     /**
      * Returns a node based on priority.
@@ -892,112 +1298,17 @@ class Manager extends events_1.EventEmitter {
             }
         }
         // If no node has a cumulative weight greater than or equal to the random number, return the node with the lowest load
-        return this.options.useNode === UseNodeOptions.LeastLoad ? this.leastLoadNode.first() : this.leastPlayersNode.first();
+        return this.options.useNode === Enums_1.UseNodeOptions.LeastLoad ? this.leastLoadNode.first() : this.leastPlayersNode.first();
+    }
+    send(packet) {
+        if (!this._send) {
+            console.warn("[Manager.send] _send is not defined! Packet will not be sent.");
+            return;
+        }
+        return this._send(packet);
+    }
+    sendPacket(packet) {
+        return this.send(packet);
     }
 }
 exports.Manager = Manager;
-var StateStorageType;
-(function (StateStorageType) {
-    StateStorageType["Collection"] = "collection";
-    StateStorageType["Redis"] = "redis";
-})(StateStorageType || (exports.StateStorageType = StateStorageType = {}));
-var TrackPartial;
-(function (TrackPartial) {
-    /** The base64 encoded string of the track */
-    TrackPartial["Track"] = "track";
-    /** The title of the track */
-    TrackPartial["Title"] = "title";
-    /** The track identifier */
-    TrackPartial["Identifier"] = "identifier";
-    /** The author of the track */
-    TrackPartial["Author"] = "author";
-    /** The length of the track in milliseconds */
-    TrackPartial["Duration"] = "duration";
-    /** The ISRC of the track */
-    TrackPartial["Isrc"] = "isrc";
-    /** Whether the track is seekable */
-    TrackPartial["IsSeekable"] = "isSeekable";
-    /** Whether the track is a stream */
-    TrackPartial["IsStream"] = "isStream";
-    /** The URI of the track */
-    TrackPartial["Uri"] = "uri";
-    /** The artwork URL of the track */
-    TrackPartial["ArtworkUrl"] = "artworkUrl";
-    /** The source name of the track */
-    TrackPartial["SourceName"] = "sourceName";
-    /** The thumbnail of the track */
-    TrackPartial["ThumbNail"] = "thumbnail";
-    /** The requester of the track */
-    TrackPartial["Requester"] = "requester";
-    /** The plugin info of the track */
-    TrackPartial["PluginInfo"] = "pluginInfo";
-    /** The custom data of the track */
-    TrackPartial["CustomData"] = "customData";
-})(TrackPartial || (exports.TrackPartial = TrackPartial = {}));
-var UseNodeOptions;
-(function (UseNodeOptions) {
-    UseNodeOptions["LeastLoad"] = "leastLoad";
-    UseNodeOptions["LeastPlayers"] = "leastPlayers";
-})(UseNodeOptions || (exports.UseNodeOptions = UseNodeOptions = {}));
-var SearchPlatform;
-(function (SearchPlatform) {
-    SearchPlatform["AppleMusic"] = "amsearch";
-    SearchPlatform["Bandcamp"] = "bcsearch";
-    SearchPlatform["Deezer"] = "dzsearch";
-    SearchPlatform["Jiosaavn"] = "jssearch";
-    SearchPlatform["SoundCloud"] = "scsearch";
-    SearchPlatform["Spotify"] = "spsearch";
-    SearchPlatform["Tidal"] = "tdsearch";
-    SearchPlatform["VKMusic"] = "vksearch";
-    SearchPlatform["YouTube"] = "ytsearch";
-    SearchPlatform["YouTubeMusic"] = "ytmsearch";
-})(SearchPlatform || (exports.SearchPlatform = SearchPlatform = {}));
-var AutoPlayPlatform;
-(function (AutoPlayPlatform) {
-    AutoPlayPlatform["Spotify"] = "spotify";
-    AutoPlayPlatform["Deezer"] = "deezer";
-    AutoPlayPlatform["SoundCloud"] = "soundcloud";
-    AutoPlayPlatform["Tidal"] = "tidal";
-    AutoPlayPlatform["VKMusic"] = "vkmusic";
-    AutoPlayPlatform["YouTube"] = "youtube";
-})(AutoPlayPlatform || (exports.AutoPlayPlatform = AutoPlayPlatform = {}));
-var PlayerStateEventTypes;
-(function (PlayerStateEventTypes) {
-    PlayerStateEventTypes["AutoPlayChange"] = "playerAutoplay";
-    PlayerStateEventTypes["ConnectionChange"] = "playerConnection";
-    PlayerStateEventTypes["RepeatChange"] = "playerRepeat";
-    PlayerStateEventTypes["PauseChange"] = "playerPause";
-    PlayerStateEventTypes["QueueChange"] = "queueChange";
-    PlayerStateEventTypes["TrackChange"] = "trackChange";
-    PlayerStateEventTypes["VolumeChange"] = "volumeChange";
-    PlayerStateEventTypes["ChannelChange"] = "channelChange";
-    PlayerStateEventTypes["PlayerCreate"] = "playerCreate";
-    PlayerStateEventTypes["PlayerDestroy"] = "playerDestroy";
-})(PlayerStateEventTypes || (exports.PlayerStateEventTypes = PlayerStateEventTypes = {}));
-var ManagerEventTypes;
-(function (ManagerEventTypes) {
-    ManagerEventTypes["Debug"] = "debug";
-    ManagerEventTypes["NodeCreate"] = "nodeCreate";
-    ManagerEventTypes["NodeDestroy"] = "nodeDestroy";
-    ManagerEventTypes["NodeConnect"] = "nodeConnect";
-    ManagerEventTypes["NodeReconnect"] = "nodeReconnect";
-    ManagerEventTypes["NodeDisconnect"] = "nodeDisconnect";
-    ManagerEventTypes["NodeError"] = "nodeError";
-    ManagerEventTypes["NodeRaw"] = "nodeRaw";
-    ManagerEventTypes["PlayerCreate"] = "playerCreate";
-    ManagerEventTypes["PlayerDestroy"] = "playerDestroy";
-    ManagerEventTypes["PlayerStateUpdate"] = "playerStateUpdate";
-    ManagerEventTypes["PlayerMove"] = "playerMove";
-    ManagerEventTypes["PlayerDisconnect"] = "playerDisconnect";
-    ManagerEventTypes["QueueEnd"] = "queueEnd";
-    ManagerEventTypes["SocketClosed"] = "socketClosed";
-    ManagerEventTypes["TrackStart"] = "trackStart";
-    ManagerEventTypes["TrackEnd"] = "trackEnd";
-    ManagerEventTypes["TrackStuck"] = "trackStuck";
-    ManagerEventTypes["TrackError"] = "trackError";
-    ManagerEventTypes["SegmentsLoaded"] = "segmentsLoaded";
-    ManagerEventTypes["SegmentSkipped"] = "segmentSkipped";
-    ManagerEventTypes["ChapterStarted"] = "chapterStarted";
-    ManagerEventTypes["ChaptersLoaded"] = "chaptersLoaded";
-})(ManagerEventTypes || (exports.ManagerEventTypes = ManagerEventTypes = {}));
-// PlayerStore WILL BE REMOVED IF YOU DONT FIND A USE FOR IT.