aqualink 1.7.0-beta4 → 1.7.0-beta6

package/build/handlers/fetchImage.js

@@ -1,19 +1,12 @@
 const { request } = require("undici");
 
 const sourceHandlers = new Map([
-    ['spotify', (uri) => fetchThumbnail(`https://open.spotify.com/oembed?url=${uri}`)],
-    ['youtube', (identifier) => fetchYouTubeThumbnail(identifier)]
+    ['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);
+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?.sourceName || !info?.uri) return null;
@@ -23,7 +16,8 @@ async function getImageUrl(info) {
 
     try {
         return await handler(info.uri);
-    } catch {
+    } catch (error) {
+        console.error('Error fetching image URL:', error);
         return null;
     }
 }
@@ -32,26 +26,23 @@ async function fetchThumbnail(url) {
     try {
         const { body } = await request(url, {
             method: "GET",
-            headers: {
-                'Accept': 'application/json'
-            }
+            headers: { 'Accept': 'application/json' }
         });
-
         const json = await body.json();
         return json.thumbnail_url || null;
-    } catch {
+    } catch (error) {
+        console.error('Error fetching thumbnail:', error);
         return null;
     }
 }
 
 async function fetchYouTubeThumbnail(identifier) {
-    const fetchPromises = YOUTUBE_QUALITIES.map(urlFunc => 
-        fetchThumbnail(urlFunc(identifier))
-    );
+    const fetchPromises = YOUTUBE_QUALITIES.map(urlFunc => fetchThumbnail(urlFunc(identifier)));
 
     try {
         return await Promise.race(fetchPromises);
-    } catch {
+    } catch (error) {
+        console.error('Error fetching YouTube thumbnail:', error);
         return null;
     }
 }

package/build/structures/Aqua.js

@@ -4,29 +4,29 @@ const { Player } = require("./Player");
 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) {
+ * @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 {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);
         this.client = client;
@@ -35,28 +35,37 @@ class Aqua extends EventEmitter {
         this.players = new Map();
         this.clientId = null;
         this.initiated = false;
-        this.shouldDeleteMessage = options.shouldDeleteMessage || false;
-        this.defaultSearchPlatform = options.defaultSearchPlatform || "ytsearch";
-        this.restVersion = options.restVersion || "v4";
-        this.plugins = options.plugins || [];
-        this.version = pkgVersion;
         this.options = options;
-        this.send = options.send;
-        this.autoResume = options.autoResume || false;
-        this.infiniteReconnects = options.infiniteReconnects || false;
+
+        this.shouldDeleteMessage = this.getOption(options, 'shouldDeleteMessage', false);
+        this.defaultSearchPlatform = this.getOption(options, 'defaultSearchPlatform', 'ytsearch');
+        this.leaveOnEnd =  this.getOption(options, 'leaveOnEnd', true);
+        this.restVersion = this.getOption(options, 'restVersion', 'v4');
+        this.plugins = this.getOption(options, 'plugins', []);
+        this.version = pkgVersion;
+        this.send = options.send || this.defaultSendFunction;
+        this.autoResume = this.getOption(options, 'autoResume', false);
+        this.infiniteReconnects = this.getOption(options, 'infiniteReconnects', false);
+        
         this.setMaxListeners(0);
     }
 
+    getOption(options, key, defaultValue) {
+        return options.hasOwnProperty(key) ? options[key] : defaultValue;
+    }
+
+    defaultSendFunction(payload) {
+        const guild = this.client.guilds.cache.get(payload.d.guild_id);
+        if (guild) guild.shard.send(payload);
+    }
 
     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})`);
-        if (typeof options?.send !== "function") throw new Error("Send function is required to initialize Aqua");
     }
 
     get leastUsedNodes() {
-        const activeNodes = [...this.nodeMap.values()].filter(node => node.connected);
-        return activeNodes.length ? activeNodes.sort((a, b) => a.rest.calls - b.rest.calls) : [];
+        return [...this.nodeMap.values()].filter(node => node.connected).sort((a, b) => a.rest.calls - b.rest.calls);
     }
 
     init(clientId) {
@@ -78,41 +87,42 @@ class Aqua extends EventEmitter {
         this.destroyNode(nodeId); // Ensure no duplicate nodes
         const node = new Node(this, options, this.options);
         this.nodeMap.set(nodeId, node);
-        try {
-            node.connect();
-            this.emit("nodeCreate", node);
-            return node;
-        } catch (error) {
-            this.nodeMap.delete(nodeId);
-            throw error;
-        }
+        node.connect()
+            .then(() => this.emit("nodeCreate", node))
+            .catch(error => {
+                this.nodeMap.delete(nodeId);
+                throw error;
+            });
+        return node;
     }
 
     destroyNode(identifier) {
         const node = this.nodeMap.get(identifier);
         if (!node) return;
-        try {
-            node.disconnect();
-            node.removeAllListeners();
-            this.nodeMap.delete(identifier);
-            this.emit("nodeDestroy", node);
-        } catch (error) {
-            console.error(`Error destroying node ${identifier}:`, error);
-        }
+
+        node.disconnect()
+            .then(() => {
+                node.removeAllListeners();
+                this.nodeMap.delete(identifier);
+                this.emit("nodeDestroy", node);
+            })
+            .catch(error => console.error(`Error destroying node ${identifier}:`, error));
     }
 
     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)) {
+        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();
-        const eligibleNodes = [...this.nodeMap.values()].filter(node => node.connected && node.regions?.includes(lowerRegion));
-        return eligibleNodes.sort((a, b) => this.calculateLoad(a) - this.calculateLoad(b));
+        return [...this.nodeMap.values()]
+            .filter(node => node.connected && node.regions?.includes(lowerRegion))
+            .sort((a, b) => this.calculateLoad(a) - this.calculateLoad(b));
     }
 
     calculateLoad(node) {
@@ -125,6 +135,7 @@ class Aqua extends EventEmitter {
         this.ensureInitialized();
         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);
@@ -140,22 +151,21 @@ class Aqua extends EventEmitter {
         return player;
     }
 
-async destroyPlayer(guildId) {
-    const player = this.players.get(guildId);
-    if (!player) return;
+    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);
+        try {
+            await player.clearData(); // Assuming clearData is an async function
+            player.removeAllListeners();
+            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);
@@ -188,11 +198,11 @@ async destroyPlayer(guildId) {
         return URL_REGEX.test(query) ? query : `${source}:${query}`;
     }
 
-     handleNoMatches(rest, query) {
+    async handleNoMatches(rest, query) {
         try {
-            const youtubeResponse =  rest.makeRequest("GET", `/v4/loadtracks?identifier=https://www.youtube.com/watch?v=${query}`, { signal: controller.signal });
+            const youtubeResponse = await rest.makeRequest("GET", `/v4/loadtracks?identifier=https://www.youtube.com/watch?v=${query}`);
             if (["empty", "NO_MATCHES"].includes(youtubeResponse.loadType)) {
-                return  rest.makeRequest("GET", `/v4/loadtracks?identifier=https://open.spotify.com/track/${query}`, { signal: controller.signal });
+                return await rest.makeRequest("GET", `/v4/loadtracks?identifier=https://open.spotify.com/track/${query}`);
             }
             return youtubeResponse;
         } catch (error) {
@@ -208,10 +218,12 @@ async destroyPlayer(guildId) {
             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":
@@ -283,4 +295,4 @@ async destroyPlayer(guildId) {
     }
 }
 
-module.exports = { Aqua };
+module.exports = { Aqua };

package/build/structures/Connection.js

@@ -1,106 +1,101 @@
 class Connection {
-    constructor(player) {
-      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
-      });
+  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.guildId = player.guildId;
+    this.aqua = player.aqua;
+    this.nodes = player.nodes;
+  }
+
+  setServerUpdate(data) {
+    if (!data?.endpoint) {
+      throw new Error("Missing 'endpoint' property");
     }
-  
-    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, '');
+
+    const endpoint = data.endpoint;
+    const regionMatch = endpoint.match(/^([a-zA-Z]+)/);
+    if (!regionMatch) return;
+
+    const newRegion = regionMatch[1];
+    if (this.region !== newRegion) {
+      this.voice.endpoint = endpoint;
+      this.voice.token = data.token;
       
-      if (this.region !== newRegion) {
-        const prevRegion = this.region;
-        
-        Object.assign(this.voice, {
-          endpoint,
-          token: data.token
-        });
-        this.region = newRegion;
-  
-        this._aqua.emit(
-          "debug",
-          `[Player ${this._guildId} - CONNECTION] ${
-            prevRegion 
-              ? `Changed Voice Region from ${prevRegion} to ${newRegion}`
-              : `Voice Server: ${newRegion}`
-          }`
-        );
-      }
-  
-      this._updatePlayerVoiceData();
+      const prevRegion = this.region;
+      this.region = newRegion;
+
+      this.aqua.emit(
+        "debug",
+        `[Player ${this.guildId} - CONNECTION] ${
+          prevRegion 
+            ? `Changed Voice Region from ${prevRegion} to ${newRegion}`
+            : `Voice Server: ${newRegion}`
+        }`
+      );
     }
