aqualink 1.6.2-beta → 1.7.0-beta1

package/README.md

@@ -25,41 +25,51 @@ This code is based in riffy, but its an 100% Rewrite made from scratch...
 
 - Example bot: https://github.com/ToddyTheNoobDud/Thorium-Music
 
-# Omg version 1.6.0 || 1.6.1 || 1.6.2 woah aqualink
+# Real changelog for 1.7.0-beta1
+Note: Not features are widely tested / Not fully Complete
+
+- Reformated the `PLAYER` System (removed Documentation for now)
+  - Notable Changes:
+  - New WeakMap System (Properly handling, deleting, setting)
+  - Around 2x faster (by my tests, taked 0ms to resolve an song)
+  - Uses less recourses (reduced by around ~0,5mb, also less cpu instensive)
+
+- Fix Some errors in `REST`, Now destroyPlayer, etc, should work as expected.
+- Rewrited out the `TRACK` System
+  - Reduced object creation
+  - Use direct acess
+  - use direct destroy() instead of Object.assing()
+  - Separate _findMatchingTrack()
+  - Rewrite the search system, Removed useless caching, Improved speed, use traditional for ... of instead of find() - Experimental
+
+- Rewrited out the `NODE` System
+  - Implement the InfiniteReconnects Option (this will make the code try to connect to an node non-stop.)
+  - WeakMap has been replaced with statsCache (experimental)
+  - Optimized by using free, used and allocated direct.
+  - Backoff in reconnect logic (by using Math)
+  - Clear reconnectTimeoutId (prevent memory leaks)
+  - Improve the overall speed by a bit
+
+- Rewrited the `CONNECTION` System
+  - Improved the Connecting, Resolving, Reconnecting Speed (around 1,5x faster now)
+  - Improved checking
+  - Cached frequently used Code
+  - Object.assign Implemented for Batch updates
+  - Still in testing, pls report bugs
+
+- Some Additions for `AQUA`
+  - Implement the InfiniteReconnects Options
+  - Re-added our DOCS (Now autocomplete works again!)
+  - Add platforms + search system on DefaultPlatform
+
+  - Rewrited the updateVoiceState System
+  - Misc changes to createConnection
+  - Document + fix destroyPlayer
+
+- Remade some stuff in `FetchImage`
+  - Use promise.race since only first sucess is required. (will be tested, may revert to promise.any)
+  - Use map cuz its faster and more efficient than Objects.
 
-Version 1.6.2
-- Fixed the rejected error (connection, for example using destroy returns an error)
-- Added bun support (now it should work with bun too)
-
-Version 1.6.1:
-
-- Many fixes related to caching and mapping.
-- Rewrited `AQUA` again, Should fix a lot of stuff related to speed, async memory leaks, remade some methods, and others stuff;
-- Rewrited `CONNECTION` manager again, should be an better cleanup system less memory leaks, correct updating.
-- Fixed various stuff + Various speed improvements, and way less recourses used on `NODE` manager.
-- Updated `REST` Manager to use better checkings, speed, and dumping system.
-- Rewrote the `TRACK` System, fixed small memory leaks, improved speed by wayyy more
-- Some misc changes on player, small optimziations, use Fisher-Yates algorithm, and remove useless asyncs.
-- Improved the internal code Garbage collection.
-- Use more WeakSet and WeakMaps for memory friendly
-- Extra: Also fixed requesting every 1 sec, reducing the requests system and memory usage by a lot i think;
--- Im working on new features, ex: autoplay, lyrics system, and more to come... its hard to me as an solo dev
-
-
-Version 1.6.0:
-
-- Reworked the `TRACK` Manager (This improves the speed by wayyy more, also uses objects, removed useless code)
-- Improved the `REST` Manager (This improves the garbage collector, an faster code, and more optimized)
-- Added enqueue to `QUEUE` (this gets the previous, made for dev), removed addMultiple (useless)
-- Fully Rewrite the `PLAYER` Manager (Way faster resolving, way less recourse intensive, more responsive, better error handling)
-
-^^ Now uses the WeakMap and WeakSet for an garbage collector, making it with an better memory management.
-
-- Rewrite the `NODE` Manager (reconnect speeds improved, various methods improved, Rewrite the cache and status handler, improve the performance) - Also fixed player resuming.
-- Remade some stuff in `CONNECTION` (this improves error handling, cleaning up, and speed)
-- Rewrite `AQUA` Manager (remade every single method, improved the resolve, made the code dynamic, fixed lots of bugs, uses weakMap too.) - Added autoResume option (true false)
-
-- There are way more stuff that i forgot to add on changelog. pls report bugs on my github !
 # How to install
 
 `npm install aqualink`

package/build/handlers/fetchImage.js

@@ -1,47 +1,59 @@
 const { request } = require("undici");
 
