magmastream 2.9.3-dev.2 → 2.9.3-dev.21

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 ?? [],
@@ -177,11 +183,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 +287,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 +474,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}`);
                     }
@@ -530,10 +536,11 @@ class Manager extends events_1.EventEmitter {
                                 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 hasGuild = this.resolveGuild(state.guildId);
+                                if (!hasGuild)
+                                    continue;
                                 const lavaPlayer = await node.rest.getPlayer(state.guildId);
                                 if (!lavaPlayer) {
                                     await this.destroy(state.guildId);
@@ -558,6 +565,7 @@ class Manager extends events_1.EventEmitter {
                                             token: state.voiceState.event.token,
                                             endpoint: state.voiceState.event.endpoint,
                                             sessionId: state.voiceState.sessionId,
+                                            channelId: state.voiceState.event.channel_id,
                                         },
                                     },
                                 });
@@ -579,7 +587,7 @@ class Manager extends events_1.EventEmitter {
                                 if (lavaPlayer.track) {
                                     await player.queue.clear();
                                     if (currentTrack) {
-                                        await player.queue.add(Utils_1.TrackUtils.build(lavaPlayer.track, currentTrack.requester));
+                                        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) {
@@ -682,31 +690,18 @@ class Manager extends events_1.EventEmitter {
                                         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;
-                            }
-                        }
-                        // 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) {
+                                try {
                                     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}`);
+                                }
+                                this.emit(Enums_1.ManagerEventTypes.PlayerRestored, player, node);
+                                await this.sleep(1000);
                             }
                             catch (error) {
-                                this.emit(Enums_1.ManagerEventTypes.Debug, `[MANAGER] Error deleting player state for guild ${guildId}: ${error}`);
+                                this.emit(Enums_1.ManagerEventTypes.Debug, `[MANAGER] Error processing player state for guild ${guildId}: ${error}`);
                                 continue;
                             }
                         }