-  
 
-    setStateUpdate(data) {
-      const channelId = data.channel_id;
-      const sessionId = data.session_id;
-  
-      if (!channelId || !sessionId) {
-        this._cleanup();
-        return;
-      }
+    this._updatePlayerVoiceData();
+  }
 
-      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;
+  setStateUpdate(data) {
+    const { channel_id: channelId, session_id: sessionId, self_deaf: selfDeaf, self_mute: selfMute } = data;
+
+    if (!channelId || !sessionId) {
+      this._cleanup();
+      return;
+    }
+
+    if (this.voiceChannel !== channelId) {
+      this.aqua.emit("playerMove", this.voiceChannel, channelId);
+      this.voiceChannel = channelId;
     }
-  
-    _updatePlayerVoiceData() {
-      this._nodes.rest.updatePlayer({
-        guildId: this._guildId,
+
+    this.selfDeaf = selfDeaf;
+    this.selfMute = selfMute;
+    this.voice.sessionId = sessionId;
+  }
+
+  async _updatePlayerVoiceData() {
+    try {
+      await this.nodes.rest.updatePlayer({
+        guildId: this.guildId,
         data: {
           voice: this.voice,
           volume: this.player.volume
         }
-      }).catch(err => {
-        this._aqua.emit("apiError", "updatePlayer", err);
-      });
-    }
-  
-    _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
       });
+    } catch (err) {
+      this.aqua.emit("apiError", "updatePlayer", err);
     }
   }
