aqualink 1.8.1-beta4 → 1.9.0

package/README.md

@@ -4,7 +4,7 @@ An Stable, performant, Recourse friendly and fast lavalink wrapper
 This code is based in riffy, but its an 100% Rewrite made from scratch...
 
 # Why use AquaLink
-- In dev
+- Uses my modified fork of @performanc/pwsl-mini, for an way faster WebSocket
 - Very Low memory comsuption
 - Built in Queue manager
 - Lots of features to use
@@ -16,64 +16,89 @@ This code is based in riffy, but its an 100% Rewrite made from scratch...
 - Lavalink v4 support (din't test v3)
 - Youtube and Spotify support (Soundcloud, deezer, vimeo, etc also works...)
 - Minimal Requests to the lavalink server (helps the lavalink recourses!)
-- Easy player, node, aqua manager 
+- Easy player, node, aqua manager
 - Fast responses from rest and node
 - Playlist support (My mix playlists, youtube playlists, spotify playlists, etc)
 - Lyrics Support by Lavalink
   - https://github.com/topi314/LavaLyrics (RECOMMENDED)
   - https://github.com/DRSchlaubi/lyrics.kt (?)
   - https://github.com/DuncteBot/java-timed-lyrics (RECOMMENDED)
+  
+# Tralalero Tralala 1.9.0 Released  
+**Whoa, lots of stuff to write here 😭**
+
+---
+
+### **Small changes on the `fetchImage` Handler**
+- Improves the overall speed, less memory overhead.
+
+---
+
+### **Remade some stuff on `AQUA` module**
+- This fixes some bugs related to destroying players.
+- Faster node connection speeds.
+- Uses an Array for getting the region instead (testing).
+- Small change on the Voice Handler.
+- Improved Error handling.
+- Use `node.destroy()` method directly.
+
+---
+
+### **Remade `Connection` module**
+- Removed lots of useless code.
+- Improved joining voice channel speed.
+- Improved configuration set/get speed.
+- Improved overall checking.
+- Improved debug messages.
+
+---
+
+### **Remade `Node` module (this one is good)**
+- Fixed the `autoResume` system (now will actually work, for 60 seconds).
+- New WebSocket System.
+- Improved the events handling speed.
+- Now does recalculation of the backoff time (for more efficiency on reconnect).
+- Now avoids reconnecting if the WebSocket is already open (sorry, I forgot to add this before).
+- Better cleaning system (improved, now removes listeners instead of setting to `null`).
+- Avoids re-binding the functions every time `connect` is called (yay).
+- This update also improves long-process running.
+
+---
+
+### **Remade the `Player` module (also a good one)**
+- Remade every method.
+- Fixed destroy system.
+- Better event handling, I think.
+- Made the events async.
+- Removed `trackChange` (does not exist in Lavalink API, use `trackStart` instead).
+- Uses a new listener system (way more efficient for creating/destroying players).
+- Faster shuffle in V8 Engine (Math stuff).
+- Improved overall configs (more precise).
+- Use `pop()` instead of disabling the track 50 on the length.
+- Improved overall speed on the check-ins and some stuff I forgot.
+
+---
+
+### **Remade the `Rest` module**
+- Better speed (removed useless `buildEndpoint`).
+- More compact code.
+- Removed `stats/all` in the stats (correct by using the Lavalink API).
+- Better `makeRequest`.
+
+---
+
+### **Small changes in `Track` module**
+- More efficient final result (`author` + `track`).
+
+---
+
+That’s all for **1.9.0** atm. I’m a lazy dev. 😴
 
 # Docs (Wiki)
 - https://github.com/ToddyTheNoobDud/AquaLink/wiki
 
 - Example bot: https://github.com/ToddyTheNoobDud/Thorium-Music
 
-# Brick by brick, 1.8.0 Update (yay)
-
-### 1.8.1-beta4 Update:
-- Use pool for connections (Experimental, help me improve it. Undici pool)
-- Default will not leave the VC anymore (leaveOnEnd: false default)
-- Misc optimizations on node and player
-
-### 1.8.0
-- Misc changes on FetchImage (improves the overall checking and speed)
-- Rewrite `AQUA` module
-  - Remade the resolve logic (improves the speed by a lot)
-  - Fixes many memory usages related to nodes
-  - send is no longer required to be Applied (Applied by default now.)
-  - Remade some stuff with discord VoiceGateway
-
-- Remade `CONNECTION` module
-  - Way faster connections (Joining, reconnecting, connected, disconnect)
-  - Reduced memory overload by removing useless code
-  - Improved early Returns
-
-- Remade `NODE` module
-  - MANY fixes for the connection logic (fixes reconnection, etc)
-  - Fixed memory leaks in heartbeat system (hopefully, reduced memory by a lot.)
-  - Faster connection speed and checkings
-  - Remade the Options system, improve JSON parsing
-
-- Rewrite `PLAYER` module
-  - Many memory related fixes
-  - Improved the overall code speed by a lot
-  - Rewrote setLoop, play, shuffle, replay methods (fixes + performance)
-  - Added 2 new options: 
-
-      leaveOnEnd: false, // Optional
-
-      shouldDeleteMessage: true // Optional
-    
-  - Uses array for better performance and less memory allocation
-  - Rewrite the Events handling (speed and recourses fixes)
-
-- Updated `TRACK` module
-  - Better object handling for internal code.
-  - Removed an useless method
-
-Thats all for now, im lazy, help me fix code and improve this on github... i can't test properly 😭😭😭
-
 # How to install
 
 `npm install aqualink`

package/build/handlers/fetchImage.js

@@ -1,15 +1,19 @@
 const { request } = require("undici");
+
 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_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;
+
     const handler = sourceHandlers.get(info.sourceName.toLowerCase());
     if (!handler) return null;
+
     try {
         return await handler(info.uri);
     } catch (error) {
@@ -33,15 +37,12 @@ async function fetchThumbnail(url) {
 }
 
 async function fetchYouTubeThumbnail(identifier) {
-    try {
-        const thumbnail = await Promise.race(
-            YOUTUBE_QUALITIES.map(urlFunc => fetchThumbnail(urlFunc(identifier)))
-        );
-        return thumbnail || null;
-    } catch (error) {
-        console.error('No valid YouTube thumbnail found:', error);
+    return Promise.race(
+        YOUTUBE_QUALITIES.map(urlFunc => fetchThumbnail(urlFunc(identifier)))
+    ).catch(() => {
+        console.error('No valid YouTube thumbnail found.');
         return null;
-    }
+    });
 }
 
-module.exports = { getImageUrl };
+module.exports = { getImageUrl };

package/build/structures/Aqua.js

@@ -8,17 +8,6 @@ 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.
-     * @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.
-     */
     constructor(client, nodes, options = {}) {
         super();
         this.validateInputs(client, nodes, options);
@@ -61,61 +50,68 @@ class Aqua extends EventEmitter {
     get leastUsedNodes() {
         const now = Date.now();
         if (now - this._leastUsedCache.timestamp < 50) return this._leastUsedCache.nodes;
+
         const nodes = [];
         for (const node of this.nodeMap.values()) {
             if (node.connected) nodes.push(node);
         }
         nodes.sort((a, b) => a.rest.calls - b.rest.calls);
+
         this._leastUsedCache = { nodes, timestamp: now };
         return nodes;
     }
 
     init(clientId) {
         if (this.initiated) return this;
+
         this.clientId = clientId;
         try {
             this.nodes.forEach(nodeConfig => this.createNode(nodeConfig));
-            this.initiated = true;
             this.plugins.forEach(plugin => plugin.load(this));
+            this.initiated = true;
         } catch (error) {
             this.initiated = false;
             throw error;
         }
+
         return this;
     }
 
     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;
-        node.connect().then(() => {
-            this.emit("nodeCreate", node);
-        }).catch(error => {
-            this.nodeMap.delete(nodeId);
-            throw error;
-        });
+
+        node.connect()
+            .then(() => this.emit("nodeCreate", node))
+            .catch(error => {
+                this.nodeMap.delete(nodeId);
+                console.error("Failed to connect node:", error);
+                throw error;
+            });
+
         return node;
     }
 
     destroyNode(identifier) {
         const node = this.nodeMap.get(identifier);
         if (!node) return;
-        node.disconnect().then(() => {
-            node.removeAllListeners();
-            this.nodeMap.delete(identifier);
-            this._leastUsedCache.timestamp = 0;
-            this.emit("nodeDestroy", node);
-        }).catch(error => console.error(`Error destroying node ${identifier}:`, error));
+
+        node.destroy();
+        this.nodeMap.delete(identifier);
+        this.emit("nodeDestroy", node);
     }
 
+
     updateVoiceState({ d, t }) {
         const player = this.players.get(d.guild_id);
         if (!player) return;
 
+        const updateMethod = t === "VOICE_SERVER_UPDATE" ? "setServerUpdate" : "setStateUpdate";
         if (t === "VOICE_SERVER_UPDATE" || (t === "VOICE_STATE_UPDATE" && d.user_id === this.clientId)) {
-            const updateMethod = t === "VOICE_SERVER_UPDATE" ? "setServerUpdate" : "setStateUpdate";
             if (player.connection && typeof player.connection[updateMethod] === "function") {
                 player.connection[updateMethod](d);
             }
@@ -127,14 +123,13 @@ 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 regionNodes = Array.from(this.nodeMap.values()).filter(node => 
+            node.connected && node.regions?.includes(lowerRegion)
+        );
         regionNodes.sort((a, b) => this.calculateLoad(a) - this.calculateLoad(b));
+
         return regionNodes;
     }
 
@@ -148,9 +143,11 @@ class Aqua extends EventEmitter {
         this.ensureInitialized();
         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);
     }
 
@@ -167,6 +164,7 @@ class Aqua extends EventEmitter {
     async destroyPlayer(guildId) {
         const player = this.players.get(guildId);
         if (!player) return;
+
         try {
             await player.clearData();
             player.removeAllListeners();
@@ -276,4 +274,4 @@ class Aqua extends EventEmitter {
     }
 }
 
-module.exports = Aqua 
+module.exports = Aqua;

package/build/structures/Connection.js

@@ -3,58 +3,41 @@
 class Connection {
     constructor(player) {
         this.playerRef = new WeakRef(player);
-        const { voiceChannel, guildId, aqua, nodes } = player;
-        this.voice = {
-            sessionId: null,
-            endpoint: null,
-            token: null
-        };
+        this.voice = { sessionId: null, endpoint: null, token: null };
         this.region = null;
         this.selfDeaf = false;
         this.selfMute = false;
-        this.voiceChannel = voiceChannel;
-        this.guildId = guildId;
-        this.aqua = aqua;
-        this.nodes = nodes;
+        this.voiceChannel = player.voiceChannel;
+        this.guildId = player.guildId;
+        this.aqua = player.aqua;
+        this.nodes = player.nodes;
     }
 
-    setServerUpdate(data = {}) {
-        const { endpoint, token } = data;
-
-        if (!endpoint) {
-            throw new Error("Missing 'endpoint' property");
-        }
-
+    setServerUpdate({ endpoint, token } = {}) {
+        if (!endpoint) throw new Error("Missing 'endpoint' property");
         const newRegion = endpoint.split('.')[0];
         if (this.region !== newRegion) {
-            this.voice.endpoint = endpoint;
-            this.voice.token = token;
+            this.voice = { ...this.voice, endpoint, token };
             const prevRegion = this.region;
             this.region = newRegion;
-
-            const message = prevRegion
-                ? `Changed Voice Region from ${prevRegion} to ${newRegion}`
-                : `Voice Server: ${newRegion}`;
-
-            this.aqua.emit("debug", `[Player ${this.guildId} - CONNECTION] ${message}`);
+            this.aqua.emit("debug", `[Player ${this.guildId} - CONNECTION] Voice Server: ${prevRegion ? `Changed from ${prevRegion} to ${newRegion}` : newRegion}`);
             this._updatePlayerVoiceData();
         }
     }
 
-    setStateUpdate({ channel_id: channelId, session_id: sessionId, self_deaf: selfDeaf, self_mute: selfMute } = {}) {
-        if (!channelId || !sessionId) {
+    setStateUpdate({ channel_id, session_id, self_deaf, self_mute } = {}) {
+        if (!channel_id || !session_id) {
             this.playerRef.deref()?.destroy();
             return;
         }
-
-        if (this.voiceChannel !== channelId) {
-            this.aqua.emit("playerMove", this.voiceChannel, channelId);
-            this.voiceChannel = channelId;
+        
+        if (this.voiceChannel !== channel_id) {
+            this.aqua.emit("playerMove", this.voiceChannel, channel_id);
+            this.voiceChannel = channel_id;
         }
-
-        this.selfDeaf = selfDeaf;
-        this.selfMute = selfMute;
-        this.voice.sessionId = sessionId;
+        
+        Object.assign(this, { selfDeaf: self_deaf, selfMute: self_mute });
+        this.voice.sessionId = session_id;
     }
 
     async _updatePlayerVoiceData() {
@@ -64,19 +47,12 @@ class Connection {
         try {
             await this.nodes.rest.updatePlayer({
                 guildId: this.guildId,
-                data: {
-                    voice: this.voice,
-                    volume: player.volume
-                }
+                data: { voice: this.voice, volume: player.volume }
             });
         } catch (err) {
-            this.aqua.emit("apiError", "updatePlayer", {
-                error: err,
-                guildId: this.guildId,
-                voiceData: this.voice
-            });
+            this.aqua.emit("apiError", "updatePlayer", { error: err, guildId: this.guildId, voiceData: this.voice });
         }
     }
 }
 
-module.exports = Connection;
+module.exports = Connection;

package/build/structures/Node.js

@@ -1,5 +1,5 @@
 "use strict";
-const WebSocket = require("ws");
+const WebSocket = require("@toddynnn/pwsl-mini");
 const Rest = require("./Rest");
 
 class Node {
@@ -30,7 +30,6 @@ class Node {
         this.regions = regions;
         this.wsUrl = new URL(`ws${secure ? "s" : ""}://${host}:${port}/v4/websocket`);
         this.rest = new Rest(aqua, this);
-        this.resumeKey = options.resumeKey || null;
         this.resumeTimeout = options.resumeTimeout || 60;
         this.autoResume = options.autoResume || false;
         this.reconnectTimeout = options.reconnectTimeout || 2000;
@@ -59,6 +58,8 @@ class Node {
     }
 
     async connect() {
+        if (this.#ws && this.#ws.readyState === WebSocket.OPEN) return;
+        
         this.#ws = new WebSocket(this.wsUrl.href, {
             headers: this.#constructHeaders(),
             perMessageDeflate: false,
@@ -70,35 +71,35 @@ class Node {
     }
 
     #constructHeaders() {
-        return {
+        const headers = {
             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;
+        return headers;
     }
 
     async #onOpen() {
         this.connected = true;
         this.#reconnectAttempted = 0;
         this.aqua.emit("debug", this.name, `Connected to ${this.wsUrl.href}`);
-        
-        if (this.autoResume) {
-            try {
-                this.info = await this.rest.makeRequest("GET", "/v4/info");
+
+        try {
+            this.info = await this.rest.makeRequest("GET", "/v4/info");
+            if (this.autoResume && this.sessionId) {
                 await this.resumePlayers();
-            } catch (err) {
-                this.info = null;
-                if (!this.aqua.bypassChecks?.nodeFetchInfo) {
-                    this.aqua.emit("error", `Failed to fetch node info: ${err.message}`);
-                }
+            }
+        } catch (err) {
+            this.info = null;
+            if (!this.aqua.bypassChecks?.nodeFetchInfo) {
+                this.aqua.emit("error", this, `Failed to fetch node info: ${err.message}`);
             }
         }
     }
 
     async getStats() {
-        const stats = await this.rest.makeRequest("GET", "/v4/stats");
+        const stats = await this.rest.getStats();
         this.stats = { ...this.defaultStats, ...stats };
         return this.stats;
     }
@@ -108,8 +109,9 @@ class Node {
         try {
             payload = JSON.parse(msg);
         } catch {
-            return;
+            return; // Invalid JSON, ignore the message
         }
+
         const op = payload?.op;
         if (!op) return;
 
@@ -125,6 +127,18 @@ class Node {
         }
     }
 
+    async resumePlayers() {
+        try {
+            await this.rest.makeRequest("PATCH", `/v4/sessions/${this.sessionId}`, {
+                resuming: true,
+                timeout: this.resumeTimeout
+            });
+            this.aqua.emit("debug", this.name, `Successfully resumed session ${this.sessionId}`);
+        } catch (err) {
+            this.aqua.emit("error", this, `Failed to resume session: ${err.message}`);
+        }
+    }
+
     #updateStats(payload) {
         if (!payload) return;
         this.stats = {
@@ -170,14 +184,20 @@ class Node {
     }
 
     #handleReadyOp(payload) {
-        if (this.sessionId !== payload.sessionId) {
-            this.sessionId = payload.sessionId;
-            this.rest.setSessionId(payload.sessionId);
+        if (!payload.sessionId) {
+            this.aqua.emit("error", this, "Ready payload missing sessionId");
+            return;
         }
+
+        this.sessionId = payload.sessionId;
+        this.rest.setSessionId(payload.sessionId);
+
+        // Don't resume here - we'll handle resuming in the #onOpen method if autoResume is enabled
         this.aqua.emit("nodeConnect", this);
     }
 
     #handlePlayerOp(payload) {
+        if (!payload.guildId) return;
         const player = this.aqua.players.get(payload.guildId);
         if (player) player.emit(payload.op, payload);
     }
@@ -188,7 +208,7 @@ class Node {
 
     #onClose(code, reason) {
         this.connected = false;
-        this.aqua.emit("nodeDisconnect", this, { code, reason });
+        this.aqua.emit("nodeDisconnect", this, { code, reason: reason?.toString() || "No reason provided" });
         this.#reconnect();
     }
 
@@ -198,22 +218,24 @@ class Node {
             setTimeout(() => this.connect(), 10000);
             return;
         }
+
         if (this.#reconnectAttempted >= this.reconnectTries) {
             this.aqua.emit("nodeError", this, 
                 new Error(`Max reconnection attempts reached (${this.reconnectTries})`));
             this.destroy(true);
             return;
         }
+
         clearTimeout(this.#reconnectTimeoutId);
         const jitter = Math.random() * 10000;
         const backoffTime = Math.min(
             this.reconnectTimeout * Math.pow(Node.BACKOFF_MULTIPLIER, this.#reconnectAttempted) + jitter,
             Node.MAX_BACKOFF
         );
+
         this.#reconnectTimeoutId = setTimeout(() => {
             this.#reconnectAttempted++;
-            this.aqua.emit("nodeReconnect", {
-                nodeName: this.name,
+            this.aqua.emit("nodeReconnect", this, {
                 attempt: this.#reconnectAttempted,
                 backoffTime
             });
@@ -222,11 +244,22 @@ class Node {
     }
 
     destroy(clean = false) {
+        clearTimeout(this.#reconnectTimeoutId);
+
+        if (this.#ws) {
+            this.#ws.removeAllListeners();
+            if (this.#ws.readyState === WebSocket.OPEN) {
+                this.#ws.close();
+            }
+            this.#ws = null;
+        }
+
         if (clean) {
             this.aqua.emit("nodeDestroy", this);
             this.aqua.nodes.delete(this.name);
             return;
         }
+
         if (this.connected) {
             for (const player of this.aqua.players.values()) {
                 if (player.node === this) {
@@ -234,11 +267,12 @@ class Node {
                 }
             }
         }
+
         this.connected = false;
-        this.aqua.nodeMap.delete(this.name);
+        this.aqua.nodes.delete(this.name);
         this.aqua.emit("nodeDestroy", this);
         this.info = null;
     }
 }
 
-module.exports = Node;
+module.exports = Node;

package/build/structures/Player.js

@@ -1,9 +1,9 @@
 "use strict";
 
 const { EventEmitter } = require("events");
-const  Connection = require("./Connection");
-const  Queue  = require("./Queue");
-const  Filters  = require("./Filters");
+const Connection = require("./Connection");
+const Queue = require("./Queue");
+const Filters = require("./Filters");
 
 class Player extends EventEmitter {
     static LOOP_MODES = Object.freeze({
@@ -30,32 +30,22 @@ class Player extends EventEmitter {
         this.voiceChannel = options.voiceChannel;
         this.connection = new Connection(this);
         this.filters = new Filters(this);
-        this.mute = options.mute ?? false;
-        this.deaf = options.deaf ?? false;
-        this.volume = options.defaultVolume ?? 100;
-        this.loop = options.loop ?? Player.LOOP_MODES.NONE;
+        this.volume = Math.min(Math.max(options.defaultVolume ?? 100, 0), 200);
+        this.loop = Player.LOOP_MODES[options.loop?.toUpperCase()] || Player.LOOP_MODES.NONE;
         this.queue = new Queue();
-        this.position = 0;
-        this.current = null;
+        this.previousTracks = [];
+        this.shouldDeleteMessage = options.shouldDeleteMessage ?? false;
+        this.leaveOnEnd = options.leaveOnEnd ?? false;
+
         this.playing = false;
         this.paused = false;
         this.connected = false;
+        this.current = null;
         this.timestamp = 0;
         this.ping = 0;
         this.nowPlayingMessage = null;
-        this.previousTracks = [];
-        this.shouldDeleteMessage = options.shouldDeleteMessage ?? false;
-        this.leaveOnEnd = options.leaveOnEnd ?? false;
-        
-        this.onPlayerUpdate = ({ state } = {}) => {
-            if (!state) return;
-            for (const key in state) {
-                if (state.hasOwnProperty(key)) {
-                    this[key] = state[key];
-                }
-            }
-            this.aqua.emit("playerUpdate", this, { state });
-        };
+
+        this.onPlayerUpdate = ({ state }) => state && Object.assign(this, state) && this.aqua.emit("playerUpdate", this, { state });
         this.handleEvent = async (payload) => {
             const player = this.aqua.players.get(payload.guildId);
             if (!player) return;
@@ -66,8 +56,12 @@ class Player extends EventEmitter {
                 this.handleUnknownEvent(payload);
             }
         };
-        this.on("playerUpdate", this.onPlayerUpdate);
-        this.on("event", this.handleEvent);
+        if (!this.listenerCount("playerUpdate")) {
+            this.on("playerUpdate", this.onPlayerUpdate);
+        }
+        if (!this.listenerCount("event")) {
+            this.on("event", this.handleEvent);
+        }
     }
 
     get previous() {
@@ -78,21 +72,18 @@ class Player extends EventEmitter {
     }
 
     addToPreviousTrack(track) {
-        if (this.previousTracks.length >= 50) {
-            this.previousTracks.length = 49;
-        }
+        if (this.previousTracks.length >= 50) this.previousTracks.pop();
         this.previousTracks.unshift(track);
     }
 
     async play() {
-        if (!this.connected) throw new Error("Player must be connected first.");
-        if (!this.queue.length) return;
-
+        if (!this.connected || !this.queue.length) return;
         const item = this.queue.shift();
+
         this.current = item.track ? item : await item.resolve(this.aqua);
         this.playing = true;
         this.position = 0;
-        
+
         this.aqua.emit("debug", this.guildId, `Playing track: ${this.current.track}`);
         return this.updatePlayer({ track: { encoded: this.current.track } });
     }
@@ -128,39 +119,25 @@ class Player extends EventEmitter {
 
     async searchLyrics(query) {
         if (!query) return null;
-        const response = await this.nodes.rest.getLyrics({
-            track: {
-                encoded: { info: { title: query } },
-                guild_id: this.guildId,
-                search: true
-            }
-        });
-        return response || null;
+        return await this.nodes.rest.getLyrics({ track: { info: { title: query } }, search: true }) || null;
     }
 
     async lyrics() {
         if (!this.playing) return null;
-        const response = await this.nodes.rest.getLyrics({
-            track: {
-                encoded: this.current.track,
-                guild_id: this.guildId
-            }
-        });
-        return response || null;
+        return await this.nodes.rest.getLyrics({ track: { encoded: this.current.track } }) || null;
     }
 
     seek(position) {
         if (!this.playing) return this;
-        this.position += position;
-        this.updatePlayer({ position: this.position });
+        this.updatePlayer({ position: (this.position += position) });
         return this;
     }
 
     stop() {
         if (!this.playing) return this;
-        this.updatePlayer({ track: { encoded: null } });
         this.playing = false;
         this.position = 0;
+        this.updatePlayer({ track: { encoded: null } });
         return this;
     }
 
@@ -179,6 +156,7 @@ class Player extends EventEmitter {
     }
 
     setTextChannel(channel) {
+        this.textChannel = channel;
         this.updatePlayer({ text_channel: channel });
         return this;
     }
@@ -199,23 +177,14 @@ class Player extends EventEmitter {
     }
 
     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.");
+        this.voiceChannel = null;
+        this.aqua.emit("debug", this.guildId, "Player disconnected.");
         return this;
     }
-
     shuffle() {
-        const array = this.queue;
-        let currentIndex = array.length;
-        
-        while (currentIndex > 0) {
-            const randomIndex = Math.floor(Math.random() * currentIndex);
-            currentIndex--;
-            [array[currentIndex], array[randomIndex]] = [array[randomIndex], array[currentIndex]];
-        }
-        
+        this.queue = this.queue.sort(() => Math.random() - 0.5);
         return this;
     }
 
@@ -225,7 +194,6 @@ class Player extends EventEmitter {
 
     replay() {
         this.seek(-this.position);
-        return this;
     }
 
     skip() {
@@ -238,19 +206,19 @@ class Player extends EventEmitter {
         this.aqua.emit("trackStart", player, track);
     }
 
-    trackChange(player, track) {
+    async trackChange(player, track) {
         this.updateTrackState(true, false);
         this.aqua.emit("trackChange", player, track);
     }
 
     async trackEnd(player, track, payload) {
         if (this.shouldDeleteMessage && this.nowPlayingMessage) {
-            await this.nowPlayingMessage.delete().catch(() => {});
+            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);
@@ -283,17 +251,17 @@ class Player extends EventEmitter {
         await player.play();
     }
 
-    trackError(player, track, payload) {
+    async trackError(player, track, payload) {
         this.aqua.emit("trackError", player, track, payload);
         return this.stop();
     }
 
-    trackStuck(player, track, payload) {
+    async trackStuck(player, track, payload) {
         this.aqua.emit("trackStuck", player, track, payload);
         return this.stop();
     }
 
-    socketClosed(player, payload) {
+    async socketClosed(player, payload) {
         if (payload?.code === 4015 || payload?.code === 4009) {
             this.send({
                 guild_id: payload.guildId,
@@ -311,22 +279,23 @@ class Player extends EventEmitter {
         this.aqua.send({ op: 4, d: data });
     }
 
-     #dataStore = new Map();
+    #dataStore = new WeakMap();
+
+    set(key, value) {
+        this.#dataStore.set(key, value);
+    }
+
+    get(key) {
+        return this.#dataStore.get(key);
+    }
+
+    clearData() {
+        this.#dataStore = new WeakMap();
+        return this;
+    }
 
-     set(key, value) {
-         this.#dataStore.set(key, value);
-     }
- 
-     get(key) {
-         return this.#dataStore.get(key);
-     }
- 
-     clearData() {
-         this.#dataStore.clear(); 
-         return this;
-     }
 
-     updatePlayer(data) {
+    updatePlayer(data) {
         return this.nodes.rest.updatePlayer({ guildId: this.guildId, data });
     }
 

package/build/structures/Rest.js

@@ -2,7 +2,7 @@
 const { Pool } = require("undici");
 
 class Rest {
-    constructor(aqua, { secure, host, port, sessionId, password,}) {
+    constructor(aqua, { secure, host, port, sessionId, password }) {
         this.aqua = aqua;
         this.sessionId = sessionId;
         this.version = "v4";
@@ -11,9 +11,7 @@ class Rest {
             "Content-Type": "application/json",
             Authorization: password,
         };
-        this.client = new Pool(this.baseUrl, {
-            pipelining: 1,
-        });
+        this.client = new Pool(this.baseUrl, { pipelining: 1 });
     }
 
     setSessionId(sessionId) {
@@ -21,101 +19,77 @@ class Rest {
     }
 
     async makeRequest(method, endpoint, body = null) {
-        const options = {
-            path: endpoint,
-            method,
-            headers: this.headers,
-            ...(body && { body: JSON.stringify(body) }),
-        };
         try {
-            const response = await this.client.request(options);
-            const { statusCode } = response;
-            return statusCode === 204 ? null : await response.body.json();
+            const response = await this.client.request({
+                path: endpoint,
+                method,
+                headers: this.headers,
+                body: body ? JSON.stringify(body) : undefined,
+            });
+
+            return response.statusCode === 204 ? null : await response.body.json();
         } catch (error) {
-            throw new Error(`Request to ${endpoint} failed: ${error.message}`);
+            throw new Error(`Request failed (${method} ${endpoint}): ${error.message}`);
         }
     }
 
-    buildEndpoint(...segments) {
-        const validSegments = segments.filter(segment => segment && segment.trim());
-        return '/' + validSegments.join('/');
-    }
-
     validateSessionId() {
-        if (!this.sessionId) {
-            throw new Error("Session ID is not set.");
-        }
+        if (!this.sessionId) throw new Error("Session ID is not set.");
     }
 
     async updatePlayer({ guildId, data }) {
-        const hasEncodedTrack = data.track?.encoded && data.track?.identifier;
-        const hasEncodedTrackAlt = data.encodedTrack && data.identifier;
-
-        if (hasEncodedTrack || hasEncodedTrackAlt) {
+        if ((data.track?.encoded && data.track?.identifier) || (data.encodedTrack && data.identifier)) {
             throw new Error("Cannot provide both 'encoded' and 'identifier' for track");
         }
-
         this.validateSessionId();
-        const endpoint = this.buildEndpoint(this.version, "sessions", this.sessionId, "players", guildId) + "?noReplace=false";
-        return this.makeRequest("PATCH", endpoint, data);
+        return this.makeRequest("PATCH", `/${this.version}/sessions/${this.sessionId}/players/${guildId}?noReplace=false`, data);
     }
 
     async getPlayers() {
         this.validateSessionId();
-        const endpoint = this.buildEndpoint(this.version, "sessions", this.sessionId, "players");
-        return this.makeRequest("GET", endpoint);
+        return this.makeRequest("GET", `/${this.version}/sessions/${this.sessionId}/players`);
     }
 
     async destroyPlayer(guildId) {
         this.validateSessionId();
-        const endpoint = this.buildEndpoint(this.version, "sessions", this.sessionId, "players", guildId);
-        return this.makeRequest("DELETE", endpoint);
+        return this.makeRequest("DELETE", `/${this.version}/sessions/${this.sessionId}/players/${guildId}`);
     }
 
     async getTracks(identifier) {
-        const endpoint = `/${this.version}/loadtracks?identifier=${encodeURIComponent(identifier)}`;
-        return this.makeRequest("GET", endpoint);
+        return this.makeRequest("GET", `/${this.version}/loadtracks?identifier=${encodeURIComponent(identifier)}`);
     }
 
     async decodeTrack(track) {
-        const endpoint = `/${this.version}/decodetrack?encodedTrack=${encodeURIComponent(track)}`;
-        return this.makeRequest("GET", endpoint);
+        return this.makeRequest("GET", `/${this.version}/decodetrack?encodedTrack=${encodeURIComponent(track)}`);
     }
 
     async decodeTracks(tracks) {
-        const endpoint = `/${this.version}/decodetracks`;
-        return this.makeRequest("POST", endpoint, tracks);
+        return this.makeRequest("POST", `/${this.version}/decodetracks`, tracks);
     }
 
     async getStats() {
-        const endpoint = `/${this.version}/stats/all`;
-        return this.makeRequest("GET", endpoint);
+        return this.makeRequest("GET", `/${this.version}/stats`);
     }
 
     async getInfo() {
-        const endpoint = `/${this.version}/info`;
-        return this.makeRequest("GET", endpoint);
+        return this.makeRequest("GET", `/${this.version}/info`);
     }
 
     async getRoutePlannerStatus() {
-        const endpoint = `/${this.version}/routeplanner/status`;
-        return this.makeRequest("GET", endpoint);
+        return this.makeRequest("GET", `/${this.version}/routeplanner/status`);
     }
 
     async getRoutePlannerAddress(address) {
-        const endpoint = `/${this.version}/routeplanner/free/address`;
-        return this.makeRequest("POST", endpoint, { address });
+        return this.makeRequest("POST", `/${this.version}/routeplanner/free/address`, { address });
     }
 
     async getLyrics({ track }) {
         if (track.search) {
-            const endpoint = `/v4/lyrics/search?query=${encodeURIComponent(track.encoded.info.title)}&source=genius`;
-            const res = await this.makeRequest("GET", endpoint);
+            const res = await this.makeRequest("GET", `/${this.version}/lyrics/search?query=${encodeURIComponent(track.encoded.info.title)}&source=genius`);
             if (res) return res;
         }
         this.validateSessionId();
-        const endpoint = this.buildEndpoint(this.version, "sessions", this.sessionId, "players", track.guild_id, "track", "lyrics") + "?skipTrackSource=false";
-        return this.makeRequest("GET", endpoint);
+        return this.makeRequest("GET", `/${this.version}/sessions/${this.sessionId}/players/${track.guild_id}/track/lyrics?skipTrackSource=false`);
     }
 }
 

package/build/structures/Track.js

@@ -1,16 +1,7 @@
 "use strict";
 const { getImageUrl } = require("../handlers/fetchImage");
-/**
- * @typedef {import("../Aqua")} Aqua
- * @typedef {import("../structures/Player")} Player
- * @typedef {import("../structures/Node")} Node
- */
+
 class Track {
-  /**
-   * @param {Object} data
-   * @param {Player} requester
-   * @param {Node} nodes
-   */
   constructor(data = {}, requester, nodes) {
     const { info = {}, encoded = null, playlist = null } = data;
     this.info = {
@@ -29,21 +20,18 @@ class Track {
     this.requester = requester;
     this.nodes = nodes;
   }
-  /**
-   * @param {string} thumbnail
-   * @returns {string|null}
-   */
+
   resolveThumbnail(thumbnail) {
-    if (!thumbnail) return null;
-    return getImageUrl(thumbnail);
+    return thumbnail ? getImageUrl(thumbnail) : null;
   }
-  /**
-   * @param {Aqua} aqua
-   * @returns {Promise<Track|null>}
-   */
+
   async resolve(aqua) {
     const searchPlatform = aqua?.options?.defaultSearchPlatform;
-    if (!searchPlatform) return null;
+    if (!searchPlatform) {
+      console.warn("No search platform configured.");
+      return null;
+    }
+
     try {
       const query = `${this.info.author} - ${this.info.title}`;
       const result = await aqua.resolve({
@@ -52,9 +40,12 @@ class Track {
         requester: this.requester,
         node: this.nodes
       });
+
       if (!result?.tracks?.length) return null;
       const track = this._findMatchingTrack(result.tracks);
       if (!track) return null;
+
+      // Update track info if a match is found
       this.info.identifier = track.info.identifier;
       this.track = track.track;
       this.playlist = track.playlist || null;
@@ -64,6 +55,7 @@ class Track {
       return null;
     }
   }
+
   _findMatchingTrack(tracks) {
     const { author, title, length } = this.info;
     for (const track of tracks) {
@@ -77,4 +69,5 @@ class Track {
     return null;
   }
 }
-module.exports = Track;
+
+module.exports = Track;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aqualink",
-  "version": "1.8.1-beta4",
+  "version": "1.9.0",
   "description": "An Lavalink wrapper, focused in speed, performance, and features, Based in Riffy!",
   "main": "build/index.js",
   "types": "index.d.ts",
@@ -37,8 +37,8 @@
   "author": "mushroom0162 (https://github.com/ToddyTheNoobDud)",
   "license": "ISC",
   "dependencies": {
-    "undici": "^7.3.0",
-    "ws": "^8.18.1"
+    "undici": "^7.4.0",
+		"@toddynnn/pwsl-mini": "github:ToddyTheNoobDud/websocket"
   },
   "repository": {
     "type": "git",