magmastream 2.9.3-dev.2 → 2.9.3-dev.20

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: {

package/dist/structures/Player.js

@@ -82,7 +82,7 @@ class Player {
                 message: "Manager instance is required.",
             });
         }
-        this.clusterId = this.manager.options.clusterId || 0;
+        this.clusterId = this.manager.options.clusterId ?? 0;
         // Check the player options for errors.
         (0, playerCheck_1.default)(options);
         this.options = {
@@ -260,21 +260,30 @@ class Player {
      */
     async destroy(disconnect = true) {
         this.state = Enums_1.StateTypes.Destroying;
+        if (this.dynamicLoopInterval) {
+            clearInterval(this.dynamicLoopInterval);
+            this.dynamicLoopInterval = null;
+        }
+        if (this.voiceReceiverReconnectTimeout) {
+            clearTimeout(this.voiceReceiverReconnectTimeout);
+            this.voiceReceiverReconnectTimeout = null;
+        }
+        if (this.voiceReceiverWsClient) {
+            this.voiceReceiverWsClient.removeAllListeners();
+            this.voiceReceiverWsClient.close();
+            this.voiceReceiverWsClient = null;
+        }
         if (disconnect) {
-            await this.disconnect().catch((err) => {
-                console.warn(`[Player#destroy] Failed to disconnect player ${this.guildId}:`, err);
-            });
+            await this.disconnect().catch(() => { });
         }
-        await this.node.rest.destroyPlayer(this.guildId).catch((err) => {
-            console.warn(`[Player#destroy] REST failed to destroy player ${this.guildId}:`, err);
-        });
-        await this.queue.clear();
-        await this.queue.clearPrevious();
-        await this.queue.setCurrent(null);
+        await this.node.rest.destroyPlayer(this.guildId).catch(() => { });
+        await this.queue.destroy();
+        this.nowPlayingMessage = undefined;
         this.manager.emit(Enums_1.ManagerEventTypes.PlayerDestroy, this);
         const deleted = this.manager.players.delete(this.guildId);
-        if (this.manager.options.stateStorage.deleteInactivePlayers)
+        if (this.manager.options.stateStorage.deleteInactivePlayers) {
             await this.manager.cleanupInactivePlayer(this.guildId);
+        }
         return deleted;
     }
     /**
@@ -806,11 +815,8 @@ class Player {
             if (currentPlayingTrack) {
                 await this.queue.add(currentPlayingTrack, 0);
             }
-            await this.play(lastTrack);
-        }
-        else {
-            await this.play(lastTrack);
         }
+        await this.play(lastTrack);
         this.manager.emit(Enums_1.ManagerEventTypes.PlayerStateUpdate, oldPlayer, this, {
             changeType: Enums_1.PlayerStateEventTypes.TrackChange,
             details: {
@@ -922,7 +928,8 @@ class Player {
             const sessionId = this.voiceState?.sessionId;
             const token = this.voiceState?.event?.token;
             const endpoint = this.voiceState?.event?.endpoint;
-            if (!sessionId || !token || !endpoint) {
+            const channelId = this.voiceState?.channelId;
+            if (!sessionId || !token || !endpoint || !channelId) {
                 this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[MANAGER] Voice state is not properly initialized for player ${this.guildId}. The bot might not be connected to a voice channel.`);
                 throw new MagmastreamError_1.MagmaStreamError({
                     code: Enums_1.MagmaStreamErrorCode.PLAYER_STATE_INVALID,
@@ -936,7 +943,7 @@ class Player {
             this.manager.players.set(this.guildId, this);
             await this.node.rest.updatePlayer({
                 guildId: this.guildId,
-                data: { paused: this.paused, volume: this.volume, position: playerPosition, encodedTrack: currentTrack?.track, voice: { token, endpoint, sessionId } },
+                data: { paused: this.paused, volume: this.volume, position: playerPosition, encodedTrack: currentTrack?.track, voice: { token, endpoint, sessionId, channelId } },
             });
             await this.filters.updateFilters();
         }
@@ -953,113 +960,6 @@ class Player {
             console.error(error);
         }
     }
-    /**
-     * Transfers the player to a new server. If the player already exists on the new server
-     * and force is false, this method will return the existing player. Otherwise, a new player
-     * will be created and the current player will be destroyed.
-     * @param {PlayerOptions} newOptions - The new options for the player.
-     * @param {boolean} force - Whether to force the creation of a new player.
-     * @returns {Promise<Player>} - The new player instance.
-     */
-    async switchGuild(newOptions, force = false) {
-        if (!newOptions.guildId) {
-            throw new MagmastreamError_1.MagmaStreamError({
-                code: Enums_1.MagmaStreamErrorCode.PLAYER_INVALID_CONFIG,
-                message: "guildId is required for switchGuild",
-            });
-        }
-        if (!newOptions.voiceChannelId) {
-            throw new MagmastreamError_1.MagmaStreamError({
-                code: Enums_1.MagmaStreamErrorCode.PLAYER_INVALID_CONFIG,
-                message: "voiceChannelId is required for switchGuild",
-            });
-        }
-        if (!newOptions.textChannelId) {
-            throw new MagmastreamError_1.MagmaStreamError({
-                code: Enums_1.MagmaStreamErrorCode.PLAYER_INVALID_CONFIG,
-                message: "textChannelId is required for switchGuild",
-            });
-        }
-        // Check if a player already exists for the new guild
-        let newPlayer = this.manager.getPlayer(newOptions.guildId);
-        // If the player already exists and force is false, return the existing player
-        if (newPlayer && !force)
-            return newPlayer;
-        const oldPlayerProperties = {
-            paused: this.paused,
-            selfMute: this.options.selfMute,
-            selfDeafen: this.options.selfDeafen,
-            volume: this.volume,
-            position: this.position,
-            queue: {
-                current: await this.queue.getCurrent(),
-                tracks: [...(await this.queue.getTracks())],
-                previous: [...(await this.queue.getPrevious())],
-            },
-            trackRepeat: this.trackRepeat,
-            queueRepeat: this.queueRepeat,
-            dynamicRepeat: this.dynamicRepeat,
-            dynamicRepeatIntervalMs: this.dynamicRepeatIntervalMs,
-            ClientUser: this.get("Internal_AutoplayUser"),
-            filters: this.filters,
-            nowPlayingMessage: this.nowPlayingMessage,
-            isAutoplay: this.isAutoplay,
-            applyVolumeAsFilter: this.options.applyVolumeAsFilter,
-        };
-        // If force is true, destroy the existing player for the new guild
-        if (force && newPlayer) {
-            await newPlayer.destroy();
-        }
-        newOptions.nodeIdentifier = newOptions.nodeIdentifier ?? this.options.nodeIdentifier;
-        newOptions.selfDeafen = newOptions.selfDeafen ?? oldPlayerProperties.selfDeafen;
-        newOptions.selfMute = newOptions.selfMute ?? oldPlayerProperties.selfMute;
-        newOptions.volume = newOptions.volume ?? oldPlayerProperties.volume;
-        newOptions.applyVolumeAsFilter = newOptions.applyVolumeAsFilter ?? oldPlayerProperties.applyVolumeAsFilter;
-        // Deep clone the current player
-        const clonedPlayer = this.manager.create(newOptions);
-        // Connect the cloned player to the new voice channel
-        clonedPlayer.connect();
-        // Update the player's state on the Lavalink node
-        await clonedPlayer.node.rest.updatePlayer({
-            guildId: clonedPlayer.guildId,
-            data: {
-                paused: oldPlayerProperties.paused,
-                volume: oldPlayerProperties.volume,
-                position: oldPlayerProperties.position,
-                encodedTrack: oldPlayerProperties.queue.current?.track,
-            },
-        });
-        await clonedPlayer.queue.setCurrent(oldPlayerProperties.queue.current);
-        await clonedPlayer.queue.addPrevious(oldPlayerProperties.queue.previous);
-        await clonedPlayer.queue.add(oldPlayerProperties.queue.tracks);
-        clonedPlayer.filters = oldPlayerProperties.filters;
-        clonedPlayer.isAutoplay = oldPlayerProperties.isAutoplay;
-        clonedPlayer.nowPlayingMessage = oldPlayerProperties.nowPlayingMessage;
-        clonedPlayer.trackRepeat = oldPlayerProperties.trackRepeat;
-        clonedPlayer.queueRepeat = oldPlayerProperties.queueRepeat;
-        clonedPlayer.dynamicRepeat = oldPlayerProperties.dynamicRepeat;
-        clonedPlayer.dynamicRepeatIntervalMs = oldPlayerProperties.dynamicRepeatIntervalMs;
-        clonedPlayer.set("Internal_AutoplayUser", oldPlayerProperties.ClientUser);
-        clonedPlayer.paused = oldPlayerProperties.paused;
-        // Update filters for the cloned player
-        await clonedPlayer.filters.updateFilters();
-        // Debug information
-        const debugInfo = {
-            success: true,
-            message: `Transferred ${await clonedPlayer.queue.size()} tracks successfully to <#${newOptions.voiceChannelId}> bound to <#${newOptions.textChannelId}>.`,
-            player: {
-                guildId: clonedPlayer.guildId,
-                voiceChannelId: clonedPlayer.voiceChannelId,
-                textChannelId: clonedPlayer.textChannelId,
-                volume: clonedPlayer.volume,
-                playing: clonedPlayer.playing,
-                queueSize: clonedPlayer.queue.size,
-            },
-        };
-        this.manager.emit(Enums_1.ManagerEventTypes.Debug, `[PLAYER] Transferred player to a new server: ${Utils_1.JSONUtils.safe(debugInfo, 2)}.`);
-        // Return the cloned player
-        return clonedPlayer;
-    }
     /**
      * Retrieves the data associated with the player.
      * @returns {Record<string, unknown>} - The data associated with the player.
@@ -1074,6 +974,13 @@ class Player {
     getDynamicLoopIntervalPublic() {
         return this.dynamicLoopInterval;
     }
+    /**
+     * Retrieves the data associated with the player.
+     * @returns {Record<string, unknown>} - The data associated with the player.
+     */
+    getSerializableData() {
+        return { ...this.data };
+    }
     /**
      * Retrieves the current lyrics for the playing track.
      * @param skipTrackSource - Indicates whether to skip the track source when fetching lyrics.

package/dist/structures/Rest.js

@@ -104,35 +104,55 @@ class Rest {
             },
             data: body,
             timeout: this.node.options.apiRequestTimeoutMs,
+            validateStatus: () => true,
         };
+        let response;
         try {
-            const response = await (0, axios_1.default)(config);
-            return response.data;
+            response = await (0, axios_1.default)(config);
         }
         catch (err) {
-            const error = err;
-            if (!error.response) {
-                throw new MagmastreamError_1.MagmaStreamError({
-                    code: Enums_1.MagmaStreamErrorCode.REST_REQUEST_FAILED,
-                    message: `No response from node ${this.node.options.identifier}: ${error.message}`,
-                });
-            }
-            const data = error.response.data;
-            if (data?.message === "Guild not found") {
-                return [];
-            }
-            if (error.response.status === 401) {
-                throw new MagmastreamError_1.MagmaStreamError({
-                    code: Enums_1.MagmaStreamErrorCode.REST_UNAUTHORIZED,
-                    message: `Unauthorized access to node ${this.node.options.identifier}`,
-                });
-            }
-            const dataMessage = typeof data === "string" ? data : data?.message ? data.message : Utils_1.JSONUtils.safe(data, 2);
+            const message = err instanceof Error ? err.message : "Unknown error";
             throw new MagmastreamError_1.MagmaStreamError({
                 code: Enums_1.MagmaStreamErrorCode.REST_REQUEST_FAILED,
-                message: `Request to node ${this.node.options.identifier} failed with status ${error.response.status}: ${dataMessage}`,
+                message: `No response from node ${this.node.options.identifier}: ${message}`,
             });
         }
+        const { status, data } = response;
+        if (status >= 200 && status < 300) {
+            return data;
+        }
+        // Lavalink sometimes returns "Guild not found" for inactive players
+        if (status === 404 && data?.message === "Guild not found") {
+            return [];
+        }
+        if (status === 401) {
+            throw new MagmastreamError_1.MagmaStreamError({
+                code: Enums_1.MagmaStreamErrorCode.REST_UNAUTHORIZED,
+                message: `Unauthorized access to node ${this.node.options.identifier}`,
+            });
+        }
+        if (status >= 400 && status < 500) {
+            const message = typeof data === "string"
+                ? data
+                : typeof data === "object" && data !== null && "message" in data && typeof data.message === "string"
+                    ? data.message
+                    : "Unknown client error";
+            return {
+                status,
+                error: true,
+                message,
+                data,
+            };
+        }
+        const safeMessage = typeof data === "string"
+            ? data
+            : typeof data === "object" && data !== null && "message" in data && typeof data.message === "string"
+                ? data.message
+                : Utils_1.JSONUtils.safe(data, 2);
+        throw new MagmastreamError_1.MagmaStreamError({
+            code: Enums_1.MagmaStreamErrorCode.REST_REQUEST_FAILED,
+            message: `Request to node ${this.node.options.identifier} failed (${status}): ${safeMessage}`,
+        });
     }
     /**
      * Sends a GET request to the specified endpoint and returns the response data.