aqualink 2.6.1 → 2.6.2

package/README.md

@@ -195,18 +195,18 @@ client.login("Yourtokenhere");
 <div align="center">
 <table>
 <tr>
-<td align="center" width="50%">
-  <img width="120" height="120" src="https://img.icons8.com/fluent/240/000000/musical-notes.png"/>
-  <br/>
-  <img src="https://img.shields.io/badge/Rive-0061ff?style=for-the-badge&logo=discord&logoColor=white" /><br />
-  <a href="https://discord.com/oauth2/authorize?client_id=1350601402325405806">Add to Discord</a>
-</td>
-<td align="center" width="50%">
+<td align="center" width="33%">
   <img width="120" height="120" src="https://img.icons8.com/fluent/240/000000/water-element.png"/>
   <br/>
   <img src="https://img.shields.io/badge/Kenium-00bfff?style=for-the-badge&logo=discord&logoColor=white" /><br />
   <a href="https://discord.com/oauth2/authorize?client_id=1202232935311495209">Add to Discord</a>
 </td>
+<td align="center" width="33%">
+  <img width="120" height="120" src="https://cdn.discordapp.com/attachments/1347414750463660032/1365654298989690930/soya1.jpg?ex=680e182d&is=680cc6ad&hm=3055de34e2af31a3a430f52b147a00215f8b88c8dcc9363cab5359c50ce8d75f&"/>
+  <br/>
+  <img src="https://img.shields.io/badge/SoyaMusic-22c55e?style=for-the-badge&logo=discord&logoColor=white" /><br />
+  <a href="https://discord.com/oauth2/authorize?client_id=997906613082013868&permissions=281357446481&integration_type=0&scope=bot+applications.commands">Add to Discord</a>
+</td>
 </tr>
 </table>
 </div>
@@ -237,8 +237,8 @@ For detailed usage, API references, and examples, check out our official documen
 
 | Bot | Invite Link | Features |
 |-----|-------------|----------|
-| Rive | [Add to Discord](https://discord.com/oauth2/authorize?client_id=1350601402325405806) | Music playback, Queue management |
 | Kenium | [Add to Discord](https://discord.com/oauth2/authorize?client_id=1202232935311495209) | Audio streaming, Discord integration |
+| Soya Music | [Add to Discord](https://discord.com/oauth2/authorize?client_id=997906613082013868&permissions=281357446481&integration_type=0&scope=bot+applications.commands) | Audio streaming, Discord integration |
 
 ## 🛠️ Advanced Features
 
@@ -347,4 +347,4 @@ Join our thriving community of developers and bot creators!
 
 <sub>Built with 💙 by the Aqualink Team</sub>
 
-</div>
+</div>

package/build/handlers/autoplay.js

@@ -1,142 +1,114 @@
 const https = require('https');
 const crypto = require('crypto');
 
-const agent = new https.Agent({ keepAlive: true, maxSockets: 10 });
+const agent = new https.Agent({
+    keepAlive: true,
+    maxSockets: 5,
+    maxFreeSockets: 2,
+    timeout: 8000,
+    freeSocketTimeout: 4000
+});
 
 const TOTP_SECRET = Buffer.from("5507145853487499592248630329347", 'utf8');
 
-async function quickFetch(url, options = {}, redirectCount = 0) {
-    const maxRedirects = 5;
-    
-    try {
-        return await new Promise((resolve, reject) => {
-            const req = https.get(url, { ...options, agent }, async (res) => {
-                if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
-                    if (redirectCount >= maxRedirects) {
-                        return reject(new Error('Too many redirects'));
-                    }
-                    
-                    res.resume();
-                    try {
-                        const resolved = await quickFetch(
-                            new URL(res.headers.location, url).toString(),
-                            options,
-                            redirectCount + 1
-                        );
-                        resolve(resolved);
-                    } catch (err) {
-                        reject(err);
-                    }
-                    return;
-                }
-
-                if (res.statusCode !== 200) {
-                    res.resume();
-                    return reject(new Error(`Request failed. Status code: ${res.statusCode}`));
-                }
-
-                const chunks = [];
-                let length = 0;
-                
-                res.on('data', (chunk) => {
-                    chunks.push(chunk);
-                    length += chunk.length;
-                });
-
-                res.on('end', () => {
-                    resolve(Buffer.concat(chunks, length).toString());
-                });
-            });
-
-            req.on('error', reject);
-            req.setTimeout(10000, () => {
-                req.destroy(new Error('Request timeout'));
-            });
-        });
-    } catch (err) {
-        throw err;
+const SOUNDCLOUD_REGEX = /<a\s+itemprop="url"\s+href="(\/[^"]+)"/g;
+
+const shuffleArray = (arr) => {
+    for (let i = arr.length - 1; i > 0; i--) {
+        const j = Math.random() * (i + 1) | 0;
+        [arr[i], arr[j]] = [arr[j], arr[i]];
     }
-}
+    return arr;
+};
+
+const fastFetch = (url, options = {}) => {
+    return new Promise((resolve, reject) => {
+        const req = https.get(url, { ...options, agent }, (res) => {
+            if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+                res.resume();
+                return fastFetch(new URL(res.headers.location, url).href, options)
+                    .then(resolve, reject);
+            }
+
+            if (res.statusCode !== 200) {
+                res.resume();
+                return reject(new Error(`HTTP ${res.statusCode}`));
+            }
+
+            const chunks = [];
+            res.on('data', chunk => chunks.push(chunk));
+            res.on('end', () => resolve(Buffer.concat(chunks).toString()));
+        });
+
+        req.on('error', reject);
+        req.setTimeout(8000, () => req.destroy(new Error('Timeout')));
+    });
+};
 
