aqualink 2.4.0 → 2.6.0

package/build/structures/Aqua.js

@@ -233,7 +233,7 @@ class Aqua extends EventEmitter {
             const response = await requestNode.rest.makeRequest("GET", endpoint);
             
             if (["empty", "NO_MATCHES"].includes(response.loadType)) {
-                return await this.handleNoMatches(requestNode.rest, query);
+                return await this.handleNoMatches(query);
             }
             
             return this.constructResponse(response, requester, requestNode);
@@ -244,33 +244,29 @@ class Aqua extends EventEmitter {
             throw new Error(`Failed to resolve track: ${error.message}`);
         }
     }
-
+    
     getRequestNode(nodes) {
         if (!nodes) return this.leastUsedNodes[0];
         
         if (nodes instanceof Node) return nodes;
-        if (typeof nodes === "string") return this.nodeMap.get(nodes) || this.leastUsedNodes[0];
+        if (typeof nodes === "string") {
+            const mappedNode = this.nodeMap.get(nodes);
+            return mappedNode || this.leastUsedNodes[0];
+        }
         
         throw new TypeError(`'nodes' must be a string or Node instance, received: ${typeof nodes}`);
     }
-
-    async handleNoMatches(rest, query) {
-        try {
-            const ytEndpoint = `/v4/loadtracks?identifier=https://www.youtube.com/watch?v=${query}`;
-            const youtubeResponse = await rest.makeRequest("GET", ytEndpoint);
-            
-            if (!["empty", "NO_MATCHES"].includes(youtubeResponse.loadType)) {
-                return youtubeResponse;
-            }
-            
-            const spotifyEndpoint = `/v4/loadtracks?identifier=https://open.spotify.com/track/${query}`;
-            return await rest.makeRequest("GET", spotifyEndpoint);
-        } catch (error) {
-            console.error(`Failed to resolve track: ${error.message}`);
-            throw error;
-        }
+    
+    async handleNoMatches(query) {
+        return {
+            loadType: "empty",
+            exception: null,
+            playlistInfo: null,
+            pluginInfo: {},
+            tracks: []
+        };
     }
-
+    
     constructResponse(response, requester, requestNode) {
         const baseResponse = {
             loadType: response.loadType,

package/build/structures/Connection.js

@@ -2,40 +2,44 @@
 
 class Connection {
     constructor(player) {
-        this.playerRef = new WeakRef(player);
+        this.player = player;
         
         this.sessionId = null;
         this.endpoint = null;
         this.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;
+        
+        this.selfDeaf = false;
+        this.selfMute = false;
+        
+        this.hasDebugListeners = this.aqua.listenerCount('debug') > 0;
     }
 
     setServerUpdate(data) {
-        if (!data?.endpoint) return;
+        if (!data || !data.endpoint) return;
         
         const { endpoint, token } = data;
-        const dotIndex = endpoint.indexOf('.');
         
+        const dotIndex = endpoint.indexOf('.');
         if (dotIndex === -1) return;
+        
         const newRegion = endpoint.substring(0, dotIndex);
         
         if (this.region !== newRegion) {
-            const prevRegion = this.region;
-            [this.endpoint, this.token, this.region] = [endpoint, token, newRegion];
+            this.endpoint = endpoint;
+            this.token = token;
+            this.region = newRegion;
             
-            if (this.aqua.listenerCount('debug')) {
+            if (this.hasDebugListeners) {
                 this.aqua.emit(
                     "debug",
                     `[Player ${this.guildId} - CONNECTION] Voice Server: ${
-                        prevRegion ? `Changed from ${prevRegion} to ${newRegion}` : newRegion
+                        this.region ? `Changed from ${this.region} to ${newRegion}` : newRegion
                     }`
                 );
             }
@@ -45,10 +49,12 @@ class Connection {
     }
 
     setStateUpdate(data) {
-        const { channel_id, session_id, self_deaf, self_mute } = data || {};
+        if (!data) return this.player?.destroy();
+        
+        const { channel_id, session_id, self_deaf, self_mute } = data;
         
         if (!channel_id || !session_id) {
-            this.playerRef.deref()?.destroy();
+            this.player?.destroy();
             return;
         }
         
@@ -57,36 +63,35 @@ class Connection {
             this.voiceChannel = channel_id;
         }
         
-        this.selfDeaf = !!self_deaf;
-        this.selfMute = !!self_mute;
+        this.selfDeaf = Boolean(self_deaf);
+        this.selfMute = Boolean(self_mute);
         this.sessionId = session_id;
     }
 
-    async _updatePlayerVoiceData() {
-        const player = this.playerRef.deref();
-        if (!player) return;
+    _updatePlayerVoiceData() {
+        if (!this.player) return;
+
+        const voiceData = {
+            sessionId: this.sessionId,
+            endpoint: this.endpoint,
+            token: this.token
+        };
 
-        try {
-            await this.nodes.rest.updatePlayer({
-                guildId: this.guildId,
-                data: { 
-                    voice: {
-                        sessionId: this.sessionId,
-                        endpoint: this.endpoint,
-                        token: this.token
-                    }, 
-                    volume: player.volume 
-                }
-            });
-        } catch (error) {
-            if (this.aqua.listenerCount('apiError')) {
+        this.nodes.rest.updatePlayer({
+            guildId: this.guildId,
+            data: { 
+                voice: voiceData, 
+                volume: this.player.volume 
+            }
+        }).catch(error => {
+            if (this.aqua.listenerCount('apiError') > 0) {
                 this.aqua.emit("apiError", "updatePlayer", { 
                     error,
                     guildId: this.guildId,
-                    voiceData: { ...this }
+                    voiceData
                 });
             }
-        }
+        });
     }
 }
 

package/build/structures/Filters.js

@@ -3,205 +3,165 @@
 class Filters {
     constructor(player, options = {}) {
         this.player = player;
-        this.volume = options.volume || 1;
-        this.equalizer = options.equalizer || [];
-        this.karaoke = options.karaoke || null;
-        this.timescale = options.timescale || null;
-        this.tremolo = options.tremolo || null;
-        this.vibrato = options.vibrato || null;
-        this.rotation = options.rotation || null;
-        this.distortion = options.distortion || null;
-        this.channelMix = options.channelMix || null;
-        this.lowPass = options.lowPass || null;
-        this.bassboost = options.bassboost || null;
-        this.slowmode = options.slowmode || null;
-        this.nightcore = options.nightcore || null;
-        this.vaporwave = options.vaporwave || null;
-        this._8d = options._8d || null;
         
-        this._filterDataTemplate = {
-            volume: this.volume,
-            equalizer: this.equalizer,
-            karaoke: null,
-            timescale: null,
-            tremolo: null,
-            vibrato: null,
-            rotation: null,
-            distortion: null,
-            channelMix: null,
-            lowPass: null
+        this.defaults = {
+            karaoke: { level: 1.0, monoLevel: 1.0, filterBand: 220.0, filterWidth: 100.0 },
+            timescale: { speed: 1.0, pitch: 1.0, rate: 1.0 },
+            tremolo: { frequency: 2.0, depth: 0.5 },
+            vibrato: { frequency: 2.0, depth: 0.5 },
+            rotation: { rotationHz: 0.0 },
+            distortion: { sinOffset: 0.0, sinScale: 1.0, cosOffset: 0.0, cosScale: 1.0, tanOffset: 0.0, tanScale: 1.0, offset: 0.0, scale: 1.0 },
+            channelMix: { leftToLeft: 1.0, leftToRight: 0.0, rightToLeft: 0.0, rightToRight: 1.0 },
+            lowPass: { smoothing: 20.0 }
         };
+        
+        this.filters = {
+            volume: options.volume || 1,
+            equalizer: options.equalizer || [],
+            karaoke: options.karaoke || null,
+            timescale: options.timescale || null,
+            tremolo: options.tremolo || null,
+            vibrato: options.vibrato || null,
+            rotation: options.rotation || null,
+            distortion: options.distortion || null,
+            channelMix: options.channelMix || null,
+            lowPass: options.lowPass || null
+        };
+        
+        this.presets = {
+            bassboost: options.bassboost !== undefined ? options.bassboost : null,
+            slowmode: options.slowmode !== undefined ? options.slowmode : null,
+            nightcore: options.nightcore !== undefined ? options.nightcore : null,
+            vaporwave: options.vaporwave !== undefined ? options.vaporwave : null,
+            _8d: options._8d !== undefined ? options._8d : null
+        };
+        
+        this._pendingUpdate = false;
+        this._updateTimeout = null;
     }
 
-    _setFilter(filterName, enabled, options, defaults) {
-        if (!enabled) {
-            this[filterName] = null;
-            return this.updateFilters();
-        }
+    _setFilter(filterName, enabled, options = {}, defaultKey = filterName) {
+        this.filters[filterName] = enabled ? { ...this.defaults[defaultKey], ...options } : null;
+        return this._scheduleUpdate();
+    }
+
+    _scheduleUpdate() {
+        this._pendingUpdate = true;
         
-        const filterObj = {};
-        for (const [key, defaultValue] of Object.entries(defaults)) {
-            filterObj[key] = options[key] !== undefined ? options[key] : defaultValue;
+        if (this._updateTimeout) {
+            clearTimeout(this._updateTimeout);
         }
         
-        this[filterName] = filterObj;
-        return this.updateFilters();
+        this._updateTimeout = setTimeout(() => this.updateFilters(), 0);
+        return this;
     }
 
     setEqualizer(bands) {
-        this.equalizer = bands;
-        return this.updateFilters();
+        this.filters.equalizer = bands || [];
+        return this._scheduleUpdate();
     }
 
     setKaraoke(enabled, options = {}) {
-        return this._setFilter('karaoke', enabled, options, {
-            level: 1.0,
-            monoLevel: 1.0,
-            filterBand: 220.0,
-            filterWidth: 100.0
-        });
+        return this._setFilter('karaoke', enabled, options);
     }
 
     setTimescale(enabled, options = {}) {
-        return this._setFilter('timescale', enabled, options, {
-            speed: 1.0,
-            pitch: 1.0,
-            rate: 1.0
-        });
+        return this._setFilter('timescale', enabled, options);
     }
 
     setTremolo(enabled, options = {}) {
-        return this._setFilter('tremolo', enabled, options, {
-            frequency: 2.0,
-            depth: 0.5
-        });
+        return this._setFilter('tremolo', enabled, options);
     }
 
     setVibrato(enabled, options = {}) {
-        return this._setFilter('vibrato', enabled, options, {
-            frequency: 2.0,
-            depth: 0.5
-        });
+        return this._setFilter('vibrato', enabled, options);
     }
 
     setRotation(enabled, options = {}) {
-        return this._setFilter('rotation', enabled, options, {
-            rotationHz: 0.0
-        });
+        return this._setFilter('rotation', enabled, options);
     }
 
     setDistortion(enabled, options = {}) {
-        return this._setFilter('distortion', enabled, options, {
-            sinOffset: 0.0,
-            sinScale: 1.0,
-            cosOffset: 0.0,
-            cosScale: 1.0,
-            tanOffset: 0.0,
-            tanScale: 1.0,
-            offset: 0.0,
-            scale: 1.0
-        });
+        return this._setFilter('distortion', enabled, options);
     }
 
     setChannelMix(enabled, options = {}) {
-        return this._setFilter('channelMix', enabled, options, {
-            leftToLeft: 1.0,
-            leftToRight: 0.0,
-            rightToLeft: 0.0,
-            rightToRight: 1.0
-        });
+        return this._setFilter('channelMix', enabled, options);
     }
 
     setLowPass(enabled, options = {}) {
-        return this._setFilter('lowPass', enabled, options, {
-            smoothing: 20.0
-        });
+        return this._setFilter('lowPass', enabled, options);
     }
 
     setBassboost(enabled, options = {}) {
         if (!enabled) {
-            this.bassboost = null;
+            this.presets.bassboost = null;
             return this.setEqualizer([]);
         }
         
         const value = options.value || 5;
         if (value < 0 || value > 5) throw new Error("Bassboost value must be between 0 and 5");
         
-        this.bassboost = value;
-        const num = (value - 1) * (1.25 / 9) - 0.25;
+        this.presets.bassboost = value;
+        const gain = (value - 1) * (1.25 / 9) - 0.25;
         
-        const eq = new Array(13);
-        for (let i = 0; i < 13; i++) {
-            eq[i] = { band: i, gain: num };
-        }
+        const eq = Array.from({ length: 13 }, (_, i) => ({ band: i, gain }));
         
         return this.setEqualizer(eq);
     }
 
     setSlowmode(enabled, options = {}) {
-        this.slowmode = enabled;
+        this.presets.slowmode = enabled;
         return this.setTimescale(enabled, { rate: enabled ? (options.rate || 0.8) : 1.0 });
     }
 
     setNightcore(enabled, options = {}) {
-        this.nightcore = enabled;
+        this.presets.nightcore = enabled;
         return this.setTimescale(enabled, { rate: enabled ? (options.rate || 1.5) : 1.0 });
     }
 
     setVaporwave(enabled, options = {}) {
-        this.vaporwave = enabled;
+        this.presets.vaporwave = enabled;
         return this.setTimescale(enabled, { pitch: enabled ? (options.pitch || 0.5) : 1.0 });
     }
 
     set8D(enabled, options = {}) {
-        this._8d = enabled;
+        this.presets._8d = enabled;
         return this.setRotation(enabled, { rotationHz: enabled ? (options.rotationHz || 0.2) : 0.0 });
     }
 
     async clearFilters() {
-        this.volume = 1;
-        this.equalizer = [];
-        this.karaoke = null;
-        this.timescale = null;
-        this.tremolo = null;
-        this.vibrato = null;
-        this.rotation = null;
-        this.distortion = null;
-        this.channelMix = null;
-        this.lowPass = null;
-        this.bassboost = null;
-        this.slowmode = null;
-        this.nightcore = null;
-        this.vaporwave = null;
-        this._8d = null;
+        Object.keys(this.filters).forEach(key => {
+            this.filters[key] = key === 'volume' ? 1 : (key === 'equalizer' ? [] : null);
+        });
+        
+        Object.keys(this.presets).forEach(key => {
+            this.presets[key] = null;
+        });
         
-        this._filterDataTemplate.volume = 1;
-        this._filterDataTemplate.equalizer = [];
+        this._pendingUpdate = false;
+        if (this._updateTimeout) {
+            clearTimeout(this._updateTimeout);
+            this._updateTimeout = null;
+        }
         
         await this.updateFilters();
         return this;
     }
 
     async updateFilters() {
-        const filterData = {
-            ...this._filterDataTemplate,
-            volume: this.volume,
-            equalizer: this.equalizer,
-            karaoke: this.karaoke,
-            timescale: this.timescale,
-            tremolo: this.tremolo,
-            vibrato: this.vibrato,
-            rotation: this.rotation,
-            distortion: this.distortion,
-            channelMix: this.channelMix,
-            lowPass: this.lowPass
-        };
-
-        this._filterDataTemplate = { ...filterData };
-
+        if (!this._pendingUpdate && this._updateTimeout) {
+            clearTimeout(this._updateTimeout);
+            this._updateTimeout = null;
+            return this;
+        }
+        
+        this._pendingUpdate = false;
+        this._updateTimeout = null;
+        
         await this.player.nodes.rest.updatePlayer({
             guildId: this.player.guildId,
-            data: { filters: filterData }
+            data: { filters: { ...this.filters } }
         });
 
         return this;

package/build/structures/Node.js

@@ -6,24 +6,45 @@ class Node {
     static BACKOFF_MULTIPLIER = 1.5;
     static MAX_BACKOFF = 60000;
     static WS_OPEN = WebSocket.OPEN;
+    static WS_CLOSE_NORMAL = 1000;
 
     constructor(aqua, connOptions, options = {}) {
         this.aqua = aqua;
-        this.host = connOptions.host || "localhost";
-        this.name = connOptions.name || this.host;
-        this.port = connOptions.port || 2333;
-        this.password = connOptions.password || "youshallnotpass";
-        this.secure = !!connOptions.secure;
-        this.sessionId = connOptions.sessionId || null;
-        this.regions = connOptions.regions || [];
+        
+        const {
+            host = "localhost",
+            name = host,
+            port = 2333,
+            password = "youshallnotpass",
+            secure = false,
+            sessionId = null,
+            regions = []
+        } = connOptions;
+
+        this.host = host;
+        this.name = name;
+        this.port = port;
+        this.password = password;
+        this.secure = !!secure;
+        this.sessionId = sessionId;
+        this.regions = regions;
         
         this.wsUrl = `ws${this.secure ? "s" : ""}://${this.host}:${this.port}/v4/websocket`;
         this.rest = new Rest(aqua, this);
-        this.resumeTimeout = options.resumeTimeout || 60;
-        this.autoResume = !!options.autoResume;
-        this.reconnectTimeout = options.reconnectTimeout || 2000;
-        this.reconnectTries = options.reconnectTries || 3;
-        this.infiniteReconnects = !!options.infiniteReconnects;
+        
+        const {
+            resumeTimeout = 60,
+            autoResume = false,
+            reconnectTimeout = 2000,
+            reconnectTries = 3,
+            infiniteReconnects = false
+        } = options;
+
+        this.resumeTimeout = resumeTimeout;
+        this.autoResume = autoResume;
+        this.reconnectTimeout = reconnectTimeout;
+        this.reconnectTries = reconnectTries;
+        this.infiniteReconnects = infiniteReconnects;
         
         this.connected = false;
         this.info = null;
@@ -31,6 +52,13 @@ class Node {
         this.reconnectAttempted = 0;
         this.reconnectTimeoutId = null;
         
+        this._boundOnOpen = this._onOpen.bind(this);
+        this._boundOnError = this._onError.bind(this);
+        this._boundOnMessage = this._onMessage.bind(this);
+        this._boundOnClose = this._onClose.bind(this);
+        
+        this._headers = this._constructHeaders();
+        
         this.initializeStats();
     }
 
@@ -50,7 +78,7 @@ class Node {
         const headers = {
             Authorization: this.password,
             "User-Id": this.aqua.clientId,
-            "Client-Name": `Aqua/${this.aqua.version}`
+            "Client-Name": `Aqua/${this.aqua.version} (https://github.com/ToddyTheNoobDud/AquaLink)`
         };
         
         if (this.sessionId) {
@@ -60,24 +88,27 @@ class Node {
         return headers;
     }
 
-    _onOpen() {
+    _updateHeaders() {
+        this._headers = this._constructHeaders();
+    }
+
+    async _onOpen() {
         this.connected = true;
         this.reconnectAttempted = 0;
         this.emitDebug(`Connected to ${this.wsUrl}`);
 
-        this.rest.makeRequest("GET", "/v4/info")
-            .then(info => {
-                this.info = info;
-                if (this.autoResume && this.sessionId) {
-                    return this.resumePlayers();
-                }
-            })
-            .catch(err => {
-                this.info = null;
-                if (!this.aqua.bypassChecks?.nodeFetchInfo) {
-                    this.emitError(`Failed to fetch node info: ${err.message}`);
-                }
-            });
+        if (this.aqua.bypassChecks?.nodeFetchInfo) return;
+
+        try {
+            this.info = await this.rest.makeRequest("GET", "/v4/info");
+            
+            if (this.autoResume && this.sessionId) {
+                await this.resumePlayers();
+            }
+        } catch (err) {
+            this.info = null;
+            this.emitError(`Failed to fetch node info: ${err.message}`);
+        }
     }
     
     _onError(error) {
@@ -107,6 +138,7 @@ class Node {
                     const player = this.aqua.players.get(payload.guildId);
                     if (player) player.emit(op, payload);
                 }
+                break;
         }
     }
     
@@ -124,7 +156,7 @@ class Node {
     scheduleReconnect(code) {
         this.clearReconnectTimeout();
         
-        if (code === 1000) {
+        if (code === Node.WS_CLOSE_NORMAL) {
             return;
         }
         
@@ -166,31 +198,41 @@ class Node {
 
     async connect() {
         this.cleanupExistingConnection();
-        this.ws = new WebSocket(this.wsUrl, { headers: this._constructHeaders(), perMessageDeflate: false });
-        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));
+        
+        if (this.sessionId && !this._headers["Session-Id"]) {
+            this._updateHeaders();
+        }
+        
+        this.ws = new WebSocket(this.wsUrl, { 
+            headers: this._headers, 
+            perMessageDeflate: false
+        });
+        
+        this.ws.once("open", this._boundOnOpen);
+        this.ws.once("error", this._boundOnError);
+        this.ws.on("message", this._boundOnMessage);
+        this.ws.once("close", this._boundOnClose);
     }
 
     cleanupExistingConnection() {
-        if (this.ws) {
-            this.ws.removeAllListeners();
-            
-            if (this.ws.readyState === Node.WS_OPEN) {
-                try {
-                    this.ws.close();
-                } catch (err) {
-                    this.emitDebug(`Error closing WebSocket: ${err.message}`);
-                }
+        if (!this.ws) return;
+        
+        this.ws.removeAllListeners();
+        
+        if (this.ws.readyState === Node.WS_OPEN) {
+            try {
+                this.ws.close();
+            } catch (err) {
+                this.emitDebug(`Error closing WebSocket: ${err.message}`);
             }
-            
-            this.ws = null;
         }
+        
+        this.ws = null;
     }
     
     destroy(clean = false) {
         this.clearReconnectTimeout();
+        
         this.cleanupExistingConnection();
 
         if (clean) {
@@ -216,6 +258,7 @@ class Node {
     async getStats() {
         try {
             const newStats = await this.rest.getStats();
+            
             Object.assign(this.stats, newStats);
             return this.stats;
         } catch (err) {
@@ -227,55 +270,46 @@ class Node {
     _updateStats(payload) {
         if (!payload) return;
 
-        this._updateBasicStats(payload);
-        
-        this._updateMemoryStats(payload.memory);
+        this.stats.players = payload.players;
+        this.stats.playingPlayers = payload.playingPlayers;
+        this.stats.uptime = payload.uptime;
+        this.stats.ping = payload.ping;
         
-        this._updateCpuStats(payload.cpu);
-        
-        this._updateFrameStats(payload.frameStats);
-    }
-    
-    _updateBasicStats(payload) {
-        this.stats.players = payload.players || this.stats.players;
-        this.stats.playingPlayers = payload.playingPlayers || this.stats.playingPlayers;
-        this.stats.uptime = payload.uptime || this.stats.uptime;
-        this.stats.ping = payload.ping || this.stats.ping;
+        this._updateMemoryStats(payload.memory || {});
+        this._updateCpuStats(payload.cpu || {});
+        this._updateFrameStats(payload.frameStats || {});
     }
     
-    _updateMemoryStats(memory = {}) {
-        const allocated = memory.allocated || this.stats.memory.allocated;
-        const free = memory.free || this.stats.memory.free;
-        const used = memory.used || this.stats.memory.used;
+    _updateMemoryStats(memory) {
+        const memoryStats = this.stats.memory;
         
-        this.stats.memory.free = free;
-        this.stats.memory.used = used;
-        this.stats.memory.allocated = allocated;
-        this.stats.memory.reservable = memory.reservable || this.stats.memory.reservable;
+        memoryStats.free = memory.free;
+        memoryStats.used = memory.used;
+        memoryStats.allocated = memory.allocated;
+        memoryStats.reservable = memory.reservable;
         
-        if (allocated) {
-            this.stats.memory.freePercentage = (free / allocated) * 100;
-            this.stats.memory.usedPercentage = (used / allocated) * 100;
-        }
+        memoryStats.freePercentage = (memoryStats.free / memoryStats.allocated) * 100;
+        memoryStats.usedPercentage = (memoryStats.used / memoryStats.allocated) * 100;
     }
     
-    _updateCpuStats(cpu = {}) {
-        const cores = cpu.cores || this.stats.cpu.cores;
+    _updateCpuStats(cpu) {
+        const cpuStats = this.stats.cpu;
         
-        this.stats.cpu.cores = cores;
-        this.stats.cpu.systemLoad = cpu.systemLoad || this.stats.cpu.systemLoad;
-        this.stats.cpu.lavalinkLoad = cpu.lavalinkLoad || this.stats.cpu.lavalinkLoad;
+        cpuStats.cores = cpu.cores;
+        cpuStats.systemLoad = cpu.systemLoad;
+        cpuStats.lavalinkLoad = cpu.lavalinkLoad;
         
-        if (cores) {
-            this.stats.cpu.lavalinkLoadPercentage = (cpu.lavalinkLoad / cores) * 100;
-        }
+        cpuStats.lavalinkLoadPercentage = (cpuStats.lavalinkLoad / cpuStats.cores) * 100;
     }
     
-    _updateFrameStats(frameStats = {}) {
+    _updateFrameStats(frameStats) {
+        const stats = this.stats.frameStats;
+
         if (!frameStats) return;
-        this.stats.frameStats.sent = frameStats.sent || this.stats.frameStats.sent;
-        this.stats.frameStats.nulled = frameStats.nulled || this.stats.frameStats.nulled;
-        this.stats.frameStats.deficit = frameStats.deficit || this.stats.frameStats.deficit;
+        
+        stats.sent = frameStats.sent;
+        stats.nulled = frameStats.nulled;
+        stats.deficit = frameStats.deficit;
     }
 
     _handleReadyOp(payload) {
@@ -286,6 +320,7 @@ class Node {
 
         this.sessionId = payload.sessionId;
         this.rest.setSessionId(payload.sessionId);
+        this._updateHeaders();
         this.aqua.emit("nodeConnect", this);
     }
 

package/build/structures/Player.js

@@ -35,10 +35,10 @@ class Player extends EventEmitter {
         this.filters = new Filters(this);
         this.queue = new Queue();
         
-        this.volume = Math.max(0, Math.min(options.defaultVolume ?? 100, 200));
+        this.volume = Math.min(Math.max(options.defaultVolume ?? 100, 0), 200);
         this.loop = Player.validModes.has(options.loop) ? options.loop : Player.LOOP_MODES.NONE;
-        this.shouldDeleteMessage = Boolean(options.shouldDeleteMessage);
-        this.leaveOnEnd = Boolean(options.leaveOnEnd);
+        this.shouldDeleteMessage = !!this.aqua.options.shouldDeleteMessage;
+        this.leaveOnEnd = !!this.aqua.options.leaveOnEnd;
         
         this.previousTracks = new Array(50);
         this.previousTracksIndex = 0;
@@ -55,6 +55,9 @@ class Player extends EventEmitter {
         this.isAutoplayEnabled = false;
         this.isAutoplay = false;
         
+        this._pendingUpdates = {};
+        this._updateTimeout = null;
+        
         this._boundHandlers = {
             playerUpdate: this._handlePlayerUpdate.bind(this),
             event: this._handleEvent.bind(this)
@@ -63,7 +66,7 @@ class Player extends EventEmitter {
         this.on("playerUpdate", this._boundHandlers.playerUpdate);
         this.on("event", this._boundHandlers.event);
         
-        this._dataStore = null;
+        this._dataStore = new Map();
     }
 
     get previous() {
@@ -75,8 +78,32 @@ class Player extends EventEmitter {
         return this.current;
     }
 
+    batchUpdatePlayer(data, immediate = false) {
+        this._pendingUpdates = { ...this._pendingUpdates, ...data };
+        
+        if (this._updateTimeout) {
+            clearTimeout(this._updateTimeout);
+            this._updateTimeout = null;
+        }
+        
+        if (immediate || data.track) {
+            const updates = this._pendingUpdates;
+            this._pendingUpdates = {};
+            return this.updatePlayer(updates);
+        }
+        
+        this._updateTimeout = setTimeout(() => {
+            const updates = this._pendingUpdates;
+            this._pendingUpdates = {};
+            this.updatePlayer(updates);
+            this._updateTimeout = null;
+        }, 50);
+        
+        return Promise.resolve();
+    }
+
     async autoplay(player) {
-        if (!player) throw new Error("Quick Fix: player.autoplay(player)");
+        if (!player) throw new Error("Player is undefined. const player = aqua.plaerers.get(guildId);");
         if (!this.isAutoplayEnabled) {
             this.aqua.emit("debug", this.guildId, "Autoplay is disabled.");
             return this;
@@ -113,7 +140,8 @@ class Player extends EventEmitter {
             const { query, source } = result;
             const response = await this.aqua.resolve({ query, source, requester });
 
-            if (!response?.tracks?.length || ["error", "empty", "LOAD_FAILED", "NO_MATCHES"].includes(response.loadType)) {
+            const failTypes = new Set(["error", "empty", "LOAD_FAILED", "NO_MATCHES"]);
+            if (!response?.tracks?.length || failTypes.has(response.loadType)) {
                 return this.stop();
             }
 
@@ -145,12 +173,13 @@ class Player extends EventEmitter {
     }
 
     _handlePlayerUpdate({ state }) {
-        if (state) {
-            const { position, timestamp, ping } = state;
-            if (position !== undefined) this.position = position;
-            if (timestamp !== undefined) this.timestamp = timestamp;
-            if (ping !== undefined) this.ping = ping;
-        }
+        if (!state) return;
+        
+        const { position, timestamp, ping } = state;
+        if (position !== undefined) this.position = position;
+        if (timestamp !== undefined) this.timestamp = timestamp;
+        if (ping !== undefined) this.ping = ping;
+        
         this.aqua.emit("playerUpdate", this, { state });
     }
 
@@ -172,7 +201,7 @@ class Player extends EventEmitter {
         this.position = 0;
         
         this.aqua.emit("debug", this.guildId, `Playing track: ${this.current.track}`);
-        return this.updatePlayer({ track: { encoded: this.current.track } });
+        return this.batchUpdatePlayer({ track: { encoded: this.current.track } }, true);
     }
 
     connect({ voiceChannel, deaf = true, mute = false } = {}) {
@@ -192,6 +221,12 @@ class Player extends EventEmitter {
     destroy() {
         if (!this.connected) return this;
         
+        if (this._updateTimeout) {
+            clearTimeout(this._updateTimeout);
+            this._updateTimeout = null;
+            this._pendingUpdates = {};
+        }
+        
         this.disconnect();
         if (this.nowPlayingMessage) {
             this.nowPlayingMessage.delete().catch(() => {});
@@ -220,22 +255,36 @@ class Player extends EventEmitter {
     pause(paused) {
         if (this.paused === paused) return this;
         this.paused = paused;
-        this.updatePlayer({ paused });
+        this.batchUpdatePlayer({ paused });
         return this;
     }
 
+    async getLyrics(options = {}) {
+        const { query = null, useCurrentTrack = true } = options;
+        
+        if (query) {
+            return this.nodes.rest.getLyrics({ track: { info: { title: query }, search: true } }) || null;
+        }
+        
+        if (useCurrentTrack && this.playing) {
+            return this.nodes.rest.getLyrics({ track: { encoded: this.current.track, guild_id: this.guildId } }) || null;
+        }
+        
+        return null;
+    }
+
     async searchLyrics(query) {
-        return query ? this.nodes.rest.getLyrics({ track: { info: { title: query }, search: true } }) || null : null;
+        return this.getLyrics({ query });
     }
 
     async lyrics() {
-        return this.playing ? this.nodes.rest.getLyrics({ track: { encoded: this.current.track, guild_id: this.guildId } }) || null : null;
+        return this.getLyrics({ useCurrentTrack: true });
     }
 
     seek(position) {
         if (!this.playing) return this;
         this.position += position;
-        this.updatePlayer({ position: this.position });
+        this.batchUpdatePlayer({ position: this.position });
         return this;
     }
 
@@ -243,27 +292,27 @@ class Player extends EventEmitter {
         if (!this.playing) return this;
         this.playing = false;
         this.position = 0;
-        this.updatePlayer({ track: { encoded: null } });
+        this.batchUpdatePlayer({ track: { encoded: null } }, true);
         return this;
     }
 
     setVolume(volume) {
         if (volume < 0 || volume > 200) throw new Error("Volume must be between 0 and 200.");
         this.volume = volume;
-        this.updatePlayer({ volume });
+        this.batchUpdatePlayer({ volume });
         return this;
     }
 
     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.batchUpdatePlayer({ loop: mode });
         return this;
     }
 
     setTextChannel(channel) {
         this.textChannel = channel;
-        this.updatePlayer({ text_channel: channel });
+        this.batchUpdatePlayer({ text_channel: channel });
         return this;
     }
 
@@ -294,11 +343,14 @@ class Player extends EventEmitter {
     }
 
     shuffle() {
-        const { queue } = this;
-        for (let i = queue.length - 1; i > 0; i--) {
+        const queue = this.queue;
+        const length = queue.length;
+        
+        for (let i = length - 1; i > 0; i--) {
             const j = Math.floor(Math.random() * (i + 1));
             [queue[i], queue[j]] = [queue[j], queue[i]];
         }
+        
         return this;
     }
 
@@ -327,14 +379,16 @@ class Player extends EventEmitter {
         if (this.shouldDeleteMessage && this.nowPlayingMessage) {
             try {
                 await this.nowPlayingMessage.delete();
-                this.nowPlayingMessage = null;
             } catch (error) {
                 console.error("Error deleting now playing message:", error);
+            } finally {
+                this.nowPlayingMessage = null;
             }
         }
         
         const reason = payload.reason;
-        if (reason === "LOAD_FAILED" || reason === "CLEANUP") {
+        const failureReasons = new Set(["LOAD_FAILED", "CLEANUP"]);
+        if (failureReasons.has(reason)) {
             if (!player.queue.length) {
                 this.clearData();
                 this.aqua.emit("queueEnd", player);
@@ -345,10 +399,13 @@ class Player extends EventEmitter {
             return;
         }
         
-        if (this.loop === Player.LOOP_MODES.TRACK) {
-            player.queue.unshift(track);
-        } else if (this.loop === Player.LOOP_MODES.QUEUE) {
-            player.queue.push(track);
+        switch (this.loop) {
+            case Player.LOOP_MODES.TRACK:
+                player.queue.unshift(track);
+                break;
+            case Player.LOOP_MODES.QUEUE:
+                player.queue.push(track);
+                break;
         }
         
         if (player.queue.isEmpty()) {
@@ -381,7 +438,8 @@ class Player extends EventEmitter {
     async socketClosed(player, payload) {
         const { code, guildId } = payload || {};
         
-        if (code === 4015 || code === 4009) {
+        const reconnectCodes = new Set([4015, 4009]);
+        if (reconnectCodes.has(code)) {
             this.send({
                 guild_id: guildId,
                 channel_id: this.voiceChannel,
@@ -400,17 +458,16 @@ class Player extends EventEmitter {
     }
 
     set(key, value) {
-        if (!this._dataStore) this._dataStore = new Map();
         this._dataStore.set(key, value);
     }
 
     get(key) {
-        return this._dataStore ? this._dataStore.get(key) : undefined;
+        return this._dataStore.get(key);
     }
 
     clearData() {
         if (this.previousTracks) this.previousTracksCount = 0;
-        this._dataStore = null;
+        this._dataStore.clear();
         return this;
     }
 

package/build/structures/Queue.js

@@ -38,23 +38,32 @@ class Queue extends Array {
     remove(track) {
         const index = this.indexOf(track);
         if (index !== -1) {
-            this.splice(index, 1);
+            if (index === this.length - 1) {
+                this.pop();
+            } else {
+                this.splice(index, 1);
+            }
+            return true;
         }
+        return false;
     }
 
     // Clear all tracks from the queue
     clear() {
-        this.length = 0; // More efficient memory handling
+        this.length = 0;
     }
 
     // Shuffle the tracks in the queue
     shuffle() {
-        for (let i = this.length - 1; i > 0; i--) {
+        const length = this.length;
+        for (let i = length - 1; i > 0; i--) {
             const j = Math.floor(Math.random() * (i + 1));
-            [this[i], this[j]] = [this[j], this[i]];
+            if (i !== j) {
+                [this[i], this[j]] = [this[j], this[i]];
+            }
         }
+        return this;
     }
-
     // Peek at the element at the front of the queue without removing it
     peek() {
         return this.first;
@@ -62,7 +71,7 @@ class Queue extends Array {
 
     // Get all tracks in the queue as an array
     toArray() {
-        return [...this]; // Create a shallow copy of the queue
+        return this.slice();
     }
 
     /**
@@ -71,9 +80,8 @@ class Queue extends Array {
      * @returns {*} The track at the specified index or null if out of bounds.
      */
     at(index) {
-        return this[index] || null; // Return null if index is out of bounds
+        return (index >= 0 && index < this.length) ? this[index] : null;
     }
-
     // Remove the first track from the queue
     dequeue() {
         return this.shift(); // Removes and returns the first element

package/build/structures/Rest.js

@@ -1,8 +1,10 @@
 "use strict";
+
 const https = require("https");
 const http = require("http");
 
 let http2;
+
 try {
     http2 = require("http2");
 } catch (e) {
@@ -20,14 +22,20 @@ class Rest {
         };
         this.secure = secure;
         this.timeout = timeout;
-        
-        this.client = secure ? (http2 || https) : http;
+
+        this.client = secure ? http2 || https : http;
     }
 
     setSessionId(sessionId) {
         this.sessionId = sessionId;
     }
 
+    validateSessionId() {
+        if (!this.sessionId) {
+            throw new Error("Session ID is required but not set.");
+        }
+    }
+
     async makeRequest(method, endpoint, body = null) {
         const url = `${this.baseUrl}${endpoint}`;
         const options = {
@@ -38,36 +46,36 @@ class Rest {
 
         return new Promise((resolve, reject) => {
             const req = this.client.request(url, options, (res) => {
-                res.setEncoding('utf8');
-                
-                let data = '';
-                
+                let data = "";
+
+                res.setEncoding("utf8");
+
                 res.on("data", (chunk) => {
                     data += chunk;
                 });
-                
+
                 res.on("end", () => {
-                    if (res.statusCode >= 200 && res.statusCode < 300) {
+                    if (res.statusCode && res.statusCode >= 200 && res.statusCode < 300) {
                         if (!data) {
                             resolve(null);
                             return;
                         }
-                        
                         try {
                             resolve(JSON.parse(data));
-                        } catch (error) {
-                            reject(new Error(`Failed to parse response: ${error.message}`));
+                        } catch (err) {
+                            reject(new Error(`Failed to parse response: ${err.message}`));
                         }
                     } else {
-                        reject(new Error(`Request failed with status ${res.statusCode}: ${res.statusMessage || 'Unknown error'}`));
+                        const errorMessage = `Request failed with status ${res.statusCode}: ${res.statusMessage || "Unknown error"}`;
+                        reject(new Error(errorMessage));
                     }
                 });
             });
 
-            req.on("error", (error) => reject(new Error(`Request failed (${method} ${url}): ${error.message}`)));
+            req.on("error", (err) => reject(new Error(`Request failed (${method} ${url}): ${err.message}`)));
             req.on("timeout", () => {
                 req.destroy();
-                reject(new Error(`Request timeout after ${this.timeout}ms (${method} ${url})`));
+                reject(new Error(`Request timed out after ${this.timeout}ms (${method} ${url})`));
             });
 
             if (body) {
@@ -77,79 +85,86 @@ class Rest {
         });
     }
 
-    validateSessionId() {
-        if (!this.sessionId) throw new Error("Session ID is required but not set.");
-    }
-
     async updatePlayer({ guildId, data }) {
-        if (data.track && data.track.encoded && data.track.identifier) {
-            throw new Error("Cannot provide both 'encoded' and 'identifier' for track");
+        if (data.track?.encoded && data.track?.identifier) {
+            throw new Error("You cannot provide both 'encoded' and 'identifier' for a track.");
         }
-        
+
         this.validateSessionId();
-        return this.makeRequest(
-            "PATCH", 
-            `/${this.version}/sessions/${this.sessionId}/players/${guildId}?noReplace=false`, 
-            data
-        );
+
+        const endpoint = `/${this.version}/sessions/${this.sessionId}/players/${guildId}?noReplace=false`;
+        return this.makeRequest("PATCH", endpoint, data);
     }
 
     async getPlayers() {
         this.validateSessionId();
-        return this.makeRequest("GET", `/${this.version}/sessions/${this.sessionId}/players`);
+        const endpoint = `/${this.version}/sessions/${this.sessionId}/players`;
+        return this.makeRequest("GET", endpoint);
     }
 
     async destroyPlayer(guildId) {
         this.validateSessionId();
-        return this.makeRequest("DELETE", `/${this.version}/sessions/${this.sessionId}/players/${guildId}`);
+        const endpoint = `/${this.version}/sessions/${this.sessionId}/players/${guildId}`;
+        return this.makeRequest("DELETE", endpoint);
     }
 
     async getTracks(identifier) {
-        return this.makeRequest("GET", `/${this.version}/loadtracks?identifier=${encodeURIComponent(identifier)}`);
+        const endpoint = `/${this.version}/loadtracks?identifier=${encodeURIComponent(identifier)}`;
+        return this.makeRequest("GET", endpoint);
     }
 
     async decodeTrack(track) {
-        return this.makeRequest("GET", `/${this.version}/decodetrack?encodedTrack=${encodeURIComponent(track)}`);
+        const endpoint = `/${this.version}/decodetrack?encodedTrack=${encodeURIComponent(track)}`;
+        return this.makeRequest("GET", endpoint);
     }
 
     async decodeTracks(tracks) {
-        return this.makeRequest("POST", `/${this.version}/decodetracks`, tracks);
+        const endpoint = `/${this.version}/decodetracks`;
+        return this.makeRequest("POST", endpoint, tracks);
     }
 
     async getStats() {
-        return this.makeRequest("GET", `/${this.version}/stats`);
+        const endpoint = `/${this.version}/stats`;
+        return this.makeRequest("GET", endpoint);
     }
 
     async getInfo() {
-        return this.makeRequest("GET", `/${this.version}/info`);
+        const endpoint = `/${this.version}/info`;
+        return this.makeRequest("GET", endpoint);
     }
 
     async getRoutePlannerStatus() {
-        return this.makeRequest("GET", `/${this.version}/routeplanner/status`);
+        const endpoint = `/${this.version}/routeplanner/status`;
+        return this.makeRequest("GET", endpoint);
     }
 
     async getRoutePlannerAddress(address) {
-        return this.makeRequest("POST", `/${this.version}/routeplanner/free/address`, { address });
+        const endpoint = `/${this.version}/routeplanner/free/address`;
+        return this.makeRequest("POST", endpoint, { address });
     }
 
     async getLyrics({ track }) {
         if (!track) return null;
-        
+
         try {
             if (track.search) {
                 const query = encodeURIComponent(track.info.title);
                 try {
-                    const res = await this.makeRequest("GET", `/${this.version}/lyrics/search?query=${query}&source=genius`);
+                    const res = await this.makeRequest(
+                        "GET", 
+                        `/${this.version}/lyrics/search?query=${query}&source=genius`
+                    );
                     if (res) return res;
-                } catch (err) {}
+                } catch (_) {
+                    // Silently handle any errors.
+                }
             } else {
                 this.validateSessionId();
                 return await this.makeRequest(
-                    "GET", 
+                    "GET",
                     `/${this.version}/sessions/${this.sessionId}/players/${track.guild_id}/track/lyrics?skipTrackSource=false`
                 );
             }
-         
         } catch (error) {
             console.error("Failed to fetch lyrics:", error.message);
             return null;

package/build/structures/Track.js

@@ -10,7 +10,8 @@ class Track {
     this.identifier = info.identifier || '';
     this.isSeekable = Boolean(info.isSeekable);
     this.author = info.author || '';
-    this.length = info.length | 0;
+    this.length = info.length || 0;
+    this.duration = info.length || 0;
     this.isStream = Boolean(info.isStream);
     this.title = info.title || '';
     this.uri = info.uri || '';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aqualink",
-  "version": "2.4.0",
+  "version": "2.6.0",
   "description": "An Lavalink client, focused in pure performance and features",
   "main": "build/index.js",
   "types": "index.d.ts",