@@ -720,9 +715,7 @@ class Manager extends events_1.EventEmitter {
                 {
                     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 redisKeyPattern = `${Utils_1.PlayerUtils.getRedisKey()}playerstore:*`;
                         const keys = await this.redis.keys(redisKeyPattern);
                         for (const key of keys) {
                             try {
@@ -730,11 +723,14 @@ class Manager extends events_1.EventEmitter {
                                 if (!data)
                                     continue;
                                 const state = JSON.parse(data);
-                                if (!state || typeof state !== "object" || state.clusterId !== this.options.clusterId)
+                                if (!state || typeof state !== "object")
                                     continue;
                                 const guildId = key.split(":").pop();
                                 if (!guildId || state.node.options.identifier !== nodeId)
                                     continue;
+                                const hasGuild = this.resolveGuild(guildId);
+                                if (!hasGuild)
+                                    continue;
                                 const lavaPlayer = await node.rest.getPlayer(state.guildId);
                                 if (!lavaPlayer) {
                                     await this.destroy(guildId);
@@ -753,7 +749,14 @@ class Manager extends events_1.EventEmitter {
                                 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 } },
+                                    data: {
+                                        voice: {
+                                            token: state.voiceState.event.token,
+                                            endpoint: state.voiceState.event.endpoint,
+                                            sessionId: state.voiceState.sessionId,
+                                            channelId: state.voiceState.event.channel_id,
+                                        },
+                                    },
                                 });
                                 player.connect();
                                 // Rest of the player state restoration code (tracks, filters, etc.)
@@ -774,7 +777,7 @@ class Manager extends events_1.EventEmitter {
                                 if (lavaPlayer.track) {
                                     await player.queue.clear();
                                     if (currentTrack) {
-                                        await player.queue.add(Utils_1.TrackUtils.build(lavaPlayer.track, currentTrack.requester));
+                                        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) {
@@ -916,11 +919,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.
@@ -1079,13 +1078,17 @@ class Manager extends events_1.EventEmitter {
      */
     async handleVoiceServerUpdate(player, update) {
         player.voiceState.event = update;
-        const { sessionId, event: { token, endpoint }, } = player.voiceState;
+        const sessionId = player.voiceState.sessionId;
+        const channelId = player.voiceState.channelId;
+        const token = update.token;
+        const endpoint = update.endpoint;
+        this.emit(Enums_1.ManagerEventTypes.Debug, `Updated voice server for player ${player.guildId} with token ${token} | endpoint ${endpoint} | sessionId ${sessionId} | channelId ${channelId}`);
+        if (!sessionId || !channelId)
+            return;
         await player.node.rest.updatePlayer({
             guildId: player.guildId,
-            data: { voice: { token, endpoint, sessionId } },
+            data: { voice: { token, endpoint, sessionId, channelId } },
         });
-        this.emit(Enums_1.ManagerEventTypes.Debug, `Updated voice server for player ${player.guildId} with token ${token} and endpoint ${endpoint} and sessionId ${sessionId}`);
-        return;
     }
     /**
      * 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,22 +1099,30 @@ 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.voiceState = Object.assign({});
-        if (player.options.pauseOnDisconnect) {
-            await player.pause(true);
+        if (player.voiceChannelId !== update.channel_id) {
+            this.emit(Enums_1.ManagerEventTypes.PlayerMove, player, player.voiceChannelId, update.channel_id);
         }
-        return;
+        player.voiceState.sessionId = update.session_id;
+        player.voiceState.channelId = update.channel_id;
+        player.voiceChannelId = update.channel_id;
+        player.options.voiceChannelId = update.channel_id;
+        const token = player.voiceState.event?.token;
+        const endpoint = player.voiceState.event?.endpoint;
+        if (!token || !endpoint)
+            return;
+        await player.node.rest.updatePlayer({
+            guildId: player.guildId,
+            data: { voice: { token, endpoint, sessionId: update.session_id, channelId: update.channel_id } },
+        });
     }
     /**
      * Cleans up inactive players by removing their state files from the file system.
@@ -1154,9 +1165,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 pattern = `${prefix}queue:*:current`;
                     try {
                         const stream = this.redis.scanStream({
@@ -1229,9 +1238,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`,
@@ -1339,9 +1346,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) {
@@ -1440,6 +1445,9 @@ class Manager extends events_1.EventEmitter {
         }
         return this._send(packet);
     }
+    getUserFromCache(id) {
+        return this._getUser?.(id);
+    }
     sendPacket(packet) {
         return this.send(packet);
     }
@@ -1454,5 +1462,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;

package/dist/structures/Node.js

@@ -31,7 +31,6 @@ class Node {
     reconnectTimeout;
     reconnectAttempts = 1;
     redisPrefix;
-    sessionIdsFilePath;
     sessionIdsMap = new Map();
     /**
      * Creates an instance of Node.
@@ -97,18 +96,12 @@ class Node {
         switch (this.manager.options.stateStorage.type) {
             case Enums_1.StateStorageType.Memory:
             case Enums_1.StateStorageType.JSON:
-                this.sessionIdsFilePath = path_1.default.join(process.cwd(), "magmastream", "sessionData", "sessionIds.json");
-                const configDir = path_1.default.dirname(this.sessionIdsFilePath);
-                if (!fs_1.default.existsSync(configDir)) {
-                    fs_1.default.mkdirSync(configDir, { recursive: true });
-                }
-                this.createSessionIdsFile();
                 this.createReadmeFile();
                 break;
             case Enums_1.StateStorageType.Redis:
                 this.redisPrefix = this.manager.options.stateStorage.redisConfig.prefix?.endsWith(":")
                     ? this.manager.options.stateStorage.redisConfig.prefix
-                    : this.manager.options.stateStorage.redisConfig.prefix ?? "magmastream:";
+                    : (this.manager.options.stateStorage.redisConfig.prefix ?? "magmastream:");
                 break;
         }
     }
@@ -125,16 +118,18 @@ class Node {
     get address() {
         return `${this.options.host}:${this.options.port}`;
     }
-    /**
-     * Creates the sessionIds.json file if it doesn't exist. This file is used to
-     * store the session IDs for each node. The session IDs are used to identify
-     * the node when resuming a session.
-     */
-    createSessionIdsFile() {
-        if (!fs_1.default.existsSync(this.sessionIdsFilePath)) {
-            this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[NODE] Creating sessionId file at: ${this.sessionIdsFilePath}`);
-            fs_1.default.writeFileSync(this.sessionIdsFilePath, Utils_1.JSONUtils.safe({}), "utf-8");
-        }
+    getCompositeKey() {
+        return `${this.options.identifier}::${this.manager.options.clusterId}`;
+    }
+    getRedisSessionIdsKey() {
+        return `${this.redisPrefix}node:sessionIds`;
+    }
+    getNodeSessionsDir() {
+        return path_1.default.join(process.cwd(), "magmastream", "sessionData", "cluster", String(this.manager.options.clusterId), "nodeSessions");
+    }
+    getNodeSessionPath() {
+        const safeId = String(this.options.identifier).replace(/[^a-zA-Z0-9._-]/g, "_");
+        return path_1.default.join(this.getNodeSessionsDir(), `${safeId}.txt`);
     }
     /**
      * Loads session IDs from the sessionIds.json file if it exists.
@@ -148,49 +143,43 @@ class Node {
         switch (this.manager.options.stateStorage.type) {
             case Enums_1.StateStorageType.Memory:
             case Enums_1.StateStorageType.JSON: {
-                if (fs_1.default.existsSync(this.sessionIdsFilePath)) {
-                    this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[NODE] Loading sessionIds from file: ${this.sessionIdsFilePath}`);
-                    const sessionIdsData = fs_1.default.readFileSync(this.sessionIdsFilePath, "utf-8");
-                    this.sessionIdsMap = new Map(Object.entries(JSON.parse(sessionIdsData)));
-                    const compositeKey = `${this.options.identifier}::${this.manager.options.clusterId}`;
-                    if (this.sessionIdsMap.has(compositeKey)) {
-                        this.sessionId = this.sessionIdsMap.get(compositeKey);
-                    }
+                const dir = this.getNodeSessionsDir();
+                const filePath = this.getNodeSessionPath();
+                if (!fs_1.default.existsSync(dir))
+                    fs_1.default.mkdirSync(dir, { recursive: true });
+                if (!fs_1.default.existsSync(filePath)) {
+                    this.sessionId = null;
+                    return;
+                }
+                try {
+                    const raw = fs_1.default.readFileSync(filePath, "utf-8").trim();
+                    this.sessionId = raw.length ? raw : null;
+                    if (this.sessionId)
+                        this.sessionIdsMap.set(this.getCompositeKey(), this.sessionId);
+                }
+                catch {
+                    this.sessionId = null;
                 }
                 break;
             }
-            case Enums_1.StateStorageType.Redis:
-                const key = `${this.redisPrefix}node:sessionIds`;
-                this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[NODE] Loading sessionIds from Redis key: ${key}`);
-                const currentRaw = await this.manager.redis.get(key);
-                if (currentRaw) {
-                    try {
-                        const sessionIds = JSON.parse(currentRaw);
-                        if (typeof sessionIds !== "object" || Array.isArray(sessionIds)) {
-                            throw new MagmastreamError_1.MagmaStreamError({
-                                code: Enums_1.MagmaStreamErrorCode.NODE_SESSION_IDS_LOAD_FAILED,
-                                message: "Invalid sessionIds data type from Redis.",
-                                context: { sessionIds },
-                            });
-                        }
-                        this.sessionIdsMap = new Map(Object.entries(sessionIds));
-                        const compositeKey = `${this.options.identifier}::${this.manager.options.clusterId}`;
-                        if (this.sessionIdsMap.has(compositeKey)) {
-                            this.sessionId = this.sessionIdsMap.get(compositeKey) || null;
-                            this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[NODE] Restored sessionId for ${compositeKey}: ${this.sessionId}`);
-                        }
-                    }
-                    catch (err) {
-                        this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[NODE] Failed to parse Redis sessionIds: ${err.message}`);
-                        this.sessionIdsMap = new Map();
+            case Enums_1.StateStorageType.Redis: {
+                const key = this.getRedisSessionIdsKey();
+                const compositeKey = this.getCompositeKey();
+                this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[NODE] Loading sessionId from Redis hash: ${key} field: ${compositeKey}`);
+                try {
+                    const sid = await this.manager.redis.hget(key, compositeKey);
+                    this.sessionId = sid ?? null;
+                    if (this.sessionId) {
+                        this.sessionIdsMap.set(compositeKey, this.sessionId);
+                        this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[NODE] Restored sessionId for ${compositeKey}: ${this.sessionId}`);
                     }
                 }
-                else {
-                    this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[NODE] No sessionIds found in Redis — creating new key.`);
-                    await this.manager.redis.set(key, Utils_1.JSONUtils.safe({}));
-                    this.sessionIdsMap = new Map();
+                catch (err) {
+                    this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[NODE] Failed to load sessionId from Redis hash: ${err.message}`);
+                    this.sessionId = null;
                 }
                 break;
+            }
         }
     }
     /**
@@ -207,84 +196,53 @@ class Node {
     async updateSessionId() {
         switch (this.manager.options.stateStorage.type) {
             case Enums_1.StateStorageType.Memory:
-            case Enums_1.StateStorageType.JSON: {
-                const compositeKey = `${this.options.identifier}::${this.manager.options.clusterId}`;
-                const filePath = this.sessionIdsFilePath;
-                this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[NODE] Updating sessionIds to file: ${filePath}`);
-                let updated = false;
-                let retries = 3;
-                while (!updated && retries > 0) {
-                    try {
-                        let fileData = {};
-                        if (fs_1.default.existsSync(filePath)) {
-                            try {
-                                const raw = fs_1.default.readFileSync(filePath, "utf-8");
-                                fileData = raw.trim() ? JSON.parse(raw) : {};
-                            }
-                            catch (err) {
-                                this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[NODE] Failed to read/parse sessionIds.json: ${err.message}`);
-                                fileData = {};
-                            }
-                        }
-                        fileData[compositeKey] = this.sessionId;
-                        const tmpPath = `${filePath}.tmp`;
-                        fs_1.default.writeFileSync(tmpPath, Utils_1.JSONUtils.safe(fileData, 2), "utf-8");
-                        fs_1.default.renameSync(tmpPath, filePath);
-                        this.sessionIdsMap = new Map(Object.entries(fileData));
-                        updated = true;
-                    }
-                    catch (err) {
-                        retries--;
-                        if (retries === 0) {
-                            throw new MagmastreamError_1.MagmaStreamError({
-                                code: Enums_1.MagmaStreamErrorCode.NODE_SESSION_IDS_UPDATE_FAILED,
-                                message: `Failed to update sessionIds after retries.`,
-                                cause: err instanceof Error ? err : undefined,
-                                context: { filePath, compositeKey, storage: "file" },
-                            });
-                        }
-                        await new Promise((r) => setTimeout(r, 50));
-                    }
-                }
-                break;
+            case Enums_1.StateStorageType.JSON:
+                return this.updateSessionIdFile();
+            case Enums_1.StateStorageType.Redis:
+                return this.updateSessionIdRedis();
+        }
+    }
+    async updateSessionIdFile() {
+        const dir = this.getNodeSessionsDir();
+        const filePath = this.getNodeSessionPath();
+        const tmpPath = `${filePath}.tmp`;
+        if (!fs_1.default.existsSync(dir))
+            fs_1.default.mkdirSync(dir, { recursive: true });
+        if (this.sessionId) {
+            fs_1.default.writeFileSync(tmpPath, this.sessionId, "utf-8");
+            fs_1.default.renameSync(tmpPath, filePath);
+            this.sessionIdsMap.set(this.getCompositeKey(), this.sessionId);
+        }
+        else {
+            try {
+                if (fs_1.default.existsSync(filePath))
+                    fs_1.default.unlinkSync(filePath);
             }
-            case Enums_1.StateStorageType.Redis: {
-                const key = `${this.redisPrefix}node:sessionIds`;
-                const compositeKey = `${this.options.identifier}::${this.manager.options.clusterId}`;
-                this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[NODE] Updating sessionIds in Redis key: ${key}`);
-                let sessionIds = {};
-                try {
-                    const currentRaw = await this.manager.redis.get(key);
-                    if (currentRaw) {
-                        sessionIds = JSON.parse(currentRaw);
-                        if (typeof sessionIds !== "object" || Array.isArray(sessionIds)) {
-                            throw new Error("Invalid data type in Redis");
-                        }
-                    }
-                    else {
-                        this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[NODE] Redis key not found — creating new sessionIds key.`);
-                        sessionIds = {};
-                    }
-                }
-                catch (err) {
-                    this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[NODE] Corrupted Redis sessionIds, reinitializing: ${err.message}`);
-                    sessionIds = {};
-                }
-                try {
-                    sessionIds[compositeKey] = this.sessionId;
-                    this.sessionIdsMap = new Map(Object.entries(sessionIds));
-                    await this.manager.redis.set(key, Utils_1.JSONUtils.safe(sessionIds));
-                }
-                catch (err) {
-                    throw new MagmastreamError_1.MagmaStreamError({
-                        code: Enums_1.MagmaStreamErrorCode.NODE_SESSION_IDS_UPDATE_FAILED,
-                        message: `Failed to update sessionIds in Redis.`,
-                        cause: err instanceof Error ? err : undefined,
-                        context: { key, compositeKey, storage: "redis" },
-                    });
-                }
-                break;
+            catch { }
+            this.sessionIdsMap.delete(this.getCompositeKey());
+        }
+    }
+    async updateSessionIdRedis() {
+        const key = this.getRedisSessionIdsKey();
+        const compositeKey = this.getCompositeKey();
+        this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[NODE] Updating sessionId in Redis hash: ${key} field: ${compositeKey}`);
+        try {
+            if (this.sessionId) {
+                await this.manager.redis.hset(key, compositeKey, this.sessionId);
+                this.sessionIdsMap.set(compositeKey, this.sessionId);
             }
+            else {
+                await this.manager.redis.hdel(key, compositeKey);
+                this.sessionIdsMap.delete(compositeKey);
+            }
+        }
+        catch (err) {
+            throw new MagmastreamError_1.MagmaStreamError({
+                code: Enums_1.MagmaStreamErrorCode.NODE_SESSION_IDS_UPDATE_FAILED,
+                message: "Failed to update sessionId in Redis hash.",
+                cause: err instanceof Error ? err : undefined,
+                context: { key, compositeKey, storage: "redis-hash" },
+            });
         }
     }
     /**
@@ -305,12 +263,7 @@ class Node {
             "User-Id": this.manager.options.clientId,
             "Client-Name": this.manager.options.clientName,
         };
-        const compositeKey = `${this.options.identifier}::${this.manager.options.clusterId}`;
-        if (this.sessionId) {
-            headers["Session-Id"] = this.sessionId;
-        }
-        else if (this.options.enableSessionResumeOption && this.sessionIdsMap.has(compositeKey)) {
-            this.sessionId = this.sessionIdsMap.get(compositeKey) || null;
+        if (typeof this.sessionId === "string" && this.sessionId.length > 0) {
             headers["Session-Id"] = this.sessionId;
         }
         this.socket = new ws_1.default(`ws${this.options.useSSL ? "s" : ""}://${this.address}/v4/websocket`, { headers });
@@ -356,9 +309,7 @@ class Node {
         // Automove all players connected to that node
         const players = this.manager.players.filter((p) => p.node == this);
         if (players.size) {
-            for (const player of players.values()) {
-                await player.autoMoveNode();
-            }
+            await Promise.all(Array.from(players.values(), (player) => player.autoMoveNode()));
         }
         this.socket.close(1000, "destroy");
         this.socket.removeAllListeners();
@@ -632,12 +583,7 @@ class Node {
         player.playing = true;
         player.paused = false;
         this.manager.emit(Enums_1.ManagerEventTypes.TrackStart, player, track, payload);
-        const AutoplayUser = player.get("Internal_AutoplayUser");
-        if (!track.requester || !track.requester.id) {
-            console.log(track);
-            console.warn(`[WARN] Track requester missing for guild ${player.guildId}`, track);
-        }
-        if (AutoplayUser && track.requester && AutoplayUser.id === track.requester.id) {
+        if (track.isAutoplay) {
             this.manager.emit(Enums_1.ManagerEventTypes.PlayerStateUpdate, oldPlayer, player, {
                 changeType: Enums_1.PlayerStateEventTypes.TrackChange,
                 details: {