-async function soundAutoPlay(baseUrl) {
+const soundAutoPlay = async (baseUrl) => {
     try {
-        const html = await quickFetch(`${baseUrl}/recommended`);
-        const links = new Set();
-        const regex = /<a\s+itemprop="url"\s+href="(\/[^"]+)"/g;
+        const html = await fastFetch(`${baseUrl}/recommended`);
         
+        const links = [];
         let match;
-        while ((match = regex.exec(html)) !== null) {
-            links.add(`https://soundcloud.com${match[1]}`);
-        }
-
-        if (!links.size) {
-            throw new Error("No recommended tracks found on SoundCloud.");
+        while ((match = SOUNDCLOUD_REGEX.exec(html)) && links.length < 50) {
+            links.push(`https://soundcloud.com${match[1]}`);
         }
 
-        const urls = Array.from(links);
-        for (let i = urls.length - 1; i > 0; i--) {
-            const j = Math.random() * (i + 1) | 0;
-            [urls[i], urls[j]] = [urls[j], urls[i]];
-        }
+        if (!links.length) throw new Error("No tracks found");
 
-        return urls;
+        return shuffleArray(links);
     } catch (err) {
-        console.error("Error in SoundCloud autoplay:", err);
+        console.error("SoundCloud error:", err.message);
         return [];
     }
-}
+};
 
-function generateToken() {
-    const timeStep = Math.floor(Date.now() / 30000);
-    const counter = Buffer.alloc(8);
-    counter.writeBigInt64BE(BigInt(timeStep));
+const generateToken = () => {
+    const timeStep = (Date.now() / 30000) | 0;
+    const counter = Buffer.allocUnsafe(8);
+    counter.writeBigUInt64BE(BigInt(timeStep), 0);
 
-    const hmac = crypto.createHmac('sha1', TOTP_SECRET);
-    hmac.update(counter);
-    const hash = hmac.digest();
-    const offset = hash[hash.length - 1] & 0x0f;
+    const hash = crypto.createHmac('sha1', TOTP_SECRET).update(counter).digest();
+    const offset = hash[19] & 0x0f;
     
     const binCode = (
-        (hash[offset] << 24) |
-        (hash[offset + 1] << 16) |
-        (hash[offset + 2] << 8) |
+        (hash[offset] & 0x7f) << 24 |
+        hash[offset + 1] << 16 |
+        hash[offset + 2] << 8 |
         hash[offset + 3]
-    ) & 0x7fffffff;
+    );
 
-    const token = (binCode % 1000000).toString().padStart(6, '0');
-    return [token, timeStep * 30000];
-}
+    return [
+        (binCode % 1000000).toString().padStart(6, '0'),
+        timeStep * 30000
+    ];
+};
 
