magmastream 2.9.3-dev.3 → 2.9.3-dev.30

package/dist/structures/Manager.js

@@ -28,6 +28,8 @@ class Manager extends events_1.EventEmitter {
     initiated = false;
     redis;
     _send;
+    _getUser;
+    _getGuild;
     loadedPlugins = new Set();
     /**
      * Initiates the Manager class.
@@ -61,6 +63,10 @@ class Manager extends events_1.EventEmitter {
             this.options.clusterId = options.clusterId;
         if (options.send && !this._send)
             this._send = options.send;
+        if (options.getUser && !this._getUser)
+            this._getUser = options.getUser;
+        if (options.getGuild && !this._getGuild)
+            this._getGuild = options.getGuild;
         this.options = {
             ...options,
             enabledPlugins: options.enabledPlugins ?? [],
@@ -86,9 +92,10 @@ class Manager extends events_1.EventEmitter {
             stateStorage: {
                 ...options.stateStorage,
                 type: options.stateStorage?.type ?? Enums_1.StateStorageType.Memory,
-                deleteInactivePlayers: options.stateStorage?.deleteInactivePlayers ?? true,
+                deleteDestroyedPlayers: options.stateStorage?.deleteDestroyedPlayers ?? true,
             },
             autoPlaySearchPlatforms: options.autoPlaySearchPlatforms ?? [Enums_1.AutoPlayPlatform.YouTube],
+            listenToSIGEvents: options.listenToSIGEvents ?? true,
             send: this._send,
         };
         Utils_1.AutoPlayUtils.init(this);
@@ -96,49 +103,51 @@ class Manager extends events_1.EventEmitter {
             for (const nodeOptions of this.options.nodes)
                 new Node_1.Node(this, nodeOptions);
         }
-        process.on("SIGINT", async () => {
-            console.warn("\x1b[33mSIGINT received! Graceful shutdown initiated...\x1b[0m");
-            try {
-                await this.handleShutdown();
-                console.warn("\x1b[32mShutdown complete. Waiting for Node.js event loop to empty...\x1b[0m");
-                // Prevent forced exit by Windows
-                setTimeout(() => {
+        if (this.options.listenToSIGEvents) {
+            process.on("SIGINT", async () => {
+                console.warn("\x1b[33mSIGINT received! Graceful shutdown initiated...\x1b[0m");
+                try {
+                    await this.handleShutdown();
+                    console.warn("\x1b[32mShutdown complete. Waiting for Node.js event loop to empty...\x1b[0m");
+                    // Prevent forced exit by Windows
+                    setTimeout(() => {
+                        process.exit(0);
+                    }, 2000);
+                }
+                catch (err) {
+                    const error = err instanceof MagmastreamError_1.MagmaStreamError
+                        ? err
+                        : new MagmastreamError_1.MagmaStreamError({
+                            code: Enums_1.MagmaStreamErrorCode.MANAGER_SHUTDOWN_FAILED,
+                            message: "An unknown error occurred.",
+                            cause: err,
+                            context: { stage: "SIGINT" },
+                        });
+                    console.error(error);
+                    process.exit(1);
+                }
+            });
+            process.on("SIGTERM", async () => {
+                console.warn("\x1b[33mSIGTERM received! Graceful shutdown initiated...\x1b[0m");
+                try {
+                    await this.handleShutdown();
+                    console.warn("\x1b[32mShutdown complete. Exiting now...\x1b[0m");
                     process.exit(0);
-                }, 2000);
-            }
-            catch (err) {
-                const error = err instanceof MagmastreamError_1.MagmaStreamError
-                    ? err
-                    : new MagmastreamError_1.MagmaStreamError({
-                        code: Enums_1.MagmaStreamErrorCode.MANAGER_SHUTDOWN_FAILED,
-                        message: "An unknown error occurred.",
-                        cause: err,
-                        context: { stage: "SIGINT" },
-                    });
-                console.error(error);
-                process.exit(1);
-            }
-        });
-        process.on("SIGTERM", async () => {
-            console.warn("\x1b[33mSIGTERM received! Graceful shutdown initiated...\x1b[0m");
-            try {
-                await this.handleShutdown();
-                console.warn("\x1b[32mShutdown complete. Exiting now...\x1b[0m");
-                process.exit(0);
-            }
-            catch (err) {
-                const error = err instanceof MagmastreamError_1.MagmaStreamError
-                    ? err
-                    : new MagmastreamError_1.MagmaStreamError({
-                        code: Enums_1.MagmaStreamErrorCode.MANAGER_SHUTDOWN_FAILED,
-                        message: "An unknown error occurred.",
-                        cause: err,
-                        context: { stage: "SIGTERM" },
-                    });
-                console.error(error);
-                process.exit(1);
-            }
-        });
+                }
+                catch (err) {
+                    const error = err instanceof MagmastreamError_1.MagmaStreamError
+                        ? err
+                        : new MagmastreamError_1.MagmaStreamError({
+                            code: Enums_1.MagmaStreamErrorCode.MANAGER_SHUTDOWN_FAILED,
+                            message: "An unknown error occurred.",
+                            cause: err,
+                            context: { stage: "SIGTERM" },
+                        });
+                    console.error(error);
+                    process.exit(1);
+                }
+            });
+        }
     }
     /**
      * Initiates the Manager.
@@ -177,11 +186,15 @@ class Manager extends events_1.EventEmitter {
                 db: config.db ?? 0,
             });
         }
-        for (const node of this.nodes.values()) {
-            try {
-                await node.connect();
-            }
-            catch (err) {
+        const results = await Promise.allSettled([...this.nodes.values()].map(async (node) => {
+            await node.connect();
+            return node;
+        }));
+        for (let i = 0; i < results.length; i++) {
+            const result = results[i];
+            const node = [...this.nodes.values()][i];
+            if (result.status === "rejected") {
+                const err = result.reason;
                 const error = err instanceof MagmastreamError_1.MagmaStreamError
                     ? err
                     : new MagmastreamError_1.MagmaStreamError({
@@ -277,9 +290,7 @@ class Manager extends events_1.EventEmitter {
                     result.playlist.tracks = result.playlist.tracks.map(processTrack);
                 }
             }
-            const summary = "tracks" in result
-                ? result.tracks.map((t) => Object.fromEntries(Object.entries(t).filter(([key]) => key !== "requester")))
-                : [];
+            const summary = "tracks" in result ? result.tracks.map((t) => Object.fromEntries(Object.entries(t).filter(([key]) => key !== "requester"))) : [];
             this.emit(Enums_1.ManagerEventTypes.Debug, `[MANAGER] Result search for ${_query.query}: ${Utils_1.JSONUtils.safe(summary, 2)}`);
             return result;
         }
@@ -466,9 +477,7 @@ class Manager extends events_1.EventEmitter {
             case Enums_1.StateStorageType.Redis:
                 {
                     try {
-                        const redisKey = `${this.options.stateStorage.redisConfig.prefix?.endsWith(":")
-                            ? this.options.stateStorage.redisConfig.prefix
-                            : this.options.stateStorage.redisConfig.prefix ?? "magmastream:"}playerstore:${guildId}`;
+                        const redisKey = `${Utils_1.PlayerUtils.getRedisKey()}playerstore:${guildId}`;
                         await this.redis.set(redisKey, JSON.stringify(serializedPlayer));
                         this.emit(Enums_1.ManagerEventTypes.Debug, `[MANAGER] Player state saved to Redis: ${guildId}`);
                     }
@@ -492,6 +501,155 @@ class Manager extends events_1.EventEmitter {
     async sleep(ms) {
         return new Promise((resolve) => setTimeout(resolve, ms));
     }
+    async restorePlayerFromState(node, nodeId, guildId, state, cleanup) {
+        if (!state.guildId || state.node?.options?.identifier !== nodeId)
+            return;
+        const hasGuild = this.resolveGuild(state.guildId);
+        if (!hasGuild)
+            return;
+        const lavaPlayer = (await node.rest.get(`/v4/sessions/${state.node.sessionId}/players/${state.guildId}`));
+        if (!lavaPlayer)
+            return;
+        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,
+            applyVolumeAsFilter: state.options.applyVolumeAsFilter,
+            pauseOnDisconnect: state.options.pauseOnDisconnect,
+        };
+        const player = this.create(playerOptions);
+        this.emit(Enums_1.ManagerEventTypes.Debug, `[MANAGER] Recreating player: ${guildId}`);
+        if (state.isAutoplay) {
+            const savedUser = state.data?.clientUser;
+            if (savedUser) {
+                const autoPlayUser = await player.manager.resolveUser(savedUser);
+                player.setAutoplay(true, autoPlayUser, state.autoplayTries);
+            }
+        }
+        const savedNowPlayingMessage = state.data?.nowPlayingMessage;
+        if (savedNowPlayingMessage) {
+            player.setNowPlayingMessage(savedNowPlayingMessage);
+        }
+        await this.restoreQueue(node, player, state, lavaPlayer);
+        await this.restorePreviousQueue(player, state);
+        this.restoreRepeatState(player, state);
+        this.restorePlayerData(player, state);
+        this.restoreFilters(player, state);
+        player.connect();
+        if (lavaPlayer.track && state.clusterId !== player.clusterId) {
+            const currentTrack = state.queue.current;
+            await player.play(Utils_1.TrackUtils.build(lavaPlayer.track, currentTrack.requester, currentTrack.isAutoplay));
+            await player.seek(lavaPlayer.state.position);
+            await node.rest.delete(`/v4/sessions/${state.node.sessionId}/players/${state.guildId}`);
+        }
+        await player.pause(state.paused);
+        await cleanup();
+        this.emit(Enums_1.ManagerEventTypes.PlayerRestored, player, node);
+        await this.sleep(1000);
+    }
+    async restoreQueue(node, player, state, lavaPlayer) {
+        const currentTrack = state.queue.current;
+        const queueTracks = state.queue.tracks;
+        if (lavaPlayer.track) {
+            await player.queue.clear();
+            if (currentTrack) {
+                await player.queue.add(Utils_1.TrackUtils.build(lavaPlayer.track, currentTrack.requester, currentTrack.isAutoplay));
+            }
+            const remainingQueue = queueTracks.filter((t) => t.uri !== lavaPlayer.track.info.uri);
+            if (remainingQueue.length > 0)
+                await player.queue.add(remainingQueue);
+            player.playing = !lavaPlayer.paused;
+            return;
+        }
+        // No active lavalink track
+        if (currentTrack) {
+            if (queueTracks.length > 0) {
+                await player.queue.clear();
+                await player.queue.add(queueTracks);
+            }
+            await node.trackEnd(player, currentTrack, {
+                reason: Enums_1.TrackEndReasonTypes.Finished,
+                type: "TrackEndEvent",
+            });
+            return;
+        }
+        // No current track either — check previous
+        const previousQueue = await player.queue.getPrevious();
+        const lastTrack = previousQueue?.at(-1);
+        if (queueTracks.length > 0) {
+            await player.queue.clear();
+            await player.queue.add(queueTracks);
+        }
+        if (lastTrack || queueTracks.length > 0) {
+            await node.trackEnd(player, lastTrack, {
+                reason: Enums_1.TrackEndReasonTypes.Finished,
+                type: "TrackEndEvent",
+            });
+        }
+    }
+    async restorePreviousQueue(player, state) {
+        if (state.queue.previous.length > 0) {
+            const validPrevious = state.queue.previous.filter((t) => t !== null && typeof t.identifier === "string");
+            if (validPrevious.length > 0)
+                await player.queue.addPrevious(validPrevious);
+        }
+        else {
+            await player.queue.clearPrevious();
+        }
+    }
+    restoreRepeatState(player, state) {
+        if (state.trackRepeat)
+            player.setTrackRepeat(true);
+        if (state.queueRepeat)
+            player.setQueueRepeat(true);
+        if (state.dynamicRepeat && state.dynamicLoopInterval) {
+            player.setDynamicRepeat(state.dynamicRepeat, state.dynamicLoopInterval);
+        }
+    }
+    restorePlayerData(player, state) {
+        if (!state.data)
+            return;
+        for (const [name, value] of Object.entries(state.data)) {
+            player.set(name, value);
+        }
+    }
+    restoreFilters(player, state) {
+        const filterActions = {
+            bassboost: () => player.filters.bassBoost(state.filters.bassBoostlevel),
+            distort: (e) => player.filters.distort(e),
+            setDistortion: () => player.filters.setDistortion(state.filters.distortion),
+            eightD: (e) => player.filters.eightD(e),
+            setKaraoke: () => player.filters.setKaraoke(state.filters.karaoke),
+            nightcore: (e) => player.filters.nightcore(e),
+            slowmo: (e) => player.filters.slowmo(e),
+            soft: (e) => player.filters.soft(e),
+            trebleBass: (e) => player.filters.trebleBass(e),
+            setTimescale: () => player.filters.setTimescale(state.filters.timescale),
+            tv: (e) => player.filters.tv(e),
+            vibrato: () => player.filters.setVibrato(state.filters.vibrato),
+            vaporwave: (e) => player.filters.vaporwave(e),
+            pop: (e) => player.filters.pop(e),
+            party: (e) => player.filters.party(e),
+            earrape: (e) => player.filters.earrape(e),
+            electronic: (e) => player.filters.electronic(e),
+            radio: (e) => player.filters.radio(e),
+            setRotation: () => player.filters.setRotation(state.filters.rotation),
+            tremolo: (e) => player.filters.tremolo(e),
+            china: (e) => player.filters.china(e),
+            chipmunk: (e) => player.filters.chipmunk(e),
+            darthvader: (e) => player.filters.darthvader(e),
+            daycore: (e) => player.filters.daycore(e),
+            doubletime: (e) => player.filters.doubletime(e),
+            demon: (e) => player.filters.demon(e),
+        };
+        for (const [filter, isEnabled] of Object.entries(state.filters.filterStatus)) {
+            if (isEnabled && filterActions[filter])
+                filterActions[filter](true);
+        }
+    }
     /**
      * Loads player states from the JSON file.
      * @param nodeId The ID of the node to load player states from.
@@ -501,7 +659,6 @@ class Manager extends events_1.EventEmitter {
         this.emit(Enums_1.ManagerEventTypes.Debug, "[MANAGER] Loading saved players.");
         const node = this.nodes.get(nodeId);
         if (!node) {
-            this.emit(Enums_1.ManagerEventTypes.Debug, `[MANAGER] Tried to load non-existent node: ${nodeId}`);
             throw new MagmastreamError_1.MagmaStreamError({
                 code: Enums_1.MagmaStreamErrorCode.MANAGER_NODE_NOT_FOUND,
                 message: "Node not found.",
@@ -510,400 +667,65 @@ class Manager extends events_1.EventEmitter {
         }
         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}`);
-                        });
-                        // 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 = await node.rest.getPlayer(state.guildId);
-                                if (!lavaPlayer) {
-                                    await this.destroy(state.guildId);
-                                    continue;
-                                }
-                                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,
-                                    applyVolumeAsFilter: state.options.applyVolumeAsFilter,
-                                    pauseOnDisconnect: state.options.pauseOnDisconnect,
-                                };
-                                this.emit(Enums_1.ManagerEventTypes.Debug, `[MANAGER] Recreating player: ${state.guildId} from saved file: ${Utils_1.JSONUtils.safe(state.options, 2)}`);
-                                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) {
-                                    const savedUser = state.data.clientUser;
-                                    if (savedUser) {
-                                        const autoPlayUser = await player.manager.resolveUser(savedUser);
-                                        player.setAutoplay(true, autoPlayUser, state.autoplayTries);
-                                    }
-                                }
-                                const savedNowPlayingMessage = state.data?.nowPlayingMessage;
-                                if (savedNowPlayingMessage) {
-                                    player.setNowPlayingMessage(savedNowPlayingMessage);
-                                }
-                                if (lavaPlayer.track) {
-                                    await player.queue.clear();
-                                    if (currentTrack) {
-                                        await player.queue.add(Utils_1.TrackUtils.build(lavaPlayer.track, currentTrack.requester, currentTrack.isAutoplay));
-                                    }
-                                    const remainingQueue = queueTracks.filter((t) => t.uri !== lavaPlayer.track.info.uri);
-                                    if (remainingQueue.length > 0) {
-                                        await player.queue.add(remainingQueue);
-                                    }
-                                    player.playing = !lavaPlayer.paused;
-                                }
-                                else {
-                                    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",
-                                            });
-                                        }
-                                    }
-                                }
-                                if (state.queue.previous.length > 0) {
-                                    await player.queue.addPrevious(state.queue.previous);
-                                }
-                                else {
-                                    await player.queue.clearPrevious();
-                                }
-                                await player.pause(state.paused);
-                                if (state.trackRepeat)
-                                    player.setTrackRepeat(true);
-                                if (state.queueRepeat)
-                                    player.setQueueRepeat(true);
-                                if (state.dynamicRepeat && state.dynamicLoopInterval) {
-                                    player.setDynamicRepeat(state.dynamicRepeat, state.dynamicLoopInterval);
-                                }
-                                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),
-                                };
-                                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);
-                            }
-                            catch (error) {
-                                this.emit(Enums_1.ManagerEventTypes.Debug, `[MANAGER] Error processing player state for guild ${guildId}: ${error}`);
-                                continue;
-                            }
+            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 });
+                    });
+                    const guildDirs = await promises_1.default.readdir(playersBaseDir, { withFileTypes: true });
+                    for (const file of guildDirs) {
+                        if (!file.isDirectory())
+                            continue;
+                        const guildId = file.name;
+                        const stateFilePath = Utils_1.PlayerUtils.getPlayerStatePath(guildId);
+                        try {
+                            await promises_1.default.access(stateFilePath);
+                            const state = JSON.parse(await promises_1.default.readFile(stateFilePath, "utf-8"));
+                            await this.restorePlayerFromState(node, nodeId, guildId, state, async () => {
+                                await promises_1.default.rm(stateFilePath, { force: true });
+                                this.emit(Enums_1.ManagerEventTypes.Debug, `[MANAGER] Deleted state for guild ${guildId}`);
+                            });
                         }
-                        // 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}`);
-                                }
-                            }
-                            catch (error) {
-                                this.emit(Enums_1.ManagerEventTypes.Debug, `[MANAGER] Error deleting player state for guild ${guildId}: ${error}`);
-                                continue;
-                            }
+                        catch (error) {
+                            this.emit(Enums_1.ManagerEventTypes.Debug, `[MANAGER] Error processing guild ${guildId}: ${error}`);
                         }
                     }
-                    catch (error) {
-                        this.emit(Enums_1.ManagerEventTypes.Debug, `[MANAGER] Error loading player states: ${error}`);
-                    }
+                }
+                catch (error) {
+                    this.emit(Enums_1.ManagerEventTypes.Debug, `[MANAGER] Error loading player states: ${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 || state.node.options.identifier !== nodeId)
-                                    continue;
-                                const lavaPlayer = await node.rest.getPlayer(state.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,
-                                    applyVolumeAsFilter: state.options.applyVolumeAsFilter,
-                                    pauseOnDisconnect: state.options.pauseOnDisconnect,
-                                };
-                                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) {
-                                    const savedUser = state.data.clientUser;
-                                    if (savedUser) {
-                                        const autoPlayUser = await player.manager.resolveUser(savedUser);
-                                        player.setAutoplay(true, autoPlayUser, state.autoplayTries);
-                                    }
-                                }
-                                const savedNowPlayingMessage = state.data?.nowPlayingMessage;
-                                if (savedNowPlayingMessage) {
-                                    player.setNowPlayingMessage(savedNowPlayingMessage);
-                                }
-                                if (lavaPlayer.track) {
-                                    await player.queue.clear();
-                                    if (currentTrack) {
-                                        await player.queue.add(Utils_1.TrackUtils.build(lavaPlayer.track, currentTrack.requester, currentTrack.isAutoplay));
-                                    }
-                                    const remainingQueue = queueTracks.filter((t) => t.uri !== lavaPlayer.track.info.uri);
-                                    if (remainingQueue.length > 0) {
-                                        await player.queue.add(remainingQueue);
-                                    }
-                                    player.playing = !lavaPlayer.paused;
-                                }
-                                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();
-                                }
-                                await player.pause(state.paused);
-                                if (state.trackRepeat)
-                                    player.setTrackRepeat(true);
-                                if (state.queueRepeat)
-                                    player.setQueueRepeat(true);
-                                if (state.dynamicRepeat && state.dynamicLoopInterval) {
-                                    player.setDynamicRepeat(state.dynamicRepeat, state.dynamicLoopInterval);
-                                }
-                                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) {
-                                console.log(error);
-                                this.emit(Enums_1.ManagerEventTypes.Debug, `[MANAGER] Error processing Redis key ${key}: ${error}`);
+            }
+            case Enums_1.StateStorageType.Redis: {
+                try {
+                    const keys = await this.redis.keys(`${Utils_1.PlayerUtils.getRedisKey()}playerstore:*`);
+                    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")
+                                continue;
+                            const guildId = key.split(":").pop();
+                            if (!guildId)
+                                continue;
+                            await this.restorePlayerFromState(node, nodeId, guildId, state, async () => {
+                                await this.redis.del(key);
+                                this.emit(Enums_1.ManagerEventTypes.Debug, `[MANAGER] Deleted Redis state: ${key}`);
+                            });
+                        }
+                        catch (error) {
+                            this.emit(Enums_1.ManagerEventTypes.Debug, `[MANAGER] Error processing Redis key ${key}: ${error}`);
                         }
-                    }
-                    catch (error) {
-                        this.emit(Enums_1.ManagerEventTypes.Debug, `[MANAGER] Error loading player states from Redis: ${error}`);
                     }
                 }
+                catch (error) {
+                    this.emit(Enums_1.ManagerEventTypes.Debug, `[MANAGER] Error loading player states from Redis: ${error}`);
+                }
                 break;
-            default:
-                break;
+            }
         }
         this.emit(Enums_1.ManagerEventTypes.Debug, "[MANAGER] Finished loading saved players.");
         this.emit(Enums_1.ManagerEventTypes.RestoreComplete, node);
@@ -916,11 +738,7 @@ class Manager extends events_1.EventEmitter {
      * @returns {Node} The node to use.
      */
     get useableNode() {
-        return this.options.enablePriorityMode
-            ? this.priorityNode
-            : this.options.useNode === Enums_1.UseNodeOptions.LeastLoad
-                ? this.leastLoadNode.first()
-                : this.leastPlayersNode.first();
+        return this.options.enablePriorityMode ? this.priorityNode : this.options.useNode === Enums_1.UseNodeOptions.LeastLoad ? this.leastLoadNode.first() : this.leastPlayersNode.first();
     }
     /**
      * Handles the shutdown of the process by saving all active players' states and optionally cleaning up inactive players.
@@ -950,8 +768,6 @@ class Manager extends events_1.EventEmitter {
                 }
             });
             await Promise.allSettled(savePromises);
-            if (this.options.stateStorage.deleteInactivePlayers)
-                await this.cleanupInactivePlayers();
             setTimeout(() => {
                 console.warn("\x1b[32m%s\x1b[0m", "MAGMASTREAM INFO: Shutting down complete, exiting...");
                 process.exit(0);
@@ -1079,13 +895,10 @@ class Manager extends events_1.EventEmitter {
      */
     async handleVoiceServerUpdate(player, update) {
         player.voiceState.event = update;
-        const { sessionId, event: { token, endpoint }, } = player.voiceState;
-        await player.node.rest.updatePlayer({
-            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;
+        const sessionId = player.voiceState.sessionId;
+        const channelId = player.voiceState.channelId;
+        this.emit(Enums_1.ManagerEventTypes.Debug, `Updated voice server for player ${player.guildId} with token ${update.token} | endpoint ${update.endpoint} | sessionId ${sessionId} | channelId ${channelId}`);
+        await player.updateVoice();
     }
     /**
      * Handles a voice state update by updating the player's voice channel and session ID if provided, or by disconnecting and destroying the player if the channel ID is null.
@@ -1096,105 +909,23 @@ class Manager extends events_1.EventEmitter {
      */
     async handleVoiceStateUpdate(player, update) {
         this.emit(Enums_1.ManagerEventTypes.Debug, `Updated voice state for player ${player.guildId} with channel id ${update.channel_id} and session id ${update.session_id}`);
-        if (update.channel_id) {
-            if (player.voiceChannelId !== update.channel_id) {
-                this.emit(Enums_1.ManagerEventTypes.PlayerMove, player, player.voiceChannelId, update.channel_id);
-            }
-            player.voiceState.sessionId = update.session_id;
-            player.voiceChannelId = update.channel_id;
-            player.options.voiceChannelId = update.channel_id;
+        if (!update.channel_id) {
+            this.emit(Enums_1.ManagerEventTypes.PlayerDisconnect, player, player.voiceChannelId);
+            player.voiceChannelId = null;
+            player.state = Enums_1.StateTypes.Disconnected;
+            player.voiceState = Object.assign({});
+            if (player.options.pauseOnDisconnect)
+                await player.pause(true);
             return;
         }
-        this.emit(Enums_1.ManagerEventTypes.PlayerDisconnect, player, player.voiceChannelId);
-        player.voiceChannelId = null;
-        player.state = Enums_1.StateTypes.Disconnected;
-        player.voiceState = Object.assign({});
-        if (player.options.pauseOnDisconnect) {
-            await player.pause(true);
-        }
-        return;
-    }
-    /**
-     * 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 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 (err) {
-                        this.emit(Enums_1.ManagerEventTypes.Debug, `[MANAGER] Error cleaning up inactive JSON players: ${err}`);
-                        const error = err instanceof MagmastreamError_1.MagmaStreamError
-                            ? err
-                            : new MagmastreamError_1.MagmaStreamError({
-                                code: Enums_1.MagmaStreamErrorCode.MANAGER_CLEANUP_INACTIVE_PLAYERS_FAILED,
-                                message: "Error cleaning up inactive players.",
-                                cause: err,
-                                context: { stage: "CLEANUP_INACTIVE_PLAYERS" },
-                            });
-                        console.error(error);
-                    }
-                }
-                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`;
-                    try {
-                        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}`);
-                                }
-                            }
-                        }
-                    }
-                    catch (err) {
-                        const error = err instanceof MagmastreamError_1.MagmaStreamError
-                            ? err
-                            : new MagmastreamError_1.MagmaStreamError({
-                                code: Enums_1.MagmaStreamErrorCode.MANAGER_SHUTDOWN_FAILED,
-                                message: "Error saving player state.",
-                                cause: err,
-                                context: { stage: "CLEANUP_INACTIVE_PLAYERS" },
-                            });
-                        console.error(error);
-                    }
-                }
-                break;
-            default:
-                break;
+        if (player.voiceChannelId !== update.channel_id) {
+            this.emit(Enums_1.ManagerEventTypes.PlayerMove, player, player.voiceChannelId, update.channel_id);
         }
+        player.voiceState.sessionId = update.session_id;
+        player.voiceState.channelId = update.channel_id;
+        player.voiceChannelId = update.channel_id;
+        player.options.voiceChannelId = update.channel_id;
+        await player.updateVoice();
     }
     /**
      * Cleans up an inactive player by removing its state data.
@@ -1230,9 +961,7 @@ class Manager extends events_1.EventEmitter {
                 {
                     try {
                         if (!player) {
-                            const prefix = this.options.stateStorage.redisConfig.prefix?.endsWith(":")
-                                ? this.options.stateStorage.redisConfig.prefix
-                                : `${this.options.stateStorage.redisConfig.prefix ?? "magmastream"}:`;
+                            const prefix = Utils_1.PlayerUtils.getRedisKey();
                             const keysToDelete = [
                                 `${prefix}playerstore:${guildId}`,
                                 `${prefix}queue:${guildId}:tracks`,
@@ -1340,9 +1069,7 @@ class Manager extends events_1.EventEmitter {
                 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 prefix = Utils_1.PlayerUtils.getRedisKey();
                 const patterns = [`${prefix}playerstore:*`, `${prefix}queue:*`];
                 try {
                     for (const pattern of patterns) {
@@ -1441,6 +1168,12 @@ class Manager extends events_1.EventEmitter {
         }
         return this._send(packet);
     }
+    getUserFromCache(id) {
+        return this._getUser?.(id);
+    }
+    getGuildFromCache(id) {
+        return this._getGuild?.(id);
+    }
     sendPacket(packet) {
         return this.send(packet);
     }
@@ -1455,5 +1188,14 @@ class Manager extends events_1.EventEmitter {
             return { id: user }; // fallback by ID only
         return user; // default: just return the portable user
     }
+    /**
+     * Resolves a Guild ID to a real guild object.
+     * Can be overridden by wrapper managers to return wrapper-specific Guild classes.
+     */
+    resolveGuild(guildId) {
+        if (!guildId)
+            return null;
+        return this._getGuild?.(guildId);
+    }
 }
 exports.Manager = Manager;