-  
-  module.exports = { Connection };
+
+  _cleanup() {
+    const { aqua, player, voiceChannel } = this;
+    
+    aqua.emit("playerLeave", voiceChannel);
+    
+    player.voiceChannel = null;
+    this.voiceChannel = null;
+    player.destroy();
+    
+    aqua.emit("playerDestroy", player);
+    this.player = null;
+    this.voice = null;
+    this.region = null;
+    this.selfDeaf = null;
+    this.selfMute = null;
+    this.guildId = null;
+    this.aqua = null;
+    this.nodes = null;
+  }
+}
+
+module.exports = { Connection };

package/build/structures/Node.js

@@ -3,9 +3,11 @@ const { Rest } = require("./Rest");
 
 class Node {
     #ws = null;
-    #statsCache = {};
+    #statsCache = new Map();
     #lastStatsRequest = 0;
     #reconnectAttempted = 0;
+    #reconnectTimeoutId = null;
+
     constructor(aqua, nodes, options) {
         const {
             name,
@@ -35,7 +37,7 @@ class Node {
         this.infiniteReconnects = options?.infiniteReconnects ?? false;
         this.connected = false;
         this.info = null;
-        this.stats = Object.freeze(this.#createStats());
+        this.stats = this.#createStats();
     }
 
     #createStats() {
@@ -43,75 +45,61 @@ class Node {
             players: 0,
             playingPlayers: 0,
             uptime: 0,
-            memory: Object.freeze({
-                free: 0,
-                used: 0,
-                allocated: 0,
-                reservable: 0,
-                freePercentage: 0,
-                usedPercentage: 0
-            }),
-            cpu: Object.freeze({
-                cores: 0,
-                systemLoad: 0,
-                lavalinkLoad: 0,
-                lavalinkLoadPercentage: 0
-            }),
-            frameStats: Object.freeze({
-                sent: 0,
-                nulled: 0,
-                deficit: 0
-            }),
+            memory: { free: 0, used: 0, allocated: 0, reservable: 0, freePercentage: 0, usedPercentage: 0 },
+            cpu: { cores: 0, systemLoad: 0, lavalinkLoad: 0, lavalinkLoadPercentage: 0 },
+            frameStats: { sent: 0, nulled: 0, deficit: 0 },
             ping: 0
         };
     }
 
     async connect() {
         this.#cleanup();
-        try {
-            this.#ws = new WebSocket(this.wsUrl.href, {
-                headers: this.#constructHeaders(),
-                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();
-        }
+        this.#ws = new WebSocket(this.wsUrl.href, {
+            headers: this.#constructHeaders(),
+            perMessageDeflate: false,
+            handshakeTimeout: 5000
+        });
+
+        this.#ws.once('open', () => {
+            this.#onOpen();
+        });
+
+        this.#setupWebSocketListeners();
+        this.aqua.emit('debug', this.name, 'Connecting...');
     }
 
     #cleanup() {
         if (this.#ws) {
-            try {
-                this.#ws.removeAllListeners();
-                this.#ws.terminate();
-            } catch (err) {
-                this.aqua.emit('debug', `Cleanup error: ${err.message}`);
-            } finally {
-                this.#ws = null;
-            }
+            this.#ws.removeAllListeners();
+            this.#ws.terminate();
+            this.#ws = null;
         }