-async function spotifyAutoPlay(seedTrackId) {
+const spotifyAutoPlay = async (seedTrackId) => {
     const [totp, ts] = generateToken();
-    const params = new URLSearchParams({
-        reason: "transport",
-        productType: "embed",
-        totp,
-        totpVer: "5",
-        ts: ts.toString()
-    });
-
+    
     try {
-        const tokenData = await quickFetch(`https://open.spotify.com/get_access_token?${params}`);
-        const { accessToken } = JSON.parse(tokenData);
+        const tokenUrl = `https://open.spotify.com/api/token?reason=init&productType=embed&totp=${totp}&totpVer=5&ts=${ts}`;
+        const tokenResponse = await fastFetch(tokenUrl);
+        const { accessToken } = JSON.parse(tokenResponse);
         
-        if (!accessToken) throw new Error("Invalid access token");
+        if (!accessToken) throw new Error("No access token");
 
-        const recData = await quickFetch(
-            `https://api.spotify.com/v1/recommendations?limit=10&seed_tracks=${seedTrackId}`,
-            { headers: { Authorization: `Bearer ${accessToken}` } }
-        );
+        const recUrl = `https://api.spotify.com/v1/recommendations?limit=10&seed_tracks=${seedTrackId}`;
+        const recResponse = await fastFetch(recUrl, {
+            headers: { Authorization: `Bearer ${accessToken}` }
+        });
 
-        const { tracks } = JSON.parse(recData);
-        if (!tracks?.length) throw new Error("No tracks found");
+        const { tracks } = JSON.parse(recResponse);
+        if (!tracks?.length) throw new Error("No tracks");
 
         return tracks[Math.random() * tracks.length | 0].id;
     } catch (err) {
-        console.error("Spotify autoplay error:", err);
+        console.error("Spotify error:", err.message);
         throw err;
     }
-}
+};
 
 module.exports = {
     scAutoPlay: soundAutoPlay,

package/build/structures/Aqua.js

@@ -4,16 +4,17 @@ const Player = require("./Player");
 const Track = require("./Track");
 const { version: pkgVersion } = require("../../package.json");
 const { EventEmitter } = require('tseep');
+const fs = require('fs-extra');
 
 const URL_REGEX = /^https?:\/\//;
 const DEFAULT_OPTIONS = Object.freeze({
-  shouldDeleteMessage: false,
-  defaultSearchPlatform: 'ytsearch',
-  leaveOnEnd: true,
-  restVersion: 'v4',
-  plugins: [],
-  autoResume: false,
-  infiniteReconnects: false
+    shouldDeleteMessage: false,
+    defaultSearchPlatform: 'ytsearch',
+    leaveOnEnd: true,
+    restVersion: 'v4',
+    plugins: [],
+    autoResume: false,
+    infiniteReconnects: false
 });
 const LEAST_USED_CACHE_TTL = 50;
 
@@ -32,9 +33,9 @@ class Aqua extends EventEmitter {
         this.clientId = null;
         this.initiated = false;
         this.version = pkgVersion;
-        
+
         this.options = Object.assign({}, DEFAULT_OPTIONS, options);
-        
+
         const {
             shouldDeleteMessage,
             defaultSearchPlatform,
@@ -45,7 +46,7 @@ class Aqua extends EventEmitter {
             infiniteReconnects,
             send
         } = this.options;
-        
+
         this.shouldDeleteMessage = shouldDeleteMessage;
         this.defaultSearchPlatform = defaultSearchPlatform;
         this.leaveOnEnd = leaveOnEnd;
@@ -53,9 +54,9 @@ class Aqua extends EventEmitter {
         this.plugins = plugins;
         this.autoResume = autoResume;
         this.infiniteReconnects = infiniteReconnects;
-        
+
         this.send = send || this.defaultSendFunction.bind(this);
-        
+
         this._leastUsedCache = { nodes: [], timestamp: 0 };
     }
 
@@ -69,14 +70,14 @@ class Aqua extends EventEmitter {
         if (now - this._leastUsedCache.timestamp < LEAST_USED_CACHE_TTL) {
             return this._leastUsedCache.nodes;
         }
-        
+
         const connectedNodes = [];
         for (const node of this.nodeMap.values()) {
             if (node.connected) connectedNodes.push(node);
         }
-        
+
         connectedNodes.sort((a, b) => a.rest.calls - b.rest.calls);
-        
+
         this._leastUsedCache = { nodes: connectedNodes, timestamp: now };
         return connectedNodes;
     }
@@ -84,35 +85,35 @@ class Aqua extends EventEmitter {
     async init(clientId) {
         if (this.initiated) return this;
         this.clientId = clientId;
-        
+
         try {
             const nodePromises = [];
             for (const node of this.nodes) {
                 nodePromises.push(this.createNode(node));
             }
             await Promise.all(nodePromises);
-            
+
             for (const plugin of this.plugins) {
                 plugin.load(this);
             }
-            
+
             this.initiated = true;
         } catch (error) {
             this.initiated = false;
             throw error;
         }
-        
+
         return this;
     }
 
     async createNode(options) {
         const nodeId = options.name || options.host;
         this.destroyNode(nodeId);
-        
+
         const node = new Node(this, options, this.options);
         this.nodeMap.set(nodeId, node);
         this._leastUsedCache.timestamp = 0;
-        
+
         try {
             await node.connect();
             this.emit("nodeCreate", node);
@@ -127,7 +128,7 @@ class Aqua extends EventEmitter {
     destroyNode(identifier) {
         const node = this.nodeMap.get(identifier);
         if (!node) return;
-        
+
         node.destroy();
         this.nodeMap.delete(identifier);
         this._leastUsedCache.timestamp = 0;
@@ -137,14 +138,14 @@ class Aqua extends EventEmitter {
     updateVoiceState({ d, t }) {
         const player = this.players.get(d.guild_id);
         if (!player) return;
-        
+
         if (t === "VOICE_SERVER_UPDATE" || (t === "VOICE_STATE_UPDATE" && d.user_id === this.clientId)) {
             if (t === "VOICE_SERVER_UPDATE") {
                 player.connection?.setServerUpdate?.(d);
             } else {
                 player.connection?.setStateUpdate?.(d);
             }
-            
+
             if (d.channel_id === null) {
                 this.cleanupPlayer(player);
             }
@@ -153,23 +154,23 @@ class Aqua extends EventEmitter {
 
     fetchRegion(region) {
         if (!region) return this.leastUsedNodes;
-        
+
         const lowerRegion = region.toLowerCase();
         const regionNodes = [];
-        
+
         for (const node of this.nodeMap.values()) {
             if (node.connected && node.regions?.includes(lowerRegion)) {
                 regionNodes.push(node);
             }
         }
-        
+
         const loadCache = new Map();
         regionNodes.sort((a, b) => {
             if (!loadCache.has(a)) loadCache.set(a, this.calculateLoad(a));
             if (!loadCache.has(b)) loadCache.set(b, this.calculateLoad(b));
             return loadCache.get(a) - loadCache.get(b);
         });
-        
+
         return regionNodes;
     }
 
@@ -182,27 +183,28 @@ class Aqua extends EventEmitter {
 
     createConnection(options) {
         if (!this.initiated) throw new Error("Aqua must be initialized before this operation");
-        
+
         const existingPlayer = this.players.get(options.guildId);
         if (existingPlayer && existingPlayer.voiceChannel) return existingPlayer;
-        
+
         const availableNodes = options.region ? this.fetchRegion(options.region) : this.leastUsedNodes;
         const node = availableNodes[0];
         if (!node) throw new Error("No nodes are available");
-        
+
         return this.createPlayer(node, options);
     }
 
     createPlayer(node, options) {
         this.destroyPlayer(options.guildId);
-        
+
         const player = new Player(this, node, options);
         this.players.set(options.guildId, player);
-        
+
         player.on("destroy", () => {
             this.players.delete(options.guildId);
+            this.emit("playerDestroy", player);
         });
-        
+
         player.connect(options);
         this.emit("playerCreate", player);
         return player;
@@ -211,7 +213,7 @@ class Aqua extends EventEmitter {
     async destroyPlayer(guildId) {
         const player = this.players.get(guildId);
         if (!player) return;
-        
+
         try {
             await player.clearData();
             player.removeAllListeners();
@@ -224,18 +226,18 @@ class Aqua extends EventEmitter {
 
     async resolve({ query, source = this.defaultSearchPlatform, requester, nodes }) {
         if (!this.initiated) throw new Error("Aqua must be initialized before this operation");
-        
+
         const requestNode = this.getRequestNode(nodes);
         const formattedQuery = URL_REGEX.test(query) ? query : `${source}:${query}`;
-        
+
         try {
             const endpoint = `/v4/loadtracks?identifier=${encodeURIComponent(formattedQuery)}`;
             const response = await requestNode.rest.makeRequest("GET", endpoint);
-            
+
             if (["empty", "NO_MATCHES"].includes(response.loadType)) {
                 return await this.handleNoMatches(query);
             }
-            
+
             return this.constructResponse(response, requester, requestNode);
         } catch (error) {
             if (error.name === "AbortError") {
@@ -244,19 +246,19 @@ class Aqua extends EventEmitter {
             throw new Error(`Failed to resolve track: ${error.message}`);
         }
     }
-    
+
     getRequestNode(nodes) {
         if (!nodes) return this.leastUsedNodes[0];
-        
+
         if (nodes instanceof Node) return nodes;
         if (typeof nodes === "string") {
             const mappedNode = this.nodeMap.get(nodes);
             return mappedNode || this.leastUsedNodes[0];
         }
-        
+
         throw new TypeError(`'nodes' must be a string or Node instance, received: ${typeof nodes}`);
     }
-    
+
     async handleNoMatches(query) {
         return {
             loadType: "empty",
@@ -266,8 +268,8 @@ class Aqua extends EventEmitter {
             tracks: []
         };
     }
-    
-    constructResponse(response, requester, requestNode) {
+
+    async constructResponse(response, requester, requestNode) {
         const baseResponse = {
             loadType: response.loadType,
             exception: null,
@@ -275,28 +277,29 @@ class Aqua extends EventEmitter {
             pluginInfo: response.pluginInfo ?? {},
             tracks: []
         };
-        
+
         if (response.loadType === "error" || response.loadType === "LOAD_FAILED") {
             baseResponse.exception = response.data ?? response.exception;
             return baseResponse;
         }
-        
+
         const trackFactory = (trackData) => new Track(trackData, requester, requestNode);
-        
+
         switch (response.loadType) {
             case "track":
                 if (response.data) {
                     baseResponse.tracks.push(trackFactory(response.data));
                 }
                 break;
-
             case "playlist": {
                 const info = response.data?.info;
                 if (info) {
-                    baseResponse.playlistInfo = {
+                    const playlistInfo = {
                         name: info.name ?? info.title,
+                        thumbnail: response.data.pluginInfo?.artworkUrl ?? (response.data.tracks?.[0]?.info?.artworkUrl || null),
                         ...info
                     };
+                    baseResponse.playlistInfo = playlistInfo;
                 }
 
                 const tracks = response.data?.tracks;
@@ -322,7 +325,7 @@ class Aqua extends EventEmitter {
                 break;
             }
         }
-        
+
         return baseResponse;
     }
 
@@ -334,7 +337,7 @@ class Aqua extends EventEmitter {
 
     async search(query, requester, source = this.defaultSearchPlatform) {
         if (!query || !requester) return null;
-        
+
         try {
             const { tracks } = await this.resolve({ query, source, requester });
             return tracks || null;
@@ -344,21 +347,94 @@ class Aqua extends EventEmitter {
         }
     }
 
-    async cleanupPlayer(player) {
-        if (!player) return;
-        
+    async savePlayer(filePath = "./AquaPlayers.json") {
+        const data = Array.from(this.players.values()).map(player => ({
+            guildId: player.guildId,
+            textChannel: player.textChannel,
+            voiceChannel: player.voiceChannel,
+            track: player.current ? {
+                identifier: player.current.identifier,
+                author: player.current.author,
+                title: player.current.title,
+                uri: player.current.uri,
+                sourceName: player.current.sourceName,
+                artworkUrl: player.current.artworkUrl,
+                duration: player.current.duration,
+                position: player.position,
+            } : null,
+            requester: player.requester || player.current?.requester,
+            volume: player.volume,
+            paused: player.paused
+        }));
+        console.log(`Saving ${data.length} players to ${filePath}`);
+        await fs.writeJSON(filePath, data, { spaces: 2 });
+        this.emit("debug", "Aqua", `Saved players to ${filePath}`);
+    }
+
+    async waitForFirstNode() {
+        if (this.leastUsedNodes.length > 0) return;
+        return new Promise(resolve => {
+            const check = () => {
+                if (this.leastUsedNodes.length > 0) {
+                    resolve();
+                } else {
+                    setTimeout(check, 100);
+                }
+            };
+            check();
+        });
+    }
+
+    async loadPlayers(filePath = "./AquaPlayers.json") {
+        if (!fs.existsSync(filePath)) {
+            this.emit("debug", "Aqua", `No player data found at ${filePath}`);
+            return;
+        }
         try {
-            if (player.connection) {
-                try {
-                    await player.destroy()
-                    player.connection = null;
-                } catch (error) {
-                    console.error(`Error disconnecting player connection: ${error.message}`);
+            await this.waitForFirstNode();
+            const data = await fs.readJSON(filePath);
+            for (const playerData of data) {
+                const { guildId, textChannel, voiceChannel, track, volume, paused, requester } = playerData;
+                let player = this.players.get(guildId);
+
+                if (!player) {
+                    player = await this.createConnection({
+                        guildId: guildId,
+                        textChannel: textChannel,
+                        voiceChannel: voiceChannel,
+                        defaultVolume: volume || 65,
+                        deaf: true
+                    });
+                }
+
+                if (track && player) {
+                    const resolved = await this.resolve({ query: track.uri, requester });
+                    if (resolved.tracks && resolved.tracks.length > 0) {
+                        player.queue.add(resolved.tracks[0]);
+                        player.position = track.position || 0;
+                    } else {
+                        this.emit("debug", "Aqua", `Could not resolve track for guild ${guildId}: ${track.uri}`);
+                    }
+                }
+
+                if (player) {
+                    player.paused = paused || false;
+                    if (!player.playing && !player.paused && player.queue.size > 0) {
+                        player.play();
+                    }
                 }
             }
-            
-            this.players.delete(player.guildId);
-            this.emit("playerCleanup", player.guildId);
+            this.emit("debug", "Aqua", `Loaded players from ${filePath}`);
+        } catch (error) {
+            console.error(`Failed to load players from ${filePath}:`, error);
+        }
+    }
+
+    async cleanupPlayer(player) {
+        if (!player) return;
+
+        try {
+            await player.destroy();
         } catch (error) {
             console.error(`Error during player cleanup: ${error.message}`);
         }

package/build/structures/Node.js

@@ -96,7 +96,7 @@ class Node {
             this.aqua.emit("nodeConnected", this);
 
             if (this.autoResume && this.sessionId) {
-                await this.resumePlayers();
+                await this.aqua.loadPlayers();
             }
         } catch (err) {
             this.info = null;
@@ -245,13 +245,33 @@ class Node {
     }
 
     async getStats() {
-        if (this.connected) {
+        
+        if (this.connected && this.stats) {
             return this.stats;
         }
 
         try {
             const newStats = await this.rest.getStats();
-            Object.assign(this.stats, newStats);
+            if (newStats && this.stats) {
+                this.stats.players = newStats.players ?? this.stats.players;
+                this.stats.playingPlayers = newStats.playingPlayers ?? this.stats.playingPlayers;
+                this.stats.uptime = newStats.uptime ?? this.stats.uptime;
+                this.stats.ping = newStats.ping ?? this.stats.ping;
+                
+                if (newStats.memory) {
+                    Object.assign(this.stats.memory, newStats.memory);
+                    this._calculateMemoryPercentages();
+                }
+                
+                if (newStats.cpu) {
+                    Object.assign(this.stats.cpu, newStats.cpu);
+                    this._calculateCpuPercentages();
+                }
+                
+                if (newStats.frameStats) {
+                    Object.assign(this.stats.frameStats, newStats.frameStats);
+                }
+            }
             return this.stats;
         } catch (err) {
             this.emitError(`Failed to fetch node stats: ${err.message}`);
@@ -269,13 +289,12 @@ class Node {
 
         if (payload.memory) {
             Object.assign(this.stats.memory, payload.memory);
-            this.stats.memory.freePercentage = (this.stats.memory.free / this.stats.memory.allocated) * 100;
-            this.stats.memory.usedPercentage = (this.stats.memory.used / this.stats.memory.allocated) * 100;
+            this._calculateMemoryPercentages();
         }
 
         if (payload.cpu) {
             Object.assign(this.stats.cpu, payload.cpu);
-            this.stats.cpu.lavalinkLoadPercentage = (this.stats.cpu.lavalinkLoad / this.stats.cpu.cores) * 100;
+            this._calculateCpuPercentages();
         }
 
         if (payload.frameStats) {
@@ -283,6 +302,21 @@ class Node {
         }
     }
 
+    _calculateMemoryPercentages() {
+        const { memory } = this.stats;
+        if (memory.allocated > 0) {
+            memory.freePercentage = (memory.free / memory.allocated) * 100;
+            memory.usedPercentage = (memory.used / memory.allocated) * 100;
+        }
+    }
+
+    _calculateCpuPercentages() {
+        const { cpu } = this.stats;
+        if (cpu.cores > 0) {
+            cpu.lavalinkLoadPercentage = (cpu.lavalinkLoad / cpu.cores) * 100;
+        }
+    }
+
     _handleReadyOp(payload) {
         if (!payload.sessionId) {
             this.emitError("Ready payload missing sessionId");
@@ -297,10 +331,7 @@ class Node {
 
     async resumePlayers() {
         try {
-            await this.rest.makeRequest("PATCH", `/v4/sessions/${this.sessionId}`, {
-                resuming: true,
-                timeout: this.resumeTimeout
-            });
+            await this.aqua.loadPlayers();
 
             this.aqua.emit("debug", this.name, "Session resumed successfully");
         } catch (err) {

package/build/structures/Player.js

@@ -58,13 +58,13 @@ class Player extends EventEmitter {
         this._updateTimeout = null;
         this._dataStore = new Map();
 
-        this.on("playerUpdate", (state) => {
-            if (state) {
-                this.position = state.position ?? this.position;
-                this.timestamp = state.timestamp ?? this.timestamp;
-                this.ping = state.ping ?? this.ping;
-                this.aqua.emit("playerUpdate", this, { state });
-            }
+        this.on("playerUpdate", (packet) => {
+            this.position = packet.state.position;
+            this.connected = packet.state.connected;
+            this.ping = packet.state.ping;
+            this.timestamp = packet.state.timestamp;
+
+            this.aqua.emit("playerUpdate", this, packet);
         });
 
         this.on("event", async (payload) => {
@@ -185,18 +185,18 @@ class Player extends EventEmitter {
         return this.batchUpdatePlayer({ track: { encoded: this.current.track } }, true);
     }
 
-    connect({ deaf = true, mute = false } = {}) {
+    connect(options = this) {
+        const { guildId, voiceChannel, deaf = true, mute = false } = options;
         this.deaf = deaf;
         this.mute = mute;
-        const payload = {
-            guild_id: this.guildId,
-            channel_id: this.voiceChannel,
+        this.send({
+            guild_id: guildId,
+            channel_id: voiceChannel,
             self_deaf: deaf,
-            self_mute: mute
-        };
-        this.send(payload);
+            self_mute: mute,
+        });
         this.connected = true;
-        this.aqua.emit("debug", this.guildId, `Player connected to voice channel: ${this.voiceChannel}.`);
+        this.aqua.emit("debug", guildId, `Player connected to voice channel: ${voiceChannel}.`);
         return this;
     }
 
@@ -289,7 +289,13 @@ class Player extends EventEmitter {
         if (!channel?.length) throw new TypeError("Channel must be a non-empty string.");
         if (this.connected && channel === this.voiceChannel) throw new ReferenceError(`Player already connected to ${channel}.`);
         this.voiceChannel = channel;
-        this.connect({ deaf: this.deaf, mute: this.mute });
+        this.connect({
+            deaf: this.deaf,
+            guildId: this.guildId,
+            voiceChannel: this.voiceChannel,
+            textChannel: this.textChannel,
+            mute: this.mute,
+        });
         return this;
     }
 

package/build/structures/Rest.js

@@ -21,7 +21,7 @@ class Rest {
         this.secure = secure;
         this.timeout = timeout;
 
-        this.client = secure ? http2 || https : http;
+        this.client = secure ? https || http2 : http;
     }
 
     setSessionId(sessionId) {

package/build/structures/Track.js

@@ -10,6 +10,7 @@ class Track {
     this.identifier = info.identifier || '';
     this.isSeekable = Boolean(info.isSeekable);
     this.author = info.author || '';
+    this.position = info.position || 0;
     this.length = info.length || 0;
     this.duration = info.length || 0;
     this.isStream = Boolean(info.isStream);
@@ -29,6 +30,7 @@ class Track {
     return {
       identifier: this.identifier,
       isSeekable: this.isSeekable,
+      position: this.position,
       author: this.author,
       length: this.length,
       isStream: this.isStream,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aqualink",
-  "version": "2.6.1",
+  "version": "2.6.2",
   "description": "An Lavalink client, focused in pure performance and features",
   "main": "build/index.js",
   "types": "index.d.ts",
@@ -42,6 +42,7 @@
   },
   "dependencies": {
     "ws": "^8.18.2",
+    "fs-extra": "^11.3.0",
 		"tseep": "^1.3.1"
   },
   "maintainers": [