-const YOUTUBE_URLS = [
-    (id) => `https://img.youtube.com/vi/${id}/maxresdefault.jpg`,
-    (id) => `https://img.youtube.com/vi/${id}/hqdefault.jpg`,
-    (id) => `https://img.youtube.com/vi/${id}/mqdefault.jpg`,
-    (id) => `https://img.youtube.com/vi/${id}/default.jpg`,
-];
+const sourceHandlers = new Map([
+    ['spotify', (uri) => fetchThumbnail(`https://open.spotify.com/oembed?url=${uri}`)],
+    ['youtube', (identifier) => fetchYouTubeThumbnail(identifier)]
+]);
+
+const YOUTUBE_URL_TEMPLATE = (quality) => 
+    (id) => `https://img.youtube.com/vi/${id}/${quality}.jpg`;
+
+const YOUTUBE_QUALITIES = [
+    'maxresdefault',
+    'hqdefault',
+    'mqdefault',
+    'default'
+].map(YOUTUBE_URL_TEMPLATE);
 
 async function getImageUrl(info) {
-    if (!info || !info.sourceName || !info.uri) return null;
-
-    switch (info.sourceName.toLowerCase()) {
-        case "spotify":
-            return await fetchThumbnail(`https://open.spotify.com/oembed?url=${info.uri}`);
-        case "youtube":
-            return await fetchYouTubeThumbnail(info.identifier);
-        default:
-            return null;
+    if (!info?.sourceName || !info?.uri) return null;
+
+    const handler = sourceHandlers.get(info.sourceName.toLowerCase());
+    if (!handler) return null;
+
+    try {
+        return await handler(info.uri);
+    } catch {
+        return null;
     }
 }
 
 async function fetchThumbnail(url) {
     try {
-        const { body } = await request(url, { method: "GET" });
+        const { body } = await request(url, {
+            method: "GET",
+            headers: {
+                'Accept': 'application/json'
+            }
+        });
+
         const json = await body.json();
-        await body.dump();
         return json.thumbnail_url || null;
-    } catch (error) {
-        console.error(`Error fetching ${url}:`, error);
+    } catch {
         return null;
     }
 }
 
 async function fetchYouTubeThumbnail(identifier) {
-    const fetchPromises = YOUTUBE_URLS.map(urlFunc => fetchThumbnail(urlFunc(identifier)));
-    const results = await Promise.allSettled(fetchPromises);
+    const fetchPromises = YOUTUBE_QUALITIES.map(urlFunc => 
+        fetchThumbnail(urlFunc(identifier))
+    );
 
-    for (const result of results) {
-        if (result.status === "fulfilled" && result.value) {
-            return result.value; 
-        }
+    try {
+        return await Promise.race(fetchPromises);
+    } catch {
+        return null;
     }
-    return null;
 }
 
 module.exports = { getImageUrl };

package/build/structures/Aqua.js

@@ -5,6 +5,27 @@ const { Track } = require("./Track");
 const { version: pkgVersion } = require("../../package.json");
 const URL_REGEX = /^https?:\/\//;
 class Aqua extends EventEmitter {
+    /**
+     * @param {Object} client - The client instance.
+     * @param {Array<Object>} nodes - An array of node configurations.
+     * @param {Object} options - Configuration options for Aqua.
+     * @param {Function} options.send - Function to send data.
+     * @param {string} [options.defaultSearchPlatform="ytsearch"] - Default search platform. Options include:
+     *     - "youtube music": "ytmsearch"
+     *     - "youtube": "ytsearch"
+     *     - "spotify": "spsearch"
+     *     - "jiosaavn": "jssearch"
+     *     - "soundcloud": "scsearch"
+     *     - "deezer": "dzsearch"
+     *     - "tidal": "tdsearch"
+     *     - "applemusic": "amsearch"
+     *     - "bandcamp": "bcsearch"
+     * @param {string} [options.restVersion="v4"] - Version of the REST API.
+     * @param {Array<Object>} [options.plugins=[]] - Plugins to load.
+     * @param {string} [options.shouldDeleteMessage='none'] - Should delete your message? (true, false)
+     * @param {boolean} [options.autoResume=false] - Automatically resume tracks on reconnect.
+     * @param {boolean} [options.infiniteReconnects=false] - Reconnect infinitely (default: false).
+     */
     constructor(client, nodes, options) {
         super();
         this.validateInputs(client, nodes, options);
@@ -22,9 +43,11 @@ class Aqua extends EventEmitter {
         this.options = options;
         this.send = options.send;
         this.autoResume = options.autoResume || false;
+        this.infiniteReconnects = options.infiniteReconnects || false;
         this.setMaxListeners(0);
     }
 
+
     validateInputs(client, nodes, options) {
         if (!client) throw new Error("Client is required to initialize Aqua");
         if (!Array.isArray(nodes) || !nodes.length) throw new Error(`Nodes must be a non-empty Array (Received ${typeof nodes})`);
@@ -78,17 +101,13 @@ class Aqua extends EventEmitter {
         }
     }
 
-    updateVoiceState(packet) {
-        if (!packet?.d?.guild_id) return;
-        const player = this.players.get(packet.d.guild_id);
-        if (!player) return;
-        const updateType = packet.t === "VOICE_SERVER_UPDATE" ? "setServerUpdate" : "setStateUpdate";
-        player.connection[updateType](packet.d);
-        if (packet.d.status === "disconnected") {
-            this.cleanupPlayer(player);
+    updateVoiceState({ d, t }) {
+        const player = this.players.get(d.guild_id);
+        if (player && (t === "VOICE_SERVER_UPDATE" || t === "VOICE_STATE_UPDATE" && d.user_id === this.clientId)) {
+            player.connection[t === "VOICE_SERVER_UPDATE" ? "setServerUpdate" : "setStateUpdate"](d);
+            if (d.status === "disconnected") this.cleanupPlayer(player);
         }
     }
-
     fetchRegion(region) {
         if (!region) return this.leastUsedNodes;
         const lowerRegion = region.toLowerCase();
@@ -104,8 +123,8 @@ class Aqua extends EventEmitter {
 
     createConnection(options) {
         this.ensureInitialized();
-        const existingPlayer = this.players.get(options.guildId);
-        if (existingPlayer?.voiceChannel) return existingPlayer;
+        const player = this.players.get(options.guildId);
+        if (player && player.voiceChannel) return player;
         const node = options.region ? this.fetchRegion(options.region)[0] : this.leastUsedNodes[0];
         if (!node) throw new Error("No nodes are available");
         return this.createPlayer(node, options);
@@ -121,21 +140,22 @@ class Aqua extends EventEmitter {
         return player;
     }
 
-    destroyPlayer(guildId) {
-        const player = this.players.get(guildId);
-        if (!player) return;
-        try {
-            player.clearData();
-            player.removeAllListeners();
-            player.destroy();
-            this.players.delete(guildId);
-            this.emit("playerDestroy", player);
-        } catch (error) {
-            console.error(`Error destroying player for guild ${guildId}:`, error);
-        }
+async destroyPlayer(guildId) {
+    const player = this.players.get(guildId);
+    if (!player) return;
+
+    try {
+        // Ensure that clearData and destroy are awaited if they are async
+        await player.clearData(); // Assuming clearData is an async function
+        player.removeAllListeners(); // This should not cause an infinite loop
+        this.players.delete(guildId);
+        this.emit("playerDestroy", player);
+    } catch (error) {
+        console.error(`Error destroying player for guild ${guildId}:`, error);
     }
+}
 
-    async resolve({ query, source = this.defaultSearchPlatform, requester, nodes }) {
+    async resolve({ query, source = this.defaultSearchPlatform , requester, nodes }) {
         this.ensureInitialized();
         const requestNode = this.getRequestNode(nodes);
         const formattedQuery = this.formatQuery(query, source);
@@ -263,4 +283,4 @@ class Aqua extends EventEmitter {
     }
 }
 
-module.exports = { Aqua };
+module.exports = { Aqua };

package/build/structures/Connection.js

@@ -1,85 +1,106 @@
 class Connection {
     constructor(player) {
-        this.player = player;
-        this.voice = { sessionId: null, endpoint: null, token: null };
-        this.region = null;
-        this.selfDeaf = false;
-        this.selfMute = false;
-        this.voiceChannel = player.voiceChannel;
-        this.lastUpdateTime = 0;
-        this.updateThrottle = 1000; // Throttle time in milliseconds
+      Object.assign(this, {
+        player,
+        voice: { sessionId: null, endpoint: null, token: null },
+        region: null,
+        selfDeaf: false,
+        selfMute: false,
+        voiceChannel: player.voiceChannel,
+        _guildId: player.guildId,
+        _aqua: player.aqua,
+        _nodes: player.nodes
+      });
     }
-
-    setServerUpdate({ endpoint, token }) {
-        if (!endpoint) throw new Error("Missing 'endpoint' property in VOICE_SERVER_UPDATE");
+  
+    setServerUpdate(data) {
+      const endpoint = data.endpoint;
+      if (!endpoint) throw new Error("Missing 'endpoint' property");
+  
+      const dotIndex = endpoint.indexOf('.');
+      if (dotIndex === -1) return;
+      
+      const newRegion = endpoint.substring(0, dotIndex).replace(/[0-9]/g, '');
+      
+      if (this.region !== newRegion) {
+        const prevRegion = this.region;
         
-        const newRegion = endpoint.split('.')[0].replace(/[0-9]/g, "");
-        if (this.region !== newRegion) {
-            this.updateRegion(newRegion, endpoint, token);
-        }
-        this.updatePlayerVoiceData();
-    }
-
-    updateRegion(newRegion, endpoint, token) {
-        const previousVoiceRegion = this.region;
+        Object.assign(this.voice, {
+          endpoint,
+          token: data.token
+        });
         this.region = newRegion;
-        this.voice.endpoint = endpoint;
-        this.voice.token = token;
-
-        const message = previousVoiceRegion 
-            ? `Changed Voice Region from ${previousVoiceRegion} to ${this.region}` 
-            : `Voice Server: ${this.region}`;
-        
-        this.player.aqua.emit("debug", `[Player ${this.player.guildId} - CONNECTION] ${message}`);
+  
+        this._aqua.emit(
+          "debug",
+          `[Player ${this._guildId} - CONNECTION] ${
+            prevRegion 
+              ? `Changed Voice Region from ${prevRegion} to ${newRegion}`
+              : `Voice Server: ${newRegion}`
+          }`
+        );
+      }
+  
+      this._updatePlayerVoiceData();
     }
+  
 
     setStateUpdate(data) {
-        if (!data.channel_id || !data.session_id) {
-            this.cleanup();
-            return;
-        }
+      const channelId = data.channel_id;
+      const sessionId = data.session_id;
+  
+      if (!channelId || !sessionId) {
+        this._cleanup();
+        return;
+      }
 
-        if (this.voiceChannel !== data.channel_id) {
-            this.player.aqua.emit("playerMove", this.voiceChannel, data.channel_id);
-            this.voiceChannel = data.channel_id;
-        }
-
-        this.selfDeaf = data.self_deaf;
-        this.selfMute = data.self_mute;
-        this.voice.sessionId = data.session_id;
+      if (this.voiceChannel !== channelId) {
+        this._aqua.emit("playerMove", this.voiceChannel, channelId);
+        this.voiceChannel = channelId;
+      }
+  
+      Object.assign(this, {
+        selfDeaf: data.self_deaf,
+        selfMute: data.self_mute
+      });
+      this.voice.sessionId = sessionId;
     }
-
-    updatePlayerVoiceData() {
-        const currentTime = Date.now();
-        if (currentTime - this.lastUpdateTime >= this.updateThrottle) {
-            this.lastUpdateTime = currentTime;
-
-            const data = {
-                voice: this.voice,
-                volume: this.player.volume,
-            };
-
-            this.player.nodes.rest.updatePlayer({
-                guildId: this.player.guildId,
-                data,
-            }).catch(err => {
-                this.player.aqua.emit("apiError", "updatePlayer", err);
-            });
+  
+    _updatePlayerVoiceData() {
+      this._nodes.rest.updatePlayer({
+        guildId: this._guildId,
+        data: {
+          voice: this.voice,
+          volume: this.player.volume
         }
+      }).catch(err => {
+        this._aqua.emit("apiError", "updatePlayer", err);
+      });
     }
-
-    cleanup() {
-        this.player.aqua.emit("playerLeave", this.player.voiceChannel);
-        this.player.voiceChannel = null;
-        this.voiceChannel = null;
-        this.player.destroy();
-        this.player.aqua.emit("playerDestroy", this.player);
-        this.player = null;
-        this.voice = null;
-        this.region = null;
-        this.selfDeaf = null;
-        this.selfMute = null;
+  
+    _cleanup() {
+      const aqua = this._aqua;
+      const channel = this.player.voiceChannel;
+      
+      aqua.emit("playerLeave", channel);
+      
+      this.player.voiceChannel = null;
+      this.voiceChannel = null;
+      this.player.destroy();
+      
+      aqua.emit("playerDestroy", this.player);
+  
+      Object.assign(this, {
+        player: null,
+        voice: null,
+        region: null,
+        selfDeaf: null,
+        selfMute: null,
+        _guildId: null,
+        _aqua: null,
+        _nodes: null
+      });
     }
-}
-
-module.exports = { Connection };
+  }
+  
+  module.exports = { Connection };

package/build/structures/Node.js

@@ -2,24 +2,21 @@ const WebSocket = require("ws");
 const { Rest } = require("./Rest");
 
 class Node {
-    // Private fields using # for better encapsulation
     #ws = null;
-    #statsCache = new WeakMap();
+    #statsCache = {};
     #lastStatsRequest = 0;
     #reconnectAttempted = 0;
-
     constructor(aqua, nodes, options) {
-        const { 
-            name, 
-            host = "localhost", 
-            port = 2333, 
+        const {
+            name,
+            host = "localhost",
+            port = 2333,
             password = "youshallnotpass",
             secure = false,
             sessionId = null,
             regions = []
         } = nodes;
 
-        // Core properties
         this.aqua = aqua;
         this.name = name || host;
         this.host = host;
@@ -28,23 +25,16 @@ class Node {
         this.secure = secure;
         this.sessionId = sessionId;
         this.regions = regions;
-        
-        // Configuration
         this.wsUrl = new URL(`ws${secure ? 's' : ''}://${host}:${port}/v4/websocket`);
         this.rest = new Rest(aqua, this);
-        
-        // Connection options
         this.resumeKey = options?.resumeKey ?? null;
         this.resumeTimeout = options?.resumeTimeout ?? 60;
         this.autoResume = options?.autoResume ?? false;
         this.reconnectTimeout = options?.reconnectTimeout ?? 2000;
         this.reconnectTries = options?.reconnectTries ?? 3;
-        
-        // State
+        this.infiniteReconnects = options?.infiniteReconnects ?? false;
         this.connected = false;
         this.info = null;
-        
-        // Initialize stats with frozen objects to prevent modifications
         this.stats = Object.freeze(this.#createStats());
     }
 
@@ -78,16 +68,13 @@ class Node {
 
     async connect() {
         this.#cleanup();
-        
         try {
             this.#ws = new WebSocket(this.wsUrl.href, {
                 headers: this.#constructHeaders(),
-                perMessageDeflate: false // Disable compression for better performance
+                perMessageDeflate: false
             });
-            
             this.#setupWebSocketListeners();
             this.aqua.emit('debug', this.name, 'Connecting...');
-            
         } catch (err) {
             this.aqua.emit('debug', this.name, `Connection failed: ${err.message}`);
             this.#reconnect();
@@ -98,9 +85,10 @@ class Node {
         if (this.#ws) {
             try {
                 this.#ws.removeAllListeners();
-                this.#ws.terminate(); // Force close connection
-            } catch {} 
-            finally {
+                this.#ws.terminate();
+            } catch (err) {
+                this.aqua.emit('debug', `Cleanup error: ${err.message}`);
+            } finally {
                 this.#ws = null;
             }
         }
@@ -112,18 +100,14 @@ class Node {
             "User-Id": this.aqua.clientId,
             "Client-Name": `Aqua/${this.aqua.version}`,
         };
-        
         if (this.sessionId) headers["Session-Id"] = this.sessionId;
         if (this.resumeKey) headers["Resume-Key"] = this.resumeKey;
-        
         return Object.freeze(headers);
     }
 
     #setupWebSocketListeners() {
         if (!this.#ws) return;
-
         const ws = this.#ws;
-        
         ws.once("open", this.#onOpen.bind(this));
         ws.once("error", this.#onError.bind(this));
         ws.on("message", this.#onMessage.bind(this));
@@ -133,30 +117,27 @@ class Node {
     async #onOpen() {
         this.connected = true;
         this.aqua.emit('debug', this.name, `Connected to ${this.wsUrl.href}`);
-        
         try {
             this.info = await this.rest.makeRequest("GET", "/v4/info");
             this.autoResume && await this.resumePlayers();
         } catch (err) {
             this.info = null;
-            !this.aqua.bypassChecks?.nodeFetchInfo && 
+            !this.aqua.bypassChecks?.nodeFetchInfo &&
                 this.aqua.emit('error', `Failed to fetch node info: ${err.message}`);
         }
     }
 
     async getStats() {
         const now = Date.now();
-        const STATS_COOLDOWN = 60000; // Update every 1 minute.
-        
+        const STATS_COOLDOWN = 60000;
         if (now - this.#lastStatsRequest < STATS_COOLDOWN) {
-            return this.#statsCache.get(this) ?? this.stats;
+            return this.#statsCache[this.name] ?? this.stats;
         }
-
         try {
             const stats = await this.rest.makeRequest("GET", "/v4/stats");
             this.#updateStats(stats);
             this.#lastStatsRequest = now;
-            this.#statsCache.set(this, this.stats);
+            this.#statsCache[this.name] = this.stats;
             return this.stats;
         } catch (err) {
             this.aqua.emit('debug', `Stats fetch error: ${err.message}`);
@@ -166,7 +147,6 @@ class Node {
 
     #updateStats(payload) {
         if (!payload) return;
-
         const newStats = {
             players: payload.players ?? 0,
             playingPlayers: payload.playingPlayers ?? 0,
@@ -176,19 +156,20 @@ class Node {
             cpu: this.#updateCpuStats(payload.cpu),
             frameStats: this.#updateFrameStats(payload.frameStats)
         };
-
         this.stats = Object.freeze(newStats);
     }
 
     #updateMemoryStats(memory = {}) {
         const allocated = memory.allocated ?? 0;
+        const free = memory.free ?? 0;
+        const used = memory.used ?? 0;
         return Object.freeze({
-            free: memory.free ?? 0,
-            used: memory.used ?? 0,
+            free,
+            used,
             allocated,
             reservable: memory.reservable ?? 0,
-            freePercentage: allocated ? (memory.free / allocated) * 100 : 0,
-            usedPercentage: allocated ? (memory.used / allocated) * 100 : 0
+            freePercentage: allocated ? (free / allocated) * 100 : 0,
+            usedPercentage: allocated ? (used / allocated) * 100 : 0
         });
     }
 
@@ -202,20 +183,25 @@ class Node {
         });
     }
 
-    #updateFrameStats() {
+    #updateFrameStats(frameStats = {}) {
+        if (!frameStats) {
+            return Object.freeze({
+                sent: 0,
+                nulled: 0,
+                deficit: 0
+            });
+        }
         return Object.freeze({
-            sent: 0,
-            nulled: 0,
-            deficit: 0
+            sent: frameStats.sent ?? 0,
+            nulled: frameStats.nulled ?? 0,
+            deficit: frameStats.deficit ?? 0
         });
     }
 
-    // More optimized message handling
     #onMessage(msg) {
         try {
             const payload = JSON.parse(msg.toString());
             if (!payload?.op) return;
-
             switch (payload.op) {
                 case "stats":
                     this.#updateStats(payload);
@@ -255,32 +241,33 @@ class Node {
     }
 
     #reconnect() {
+        if (this.infiniteReconnects) {
+            this.aqua.emit("nodeReconnect", this, console.log("Experimental infinite reconnects enabled, will be trying non-stop..."));
+            this.connect();
+            return;
+        }
         if (++this.#reconnectAttempted >= this.reconnectTries) {
             this.aqua.emit("nodeError", this, new Error(`Max reconnection attempts reached (${this.reconnectTries})`));
+            clearTimeout(this.reconnectTimeoutId);
             return this.destroy();
         }
-
-        setTimeout(() => {
-            this.aqua.emit("nodeReconnect", this);
+        clearTimeout(this.reconnectTimeoutId);
+        this.reconnectTimeoutId = setTimeout(() => {
+            this.aqua.emit("nodeReconnect", this, this.#reconnectAttempted);
             this.connect();
-        }, this.reconnectTimeout * this.#reconnectAttempted); // Exponential backoff
+        }, this.reconnectTimeout * Math.pow(2, this.#reconnectAttempted)); // Exponential backoff
     }
 
-    // Performance optimized penalties calculation
     get penalties() {
         if (!this.connected) return Number.MAX_SAFE_INTEGER;
-        
         let penalties = this.stats.players;
-        
         if (this.stats.cpu?.systemLoad) {
             penalties += Math.round(Math.pow(1.05, 100 * this.stats.cpu.systemLoad) * 10 - 10);
         }
-
         if (this.stats.frameStats) {
             penalties += this.stats.frameStats.deficit;
             penalties += this.stats.frameStats.nulled * 2;
         }
-
         return penalties;
     }
 
@@ -290,8 +277,6 @@ class Node {
             this.aqua.nodes.delete(this.name);
             return;
         }
-
-        // Cleanup all players using this node
         if (this.connected) {
             for (const player of this.aqua.players.values()) {
                 if (player.node === this) {
@@ -299,17 +284,14 @@ class Node {
                 }
             }
         }
-
         this.#cleanup();
         this.connected = false;
         this.aqua.nodeMap.delete(this.name);
         this.aqua.emit("nodeDestroy", this);
-
-        // Clear references
         this.info = null;
-        this.#statsCache = new WeakMap();
+        this.#statsCache = {};
         this.stats = Object.freeze(this.#createStats());
     }
 }
 
-module.exports = { Node };
+module.exports = { Node };

package/build/structures/Player.js

@@ -30,11 +30,8 @@ class Player extends EventEmitter {
         this.previousTracks = [];
         this.shouldDeleteMessage = options.shouldDeleteMessage ?? true;
 
-        this._boundPlayerUpdate = this.onPlayerUpdate.bind(this);
-        this._boundHandleEvent = this.handleEvent.bind(this);
-
-        this.on("playerUpdate", this._boundPlayerUpdate);
-        this.on("event", this._boundHandleEvent);
+        this.on("playerUpdate", this.onPlayerUpdate.bind(this));
+        this.on("event", this.handleEvent.bind(this));
     }
 
     onPlayerUpdate(packet) {
@@ -58,162 +55,96 @@ class Player extends EventEmitter {
         }
         this.previousTracks.unshift(track);
     }
-    /**
-     * Play the next track in the queue.
-     *
-     * @throws {Error} If the player is not connected.
-     * @returns {Promise<Player>} The player instance.
-     */
-     play() {
+
+
+    async play() {
         if (!this.connected) throw new Error("Player must be connected first.");
         if (!this.queue.length) return;
-
+    
         const track = this.queue.shift();
-        this.current = track.track ? track :  track.resolve(this.aqua);
-
+        
+        this.current = track.track ? track : await track.resolve(this.aqua);
+        
         this.playing = true;
         this.position = 0;
-
         this.aqua.emit("debug", this.guildId, `Playing track: ${this.current.track}`);
-         this.updatePlayer({ track: { encoded: this.current.track } });
+        this.updatePlayer({ track: { encoded: this.current.track } });
         return this;
     }
-    /**
-     * Connects the player to a specified voice channel.
-     *
-     * @param {Object} options - Options for connecting the player.
-     * @param {string} options.guildId - The ID of the guild.
-     * @param {string} options.voiceChannel - The ID of the voice channel to connect to.
-     * @param {boolean} [options.deaf=true] - Whether the player should be self-deafened.
-     * @param {boolean} [options.mute=false] - Whether the player should be self-muted.
-     * @throws {Error} If the player is already connected.
-     * @returns {Promise<Player>} The player instance.
-     */
-     connect(options) {
-        if (this.connected) throw new Error("Player is already connected.");
-
-        const {
-            guildId,
-            voiceChannel,
-            deaf = true,
-            mute = false
-        } = options;
 
+    connect(options) {
+        if (this.connected) throw new Error("Player is already connected.");
+        const { guildId, voiceChannel, deaf = true, mute = false } = options;
         this.send({
             guild_id: guildId,
             channel_id: voiceChannel,
             self_deaf: deaf,
             self_mute: mute
         });
-
         this.connected = true;
         this.aqua.emit("debug", this.guildId, `Player connected to voice channel: ${voiceChannel}.`);
         return this;
     }
 
-      destroy() {
+    destroy() {
         if (!this.connected) return this;
-         this.updatePlayer({ track: { encoded: null } });
-        this.queue.clear();
-        this.current = null;
-        this.previousTracks.length = 0;
-        this.playing = false;
-        this.position = 0;
-        this.send({ guild_id: this.guildId, channel_id: null });
-        this.connected = false;
-
-        this.removeListener("playerUpdate", this._boundPlayerUpdate);
-        this.removeListener("event", this._boundHandleEvent);
-        
+        this.disconnect();
+        this.nowPlayingMessage?.delete().catch(() => { }); // ignore the error
+        this.aqua.destroyPlayer(this.guildId);
+        this.nodes.rest.destroyPlayer(this.guildId);
         return this;
     }
-    /**
-     * Pauses or resumes the player.
-     *
-     * @param {boolean} paused - If true, the player will be paused; if false, it will resume.
-     * @returns {Promise<Player>} The player instance.
-     */
 
-     pause(paused) {
+    pause(paused) {
         this.paused = paused;
-         this.updatePlayer({ paused });
+        this.updatePlayer({ paused });
         return this;
     }
-    /**
-     * Seeks to a position in the currently playing track.
-     *
-     * @param {number} position - The position in milliseconds to seek to.
-     * @throws {Error} If the position is negative.
-     * @returns {Promise<Player>} The player instance.
-     */
-     seek(position) {
+
+    seek(position) {
         if (position < 0) throw new Error("Seek position cannot be negative.");
         if (!this.playing) return this;
-
         this.position = position;
-         this.updatePlayer({ position });
+        this.updatePlayer({ position });
         return this;
     }
-     stop() {
+
+    stop() {
         if (!this.playing) return this;
-         this.updatePlayer({ track: { encoded: null } });
+        this.updatePlayer({ track: { encoded: null } });
         this.playing = false;
         this.position = 0;
         return this;
     }
-     /**
-     * Sets the volume of the player.
-     *
-     * @param {number} volume - The volume to set, between 0 and 200.
-     * @throws {Error} If the volume is out of range.
-     * @returns {Promise<Player>} The player instance.
-     */
-     setVolume(volume) {
+
+    setVolume(volume) {
         if (volume < 0 || volume > 200) throw new Error("Volume must be between 0 and 200.");
         this.volume = volume;
-         this.updatePlayer({ volume });
+        this.updatePlayer({ volume });
         return this;
     }
-    /**
-     * Sets the loop mode of the player.
-     *
-     * @param {string} mode - The loop mode to set, either "none", "track", or "queue".
-     * @throws {Error} If the mode is not one of the above.
-     * @returns {Promise<Player>} The player instance.
-     */
-     setLoop(mode) {
-        const validModes = new Set(["none", "track", "queue"]);
-        if (!validModes.has(mode)) throw new Error("Loop mode must be 'none', 'track', or 'queue'.");
+
+    static validModes = new Set(["none", "track", "queue"]); 
+
+    setLoop(mode) {
+        if (!Player.validModes.has(mode)) throw new Error("Loop mode must be 'none', 'track', or 'queue'.");
         this.loop = mode;
-         this.updatePlayer({ loop: mode });
+        this.updatePlayer({ loop: mode });
         return this;
     }
-  /**
-     * Sets the text channel for the player.
-     *
-     * @param {string} channel - The ID of the text channel to set.
-     * @returns {Promise<Player>} The player instance.
-     */
 
-     setTextChannel(channel) {
-         this.updatePlayer({ text_channel: channel });
+    setTextChannel(channel) {
+        this.updatePlayer({ text_channel: channel });
         return this;
     }
-     /**
-     * Sets the voice channel for the player.
-     *
-     * @param {string} channel - The ID of the voice channel to set.
-     * @throws {TypeError} If the channel is not a non-empty string.
-     * @throws {ReferenceError} If the player is already connected to the channel.
-     * @returns {Promise<Player>} The player instance.
-     */
-     setVoiceChannel(channel) {
+
+    setVoiceChannel(channel) {
         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({
+        this.connect({
             deaf: this.deaf,
             guildId: this.guildId,
             voiceChannel: channel,
@@ -222,14 +153,14 @@ class Player extends EventEmitter {
         return this;
     }
 
-     disconnect() {
-         this.updatePlayer({ track: { encoded: null } });
+    disconnect() {
+        this.updatePlayer({ track: { encoded: null } });
         this.connected = false;
         this.send({ guild_id: this.guildId, channel_id: null });
         this.aqua.emit("debug", this.guildId, "Player disconnected.");
     }
 
-     shuffle() {
+    shuffle() {
         const len = this.queue.length;
         for (let i = len - 1; i > 0; i--) {
             const j = Math.floor(Math.random() * (i + 1));
@@ -242,12 +173,12 @@ class Player extends EventEmitter {
         return this.queue;
     }
 
-     replay() {
+    replay() {
         return this.seek(0);
     }
 
-     skip() {
-         this.stop();
+    skip() {
+        this.stop();
         return this.playing ? this.play() : undefined;
     }
 
@@ -263,16 +194,14 @@ class Player extends EventEmitter {
     handleEvent = (payload) => {
         const player = this.aqua.players.get(payload.guildId);
         if (!player) return;
-
         const track = player.current;
         const handlerName = Player.EVENT_HANDLERS.get(payload.type);
-
         if (handlerName) {
             this[handlerName](player, track, payload);
         } else {
             this.handleUnknownEvent(player, track, payload);
         }
-    }
+    };
 
     trackStart(player, track) {
         this.playing = true;
@@ -290,15 +219,13 @@ class Player extends EventEmitter {
         if (this.shouldDeleteMessage && this.nowPlayingMessage) {
             try {
                 await this.nowPlayingMessage.delete();
-            } catch {
-                // Ignore errors
+            } catch (error) {
+                // Consider logging specific errors
             } finally {
                 this.nowPlayingMessage = null;
             }
         }
-
         const reason = payload.reason.replace("_", "").toLowerCase();
-
         if (reason === "loadfailed" || reason === "cleanup") {
             if (player.queue.isEmpty()) {
                 this.aqua.emit("queueEnd", player);
@@ -306,7 +233,6 @@ class Player extends EventEmitter {
             }
             return player.play();
         }
-
         switch (this.loop) {
             case "track":
                 this.aqua.emit("trackRepeat", player, track);
@@ -317,13 +243,11 @@ class Player extends EventEmitter {
                 player.queue.push(track);
                 break;
         }
-
         if (player.queue.isEmpty()) {
             this.playing = false;
             this.aqua.emit("queueEnd", player);
             return this.cleanup();
         }
-
         return player.play();
     }
 
@@ -366,7 +290,7 @@ class Player extends EventEmitter {
     }
 
     clearData() {
-        this.#dataStore = new WeakMap();
+        this.#dataStore.delete()
         return this;
     }
 
@@ -384,10 +308,10 @@ class Player extends EventEmitter {
 
     async cleanup() {
         if (!this.playing && !this.paused && this.queue.isEmpty()) {
-             this.destroy();
+            this.destroy();
         }
         this.clearData();
     }
 }
 
-module.exports = { Player };
+module.exports = { Player };

package/build/structures/Rest.js

@@ -29,6 +29,7 @@ class Rest {
         }
 
         const response = await request(`${this.url}${endpoint}`, options);
+        if (response.statusCode === 204) return null;
         this.calls++;
         const data = await response.body.json();
         this.aqua.emit("apiResponse", endpoint, {

package/build/structures/Track.js

@@ -5,29 +5,32 @@ const { getImageUrl } = require("../handlers/fetchImage");
  * @typedef {import("../structures/Player")} Player
  * @typedef {import("../structures/Node")} Node
  */
+
 class Track {
   /**
-   * @param {{ encoded: string, info: { identifier: string, isSeekable: boolean, author: string, length: number, isStream: boolean, position: number, title: string, uri: string, sourceName: string, artworkUrl: string, track: string }, playlist?: { name: string, selectedTrack: number } }} data
+   * @param {Object} data
    * @param {Player} requester
    * @param {Node} nodes
    */
   constructor(data, requester, nodes) {
-    const { encoded = null, info = {}, playlist = null } = data;
-    this.info = Object.freeze({
-      identifier: info.identifier,
-      isSeekable: info.isSeekable,
-      author: info.author,
-      length: info.length,
-      isStream: info.isStream,
-      title: info.title,
-      uri: info.uri,
-      sourceName: info.sourceName,
-      artworkUrl: info.artworkUrl
-    });
+    const info = data?.info || {};
+    
+    this.info = {
+      identifier: info.identifier || '',
+      isSeekable: !!info.isSeekable,
+      author: info.author || '',
+      length: ~~info.length,
+      isStream: !!info.isStream,
+      title: info.title || '',
+      uri: info.uri || '',
+      sourceName: info.sourceName || '',
+      artworkUrl: info.artworkUrl || ''
+    };
+
+    this.track = data?.encoded || null;
+    this.playlist = data?.playlist || null;
     this.requester = requester;
     this.nodes = nodes;
-    this.track = encoded;
-    this.playlist = playlist;
   }
 
   /**
@@ -39,13 +42,16 @@ class Track {
     return thumbnail.startsWith("http") ? thumbnail : getImageUrl(thumbnail, this.nodes);
   }
 
+  /**
+   * @param {Aqua} aqua
+   * @returns {Promise<Track|null>}
+   */
   async resolve(aqua) {
     if (!aqua?.options?.defaultSearchPlatform) return null;
 
     try {
-      const query = `${this.info.author} - ${this.info.title}`;
       const result = await aqua.resolve({
-        query,
+        query: this.info.author + ' - ' + this.info.title,
         source: aqua.options.defaultSearchPlatform,
         requester: this.requester,
         node: this.nodes
@@ -53,52 +59,54 @@ class Track {
 
       if (!result?.tracks?.length) return null;
 
-      const matchedTrack = result.tracks.find(track => this.isTrackMatch(track)) || result.tracks[0];
-
-      if (matchedTrack) {
-        this.updateTrackInfo(matchedTrack);
-        return this;
-      }
+      const track = this._findMatchingTrack(result.tracks);
+      if (!track) return null;
 
-      return null;
-
-    } catch (error) {
-      console.error('Error resolving track:', error);
+      this._updateTrack(track);
+      return this;
+    } catch {
       return null;
     }
   }
 
-  isTrackMatch(track) {
+  /**
+   * @private
+   */
+  _findMatchingTrack(tracks) {
     const { author, title, length } = this.info;
-    const { author: tAuthor, title: tTitle, length: tLength } = track.info;
 
-    return tAuthor === author && 
-           tTitle === title && 
-           (!length || Math.abs(tLength - length) <= 2000);
+    for (let i = 0; i < tracks.length; i++) {
+      const track = tracks[i];
+      const tInfo = track.info;
+      
+      if (tInfo.author === author && 
+          tInfo.title === title && 
+          (!length || Math.abs(tInfo.length - length) <= 2000)) {
+        return track;
+      }
+    }
+
+    return tracks[0];
   }
 
   /**
-   * @param {Track} track
+   * @private
    */
-  updateTrackInfo(track) {
-    if (!track) return;
-    this.info = Object.freeze({
-      ...this.info,
-      identifier: track.info.identifier
-    });
-    
+  _updateTrack(track) {
+    this.info.identifier = track.info.identifier;
     this.track = track.track;
     this.playlist = track.playlist || null;
   }
 
   /**
-   * Cleanup method to help garbage collection
+   * Fast cleanup
    */
   destroy() {
     this.requester = null;
     this.nodes = null;
     this.track = null;
     this.playlist = null;
+    this.info = null;
   }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aqualink",
-  "version": "1.6.2-beta",
+  "version": "1.7.0-beta1",
   "description": "An Lavalink wrapper, focused in speed, performance, and features, Based in Riffy!",
   "main": "build/index.js",
   "scripts": {
@@ -48,8 +48,5 @@
       "name": "mushroom0162",
       "url": "https://github.com/ToddyTheNoobDud"
     }
-  ],
-  "devDependencies": {
-    "discord.js": "^14.16.3"
-  }
+  ]
 }