+        this.info = null;
+        this.#statsCache.clear();
     }
 
     #constructHeaders() {
-        const headers = {
+        return {
             Authorization: this.password,
             "User-Id": this.aqua.clientId,
             "Client-Name": `Aqua/${this.aqua.version}`,
+            ...(this.sessionId && { "Session-Id": this.sessionId }),
+            ...(this.resumeKey && { "Resume-Key": this.resumeKey })
         };
-        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));
-        ws.once("close", this.#onClose.bind(this));
+        
+        this.#ws.removeAllListeners('open');
+        this.#ws.removeAllListeners('error');
+        this.#ws.removeAllListeners('message');
+        this.#ws.removeAllListeners('close');
+    
+        this.#ws.once("open", this.#onOpen.bind(this));
+        this.#ws.once("error", this.#onError.bind(this));
+        this.#ws.on("message", this.#onMessage.bind(this));
+        this.#ws.once("close", this.#onClose.bind(this));
     }
 
     async #onOpen() {
@@ -119,25 +107,28 @@ class Node {
         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();
+            if (this.autoResume) await this.resumePlayers();
         } catch (err) {
             this.info = null;
-            !this.aqua.bypassChecks?.nodeFetchInfo &&
+            if (!this.aqua.bypassChecks?.nodeFetchInfo) {
                 this.aqua.emit('error', `Failed to fetch node info: ${err.message}`);
+            }
         }
     }
-
     async getStats() {
+        if (!this.connected) return this.stats;
+    
         const now = Date.now();
         const STATS_COOLDOWN = 60000;
+    
         if (now - this.#lastStatsRequest < STATS_COOLDOWN) {
-            return this.#statsCache[this.name] ?? this.stats;
+            return this.stats;
         }
+    
         try {
             const stats = await this.rest.makeRequest("GET", "/v4/stats");
-            this.#updateStats(stats);
+            this.stats = { ...this.#createStats(), ...stats };
             this.#lastStatsRequest = now;
-            this.#statsCache[this.name] = this.stats;
             return this.stats;
         } catch (err) {
             this.aqua.emit('debug', `Stats fetch error: ${err.message}`);
@@ -147,66 +138,58 @@ class Node {
 
     #updateStats(payload) {
         if (!payload) return;
-        const newStats = {
-            players: payload.players ?? 0,
-            playingPlayers: payload.playingPlayers ?? 0,
-            uptime: payload.uptime ?? 0,
-            ping: payload.ping ?? 0,
+        this.stats = {
+            ...this.stats,
+            ...payload,
             memory: this.#updateMemoryStats(payload.memory),
             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({
+        return {
             free,
             used,
             allocated,
             reservable: memory.reservable ?? 0,
             freePercentage: allocated ? (free / allocated) * 100 : 0,
             usedPercentage: allocated ? (used / allocated) * 100 : 0
-        });
+        };
     }
 
     #updateCpuStats(cpu = {}) {
         const cores = cpu.cores ?? 0;
-        return Object.freeze({
+        return {
             cores,
             systemLoad: cpu.systemLoad ?? 0,
             lavalinkLoad: cpu.lavalinkLoad ?? 0,
             lavalinkLoadPercentage: cores ? (cpu.lavalinkLoad / cores) * 100 : 0
-        });
+        };
     }
 
     #updateFrameStats(frameStats = {}) {
-        if (!frameStats) {
-            return Object.freeze({
-                sent: 0,
-                nulled: 0,
-                deficit: 0
-            });
-        }
-        return Object.freeze({
+        if (!frameStats) return {};
+        return {
             sent: frameStats.sent ?? 0,
             nulled: frameStats.nulled ?? 0,
             deficit: frameStats.deficit ?? 0
-        });
+        };
     }
 
     #onMessage(msg) {
         try {
             const payload = JSON.parse(msg.toString());
             if (!payload?.op) return;
+
             switch (payload.op) {
-                case "stats":
+                case 'stats':
                     this.#updateStats(payload);
                     break;
-                case "ready":
+                case 'ready':
                     this.#handleReadyOp(payload);
                     break;
                 default:
@@ -242,26 +225,33 @@ class Node {
 
     #reconnect() {
         if (this.infiniteReconnects) {
-            this.aqua.emit("nodeReconnect", this, console.log("Experimental infinite reconnects enabled, will be trying non-stop..."));
-            setTimeout(() => {
-                this.connect();
-            }, 10000); 
+            this.aqua.emit("nodeReconnect", this, "Experimental infinite reconnects enabled, will be trying non-stop...");
+            setTimeout(() => this.connect(), 10000);
             return;
         }
 
-        if (this.connected) {
-            clearTimeout(this.reconnectTimeoutId);
-        }
-        if (++this.#reconnectAttempted >= this.reconnectTries) {
+        const jitter = Math.random() * 10000;
+        const backoffTime = Math.min(
+            this.reconnectTimeout * Math.pow(1.5, this.#reconnectAttempted) + jitter,
+            30000
+        );
+
+        if (this.#reconnectAttempted >= this.reconnectTries && !this.infiniteReconnects) {
             this.aqua.emit("nodeError", this, new Error(`Max reconnection attempts reached (${this.reconnectTries})`));
-            clearTimeout(this.reconnectTimeoutId);
-            return this.destroy();
+            this.destroy(true);
+            return;
         }
-        clearTimeout(this.reconnectTimeoutId);
-        this.reconnectTimeoutId = setTimeout(() => {
-            this.aqua.emit("nodeReconnect", this, this.#reconnectAttempted);
+
+        clearTimeout(this.#reconnectTimeoutId);
+        this.#reconnectTimeoutId = setTimeout(() => {
+            this.#reconnectAttempted++;
+            this.aqua.emit("nodeReconnect", {
+                nodeName: this.name,
+                attempt: this.#reconnectAttempted,
+                backoffTime
+            });
             this.connect();
-        }, this.reconnectTimeout * Math.pow(2, this.#reconnectAttempted)); // Exponential backoff
+        }, backoffTime);
     }
 
     get penalties() {
@@ -271,8 +261,7 @@ class Node {
             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;
+            penalties += this.stats.frameStats.deficit + this.stats.frameStats.nulled * 2;
         }
         return penalties;
     }
@@ -295,8 +284,8 @@ class Node {
         this.aqua.nodeMap.delete(this.name);
         this.aqua.emit("nodeDestroy", this);
         this.info = null;
-        this.#statsCache = {};
-        this.stats = Object.freeze(this.#createStats());
+        this.#statsCache.clear();
+        this.stats = this.#createStats();
     }
 }
 

package/build/structures/Player.js

@@ -4,6 +4,11 @@ const { Queue } = require("./Queue");
 const { Filters } = require("./Filters");
 
 class Player extends EventEmitter {
+    static LOOP_MODES = Object.freeze({
+        NONE: "none",
+        TRACK: "track",
+        QUEUE: "queue"
+    });
     constructor(aqua, nodes, options = {}) {
         super();
         this.aqua = aqua;
@@ -28,25 +33,26 @@ class Player extends EventEmitter {
         this.ping = 0;
         this.nowPlayingMessage = null;
         this.previousTracks = [];
-        this.shouldDeleteMessage = options.shouldDeleteMessage ?? true;
+        this.shouldDeleteMessage = options.shouldDeleteMessage; 
+        this.leaveOnEnd = options.leaveOnEnd
 
-        this.on("playerUpdate", this.onPlayerUpdate.bind(this));
-        this.on("event", this.handleEvent.bind(this));
+        this.boundHandleEvent = this.handleEvent.bind(this);
+        this.boundOnPlayerUpdate = this.onPlayerUpdate.bind(this);
+        this.on("playerUpdate", this.boundOnPlayerUpdate);
+        this.on("event", this.boundHandleEvent);
     }
 
-    onPlayerUpdate(packet) {
-        if (!packet?.state) return;
-        const { state } = packet;
+    onPlayerUpdate({ state } = {}) {
+        if (!state) return;
+        
         const { connected, position, ping, time } = state;
-        this.connected = connected;
-        this.position = position;
-        this.ping = ping;
-        this.timestamp = time;
-        this.aqua.emit("playerUpdate", this, packet);
+        Object.assign(this, { connected, position, ping, timestamp: time });
+        
+        this.aqua.emit("playerUpdate", this, { state });
     }
 
     get previous() {
-        return this.previousTracks.length ? this.previousTracks[0] : null;
+        return this.previousTracks[0] || null;
     }
 
     get currenttrack() {
@@ -60,25 +66,28 @@ class Player extends EventEmitter {
         this.previousTracks.unshift(track);
     }
 
-
     async play() {
-        if (!this.connected) throw new Error("Player must be connected first.");
+        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 : await track.resolve(this.aqua);
         
-        this.playing = true;
-        this.position = 0;
+        Object.assign(this, {
+            playing: true,
+            position: 0
+        });
+
         this.aqua.emit("debug", this.guildId, `Playing track: ${this.current.track}`);
-        this.updatePlayer({ track: { encoded: this.current.track } });
-        return this;
+        return this.updatePlayer({ track: { encoded: this.current.track } });
     }
 
-    connect(options) {
-        if (this.connected) throw new Error("Player is already connected.");
-        const { guildId, voiceChannel, deaf = true, mute = false } = options;
+    connect({ guildId, voiceChannel, deaf = true, mute = false }) {
+        if (this.connected) {
+            throw new Error("Player is already connected.");
+        }
         this.send({
             guild_id: guildId,
             channel_id: voiceChannel,
@@ -93,7 +102,7 @@ class Player extends EventEmitter {
     destroy() {
         if (!this.connected) return this;
         this.disconnect();
-        this.nowPlayingMessage?.delete().catch(() => { }); // ignore the error
+        this.nowPlayingMessage?.delete().catch(() => { });
         this.aqua.destroyPlayer(this.guildId);
         this.nodes.rest.destroyPlayer(this.guildId);
         return this;
@@ -107,30 +116,29 @@ class Player extends EventEmitter {
 
     async searchLyrics(query) {
         if (!query) return null;
-    
-        const response = await this.nodes.rest.getLyrics({ 
-            track: { 
+        const response = await this.nodes.rest.getLyrics({
+            track: {
                 encoded: { info: { title: query } },
                 guild_id: this.guildId,
                 search: true
-            } 
+            }
         });
-    
         return response || null;
     }
+
     async lyrics() {
         if (!this.playing) return null;
         const response = await this.nodes.rest.getLyrics({
             track: {
-              encoded: this.current.track,
-              guild_id: this.guildId
+                encoded: this.current.track,
+                guild_id: this.guildId
             },
-          });
+        });
         return response || null;
     }
 
     seek(position) {
-        if (!this.playing) return this; 
+        if (!this.playing) return this;
         const newPosition = this.position + position;
         if (newPosition < 0) {
             throw new Error("Seek position cannot be negative.");
@@ -155,8 +163,7 @@ class Player extends EventEmitter {
         return this;
     }
 
-    static validModes = new Set(["none", "track", "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;
@@ -192,10 +199,10 @@ class Player extends EventEmitter {
     }
 
     shuffle() {
-        const len = this.queue.length;
-        for (let i = len - 1; i > 0; i--) {
-            const j = Math.floor(Math.random() * (i + 1));
-            [this.queue[i], this.queue[j]] = [this.queue[j], this.queue[i]];
+        const arr = this.queue;
+        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 this;
     }
@@ -213,30 +220,29 @@ class Player extends EventEmitter {
         return this.playing ? this.play() : undefined;
     }
 
-    static EVENT_HANDLERS = new Map([
-        ["TrackStartEvent", "trackStart"],
-        ["TrackEndEvent", "trackEnd"],
-        ["TrackExceptionEvent", "trackError"],
-        ["TrackStuckEvent", "trackStuck"],
-        ["TrackChangeEvent", "trackChange"],
-        ["WebSocketClosedEvent", "socketClosed"]
-    ]);
+    static EVENT_HANDLERS = Object.freeze({
+        TrackStartEvent: "trackStart",
+        TrackEndEvent: "trackEnd",
+        TrackExceptionEvent: "trackError",
+        TrackStuckEvent: "trackStuck",
+        TrackChangeEvent: "trackChange",
+        WebSocketClosedEvent: "socketClosed"
+    });
 
-    handleEvent = (payload) => {
+    async 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);
+
+        const handler = Player.EVENT_HANDLERS[payload.type];
+        if (handler) {
+            await this[handler](player, this.current, payload);
         } else {
-            this.handleUnknownEvent(player, track, payload);
+            this.handleUnknownEvent(payload);
         }
-    };
+    }
 
     trackStart(player, track) {
-        this.playing = true;
-        this.paused = false;
+        Object.assign(this, { playing: true, paused: false });
         this.aqua.emit("trackStart", player, track);
     }
 
@@ -248,36 +254,37 @@ class Player extends EventEmitter {
 
     async trackEnd(player, track, payload) {
         if (this.shouldDeleteMessage && this.nowPlayingMessage) {
-            try {
-                await this.nowPlayingMessage.delete();
-            } catch (error) {
-            } finally {
-                this.nowPlayingMessage = null;
-            }
+            await this.nowPlayingMessage?.delete().catch(() => { });
+            this.nowPlayingMessage = null;
         }
+
         const reason = payload.reason.replace("_", "").toLowerCase();
         if (reason === "loadfailed" || reason === "cleanup") {
-            if (player.queue.isEmpty()) {
-                this.aqua.emit("queueEnd", player);
-                return;
-            }
-            return player.play();
+            return player.queue.isEmpty() ?
+                this.aqua.emit("queueEnd", player) :
+                player.play();
         }
+
         switch (this.loop) {
-            case "track":
+            case Player.LOOP_MODES.TRACK:
                 this.aqua.emit("trackRepeat", player, track);
                 player.queue.unshift(track);
                 break;
-            case "queue":
+            case Player.LOOP_MODES.QUEUE:
                 this.aqua.emit("queueRepeat", player, track);
                 player.queue.push(track);
                 break;
         }
+
         if (player.queue.isEmpty()) {
             this.playing = false;
-            this.aqua.emit("queueEnd", player);
-            return this.cleanup();
+            if (this.leaveOnEnd) {
+                await this.cleanup();
+            }
+            return this.aqua.emit("queueEnd", player);
         }
+    
+
         return player.play();
     }
 
@@ -309,9 +316,8 @@ class Player extends EventEmitter {
         this.aqua.send({ op: 4, d: data });
     }
 
-    #dataStore = new WeakMap();
-
-    set(key, value) {
+    #dataStore = new Map();
+     set(key, value) {
         this.#dataStore.set(key, value);
     }
 
@@ -320,7 +326,7 @@ class Player extends EventEmitter {
     }
 
     clearData() {
-        this.#dataStore.delete()
+        this.#dataStore.clear();
         return this;
     }
 

package/build/structures/Track.js

@@ -13,22 +13,22 @@ class Track {
    * @param {Node} nodes
    */
   constructor(data, requester, nodes) {
-    const info = data?.info || {};
+    const { info = {}, encoded = null, playlist = null } = data || {};
     
-    this.info = {
+    this.info = Object.freeze({
       identifier: info.identifier || '',
-      isSeekable: !!info.isSeekable,
+      isSeekable: Boolean(info.isSeekable),
       author: info.author || '',
-      length: ~~info.length,
-      isStream: !!info.isStream,
+      length: info.length | 0,
+      isStream: Boolean(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.track = encoded;
+    this.playlist = playlist;
     this.requester = requester;
     this.nodes = nodes;
   }
@@ -38,8 +38,9 @@ class Track {
    * @returns {string|null}
    */
   resolveThumbnail(thumbnail) {
-    if (!thumbnail) return null;
-    return thumbnail.startsWith("http") ? thumbnail : getImageUrl(thumbnail, this.nodes);
+    return thumbnail && thumbnail.startsWith("http") ? 
+      thumbnail : 
+      thumbnail ? getImageUrl(thumbnail, this.nodes) : null;
   }
 
   /**
@@ -47,12 +48,14 @@ class Track {
    * @returns {Promise<Track|null>}
    */
   async resolve(aqua) {
-    if (!aqua?.options?.defaultSearchPlatform) return null;
+    const searchPlatform = aqua?.options?.defaultSearchPlatform;
+    if (!searchPlatform) return null;
 
     try {
+      const query = `${this.info.author} - ${this.info.title}`;
       const result = await aqua.resolve({
-        query: this.info.author + ' - ' + this.info.title,
-        source: aqua.options.defaultSearchPlatform,
+        query,
+        source: searchPlatform,
         requester: this.requester,
         node: this.nodes
       });
@@ -62,7 +65,10 @@ class Track {
       const track = this._findMatchingTrack(result.tracks);
       if (!track) return null;
 
-      this._updateTrack(track);
+      this.info.identifier = track.info.identifier;
+      this.track = track.track;
+      this.playlist = track.playlist || null;
+
       return this;
     } catch {
       return null;
@@ -74,40 +80,24 @@ class Track {
    */
   _findMatchingTrack(tracks) {
     const { author, title, length } = this.info;
-
-    for (let i = 0; i < tracks.length; i++) {
-      const track = tracks[i];
+    
+    for (const track of tracks) {
       const tInfo = track.info;
       
-      if (tInfo.author === author && 
-          tInfo.title === title && 
-          (!length || Math.abs(tInfo.length - length) <= 2000)) {
+      if (!author || !title || author !== tInfo.author || title !== tInfo.title) {
+        continue;
+      }
+      
+      if (!length || Math.abs(tInfo.length - length) <= 2000) {
         return track;
       }
     }
 
     return tracks[0];
   }
-
-  /**
-   * @private
-   */
-  _updateTrack(track) {
-    this.info.identifier = track.info.identifier;
-    this.track = track.track;
-    this.playlist = track.playlist || null;
-  }
-
-  /**
-   * Fast cleanup
-   */
   destroy() {
-    this.requester = null;
-    this.nodes = null;
-    this.track = null;
-    this.playlist = null;
-    this.info = null;
+    Object.keys(this).forEach(key => this[key] = null);
   }
 }
 
-module.exports = { Track };
+module.exports = { Track };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aqualink",
-  "version": "1.7.0-beta4",
+  "version": "1.7.0-beta6",
   "description": "An Lavalink wrapper, focused in speed, performance, and features, Based in Riffy!",
   "main": "build/index.js",
   "scripts": {
@@ -36,7 +36,7 @@
   "author": "mushroom0162 (https://github.com/ToddyTheNoobDud)",
   "license": "ISC",
   "dependencies": {
-    "undici": "^7.2.0",
+    "undici": "^7.3.0",
     "ws": "^8.18.0"
   },
   "repository": {