aqualink 2.17.0 → 2.17.2

package/README.md

@@ -180,16 +180,18 @@ const aqua = new Aqua(client, nodes, {
 
 client.aqua = aqua;
 
-client.once(Events.Ready, () => {
+client.once(Events.ClientReady, () => {
     client.aqua.init(client.user.id);
     console.log(`Logged in as ${client.user.tag}`);
 });
 
-client.on(Events.Raw, (d) => {
-    if (![Events.VoiceStateUpdate, Events.VoiceServerUpdate].includes(d.t)) return;
-    client.aqua.updateVoiceState(d);
+client.on(Events.Raw, (d, t) => {
+    if (d.t === "VOICE_SERVER_UPDATE" || d.t === "VOICE_STATE_UPDATE") {
+        return client.aqua.updateVoiceState(d, t);
+    }
 });
 
+
 client.on(Events.MessageCreate, async (message) => {
     if (message.author.bot || !message.content.startsWith("!play")) return;
 
@@ -446,4 +448,4 @@ Join our thriving community of developers and bot creators!
 
 <sub>Built with 💙 by the Aqualink Team</sub>
 
-</div>
+</div>

package/build/index.d.ts

@@ -38,8 +38,7 @@ declare module "aqualink" {
         _rebuildLocks: Set<string>;
         _leastUsedNodesCache: Node[] | null;
         _leastUsedNodesCacheTime: number;
-        _nodeLoadCache: Map<string, number>;
-        _nodeLoadCacheTime: Map<string, number>;
+        _nodeLoadCache: Map<string, {load: number; time: number}>;
         _cleanupTimer: NodeJS.Timer | null;
         _onNodeConnect?: (node: Node) => void;
         _onNodeDisconnect?: (node: Node) => void;
@@ -126,6 +125,7 @@ declare module "aqualink" {
         infiniteReconnects: boolean;
         connected: boolean;
         info: NodeInfo | null;
+        isNodelink: boolean;
         ws: any | null; // WebSocket
         reconnectAttempted: number;
         reconnectTimeoutId: NodeJS.Timeout | null;
@@ -198,6 +198,8 @@ declare module "aqualink" {
         mute: boolean;
         autoplayRetries: number;
         reconnectionRetries: number;
+        _resuming: boolean;
+        _reconnecting: boolean;
         previousIdentifiers: Set<string>;
         self_deaf: boolean;
         self_mute: boolean;
@@ -242,6 +244,11 @@ declare module "aqualink" {
         setAutoplay(enabled: boolean): Player;
         updatePlayer(data: any): Promise<any>;
         cleanup(): Promise<void>;
+        getActiveMixer(guildId: string): Promise<any[]>;
+        updateMixerVolume(guildId: string, mix: string, volume: number): Promise<any>;
+        removeMixer(guildId: string, mix: string): Promise<any>;
+        addMixer(guildId: string, options: MixerOptions): Promise<any>;
+        getLoadLyrics(encodedTrack: string): Promise<LyricsResponse | null>;
 
         // Data Methods
         set(key: string, value: any): void;
@@ -276,7 +283,7 @@ declare module "aqualink" {
     }
 
     export class Track {
-        constructor(data?: TrackData, requester?: any, nodes?: Node);
+        constructor(data?: TrackData, requester?: any, node?: Node);
 
         // Properties
         identifier: string;
@@ -326,6 +333,7 @@ declare module "aqualink" {
         baseUrl: string;
         defaultHeaders: Record<string, string>;
         agent: any; // HTTP/HTTPS Agent
+        useHttp2: boolean;
 
         // Core Methods
         setSessionId(sessionId: string): void;
@@ -347,6 +355,11 @@ declare module "aqualink" {
         getRoutePlannerStatus(): Promise<any>;
         freeRoutePlannerAddress(address: string): Promise<any>;
         freeAllRoutePlannerAddresses(): Promise<any>;
+        addMixer(guildId: string, options: MixerOptions): Promise<any>;
+        getActiveMixer(guildId: string): Promise<any[]>;
+        updateMixerVolume(guildId: string, mix: string, volume: number): Promise<any>;
+        removeMixer(guildId: string, mix: string): Promise<any>;
+        getLoadLyrics(encodedTrack: string): Promise<LyricsResponse>;
         destroy(): void;
     }
 
@@ -452,7 +465,7 @@ declare module "aqualink" {
         updateSequence(seq: number): void;
         destroy(): void;
         attemptResume(): Promise<boolean>;
-        resendVoiceUpdate(options?: { resume?: boolean }): void;
+        resendVoiceUpdate(): boolean;
 
         // Internal Methods
         _extractRegion(endpoint: string): string | null;
@@ -736,6 +749,13 @@ declare module "aqualink" {
         smoothing?: number;
     }
 
+    export interface MixerOptions {
+        identifier?: string;
+        encoded?: string;
+        userData?: any;
+        volume?: number;
+    }
+
     // Voice Update Interfaces
     export interface VoiceStateUpdate {
         d: {

package/build/structures/Aqua.js

@@ -529,7 +529,7 @@ class Aqua extends EventEmitter {
   _handlePlayerDestroy(player) {
     player.nodes?.players?.delete?.(player)
     if (this.players.get(player.guildId) === player) this.players.delete(player.guildId)
-    this.emit(AqualinkEvents.PlayerDestroy, player)
+    this.emit(AqualinkEvents.PlayerDestroyed, player)
   }
 
   async destroyPlayer(guildId) {

package/build/structures/AqualinkEvents.js

@@ -29,16 +29,17 @@ const AqualinkEvents = {
   Debug: 'debug',
   Error: 'error',
   PlayerCreate: 'playerCreate',
-  PlayerDestroy: 'playerDestroy',
   PlayersRebuilt: 'playersRebuilt',
   VolumeChanged: 'volumeChanged',
   FiltersChanged: 'filtersChanged',
   Seek: 'seek',
   PlayerCreated: 'playerCreated',
   PlayerConnected: 'playerConnected',
-  PlayerDestroyed: 'playerDestroyed',
+  PlayerDestroyed: 'playerDestroy',
   PlayerMigrated: 'playerMigrated',
-  PauseEvent: 'pauseEvent'
+  PauseEvent: 'pauseEvent',
+  MixStarted: 'mixStarted',
+  MixEnded: 'mixEnded'
 };
 
-module.exports = { AqualinkEvents };
+module.exports = { AqualinkEvents };

package/build/structures/Connection.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const {AqualinkEvents} = require('./AqualinkEvents')
+const { AqualinkEvents } = require('./AqualinkEvents')
 
 const POOL_SIZE = 12
 const UPDATE_TIMEOUT = 4000
@@ -17,15 +17,46 @@ const STATE = {
   VOICE_DATA_STALE: 512
 }
 
-const ENDPOINT_REGION_REGEX = /^([a-z-]+)\d*/i
-
 const _functions = {
-  safeUnref: t => t?.unref?.(),
+  safeUnref: t => (typeof t?.unref === 'function' ? t.unref() : undefined),
   isValidNumber: n => typeof n === 'number' && n >= 0 && Number.isFinite(n),
-  isNetworkError: e => e && (e.code === 'ECONNREFUSED' || e.code === 'ENOTFOUND' || e.code === 'ETIMEDOUT'),
+  isNetworkError: e => !!e && (e.code === 'ECONNREFUSED' || e.code === 'ENOTFOUND' || e.code === 'ETIMEDOUT'),
   extractRegion: endpoint => {
-    const m = ENDPOINT_REGION_REGEX.exec(endpoint)
-    return m ? m[1] : 'unknown'
+    if (typeof endpoint !== 'string') return 'unknown'
+    endpoint = endpoint.trim()
+    if (!endpoint) return 'unknown'
+
+    const proto = endpoint.indexOf('://')
+    if (proto !== -1) endpoint = endpoint.slice(proto + 3)
+
+    const slash = endpoint.indexOf('/')
+    if (slash !== -1) endpoint = endpoint.slice(0, slash)
+
+    const colon = endpoint.indexOf(':')
+    if (colon !== -1) endpoint = endpoint.slice(0, colon)
+
+    const dot = endpoint.indexOf('.')
+    const label = (dot === -1 ? endpoint : endpoint.slice(0, dot)).toLowerCase()
+    if (!label) return 'unknown'
+
+    let i = label.length - 1
+    while (i >= 0) {
+      const c = label.charCodeAt(i)
+      if (c >= 48 && c <= 57) i--
+      else break
+    }
+    return label.slice(0, i + 1) || 'unknown'
+  },
+  fillVoicePayload: (payload, guildId, conn, player, resume) => {
+    payload.guildId = guildId
+    const v = payload.data.voice
+    v.token = conn.token
+    v.endpoint = conn.endpoint
+    v.sessionId = conn.sessionId
+    v.resume = resume ? true : undefined
+    v.sequence = resume ? conn.sequence : undefined
+    payload.data.volume = player?.volume ?? 100
+    return payload
   }
 }
 
@@ -39,7 +70,7 @@ class PayloadPool {
     return {
       guildId: null,
       data: {
-        voice: {token: null, endpoint: null, sessionId: null, resume: undefined, sequence: undefined},
+        voice: { token: null, endpoint: null, sessionId: null, resume: undefined, sequence: undefined },
         volume: null
       }
     }
@@ -69,21 +100,21 @@ const sharedPool = new PayloadPool()
 
 class Connection {
   constructor(player) {
-    if (!player?.aqua?.clientId || !player.nodes?.rest) {
-      throw new TypeError('Invalid player configuration')
-    }
+    if (!player?.aqua?.clientId || !player.nodes?.rest) throw new TypeError('Invalid player configuration')
 
     this._player = player
     this._aqua = player.aqua
     this._rest = player.nodes.rest
     this._guildId = player.guildId
     this._clientId = player.aqua.clientId
+
     this.voiceChannel = player.voiceChannel
     this.sessionId = null
     this.endpoint = null
     this.token = null
     this.region = null
     this.sequence = 0
+
     this._lastEndpoint = null
     this._pendingUpdate = null
     this._stateFlags = 0
@@ -109,21 +140,29 @@ class Connection {
     return this._hasValidVoiceData() || !!this._player?._resuming
   }
 
+  _setReconnectTimer(delay) {
+    if (this._destroyed) return
+    this._clearReconnectTimer()
+    this._reconnectTimer = setTimeout(() => this._handleReconnect(), delay)
+    _functions.safeUnref(this._reconnectTimer)
+  }
+
   setServerUpdate(data) {
     if (this._destroyed || !data?.endpoint || !data.token) return
-    const endpoint = typeof data.endpoint === 'string' && data.endpoint.trim()
+
+    const endpoint = typeof data.endpoint === 'string' ? data.endpoint.trim() : ''
     if (!endpoint || typeof data.token !== 'string' || !data.token) return
     if (this._lastEndpoint === endpoint && this.token === data.token) return
 
-    const newRegion = _functions.extractRegion(endpoint)
     if (this._lastEndpoint !== endpoint) {
       this.sequence = 0
       this._lastEndpoint = endpoint
       this._reconnectAttempts = 0
       this._consecutiveFailures = 0
     }
+
     this.endpoint = endpoint
-    this.region = newRegion
+    this.region = _functions.extractRegion(endpoint)
     this.token = data.token
     this._lastVoiceDataUpdate = Date.now()
     this._stateFlags &= ~STATE.VOICE_DATA_STALE
@@ -141,37 +180,35 @@ class Connection {
   setStateUpdate(data) {
     if (this._destroyed || !data || data.user_id !== this._clientId) return
 
-    const {session_id: sessionId, channel_id: channelId, self_deaf: selfDeaf, self_mute: selfMute} = data
+    const { session_id: sessionId, channel_id: channelId, self_deaf: selfDeaf, self_mute: selfMute } = data
 
-    if (channelId) {
-      let needsUpdate = false
+    if (!channelId) return this._handleDisconnect()
 
-      if (this.voiceChannel !== channelId) {
-        this._aqua.emit(AqualinkEvents.PlayerMove, this.voiceChannel, channelId)
-        this.voiceChannel = channelId
-        this._player.voiceChannel = channelId
-        needsUpdate = true
-      }
+    let needsUpdate = false
 
-      if (this.sessionId !== sessionId) {
-        this.sessionId = sessionId
-        this._lastVoiceDataUpdate = Date.now()
-        this._stateFlags &= ~STATE.VOICE_DATA_STALE
-        this._reconnectAttempts = 0
-        this._consecutiveFailures = 0
-        needsUpdate = true
-      }
-
-      this._player.connection.sessionId = sessionId || this._player.connection.sessionId
-      this._player.self_deaf = this._player.selfDeaf = !!selfDeaf
-      this._player.self_mute = this._player.selfMute = !!selfMute
-      this._player.connected = true
-      this._stateFlags |= STATE.CONNECTED
+    if (this.voiceChannel !== channelId) {
+      this._aqua.emit(AqualinkEvents.PlayerMove, this.voiceChannel, channelId)
+      this.voiceChannel = channelId
+      this._player.voiceChannel = channelId
+      needsUpdate = true
+    }
 
-      if (needsUpdate) this._scheduleVoiceUpdate()
-    } else {
-      this._handleDisconnect()
+    if (this.sessionId !== sessionId) {
+      this.sessionId = sessionId
+      this._lastVoiceDataUpdate = Date.now()
+      this._stateFlags &= ~STATE.VOICE_DATA_STALE
+      this._reconnectAttempts = 0
+      this._consecutiveFailures = 0
+      needsUpdate = true
     }
+
+    this._player.connection.sessionId = sessionId || this._player.connection.sessionId
+    this._player.self_deaf = this._player.selfDeaf = !!selfDeaf
+    this._player.self_mute = this._player.selfMute = !!selfMute
+    this._player.connected = true
+    this._stateFlags |= STATE.CONNECTED
+
+    if (needsUpdate) this._scheduleVoiceUpdate()
   }
 
   _handleDisconnect() {
@@ -183,7 +220,8 @@ class Connection {
     this._clearReconnectTimer()
 
     this.voiceChannel = this.sessionId = null
-    this.sequence = this._lastVoiceDataUpdate = 0
+    this.sequence = 0
+    this._lastVoiceDataUpdate = 0
     this._stateFlags |= STATE.VOICE_DATA_STALE
 
     try {
@@ -197,19 +235,18 @@ class Connection {
 
   _requestVoiceState() {
     try {
-      if (typeof this._player?.send === 'function' && this._player.voiceChannel) {
-        this._player.send({
-          guild_id: this._guildId,
-          channel_id: this._player.voiceChannel,
-          self_deaf: this._player.deaf,
-          self_mute: this._player.mute
-        })
-        this._reconnectTimer = setTimeout(() => this._handleReconnect(), 1500)
-        _functions.safeUnref(this._reconnectTimer)
-        return true
-      }
-    } catch {}
-    return false
+      if (typeof this._player?.send !== 'function' || !this._player.voiceChannel) return false
+      this._player.send({
+        guild_id: this._guildId,
+        channel_id: this._player.voiceChannel,
+        self_deaf: this._player.deaf,
+        self_mute: this._player.mute
+      })
+      this._setReconnectTimer(1500)
+      return true
+    } catch {
+      return false
+    }
   }
 
   async attemptResume() {
@@ -240,21 +277,18 @@ class Connection {
 
     this._stateFlags |= STATE.ATTEMPTING_RESUME
     this._reconnectAttempts++
-    this._aqua.emit(AqualinkEvents.Debug, `Attempt resume: guild=${this._guildId} endpoint=${this.endpoint} session=${this.sessionId}`)
+    this._aqua.emit(
+      AqualinkEvents.Debug,
+      `Attempt resume: guild=${this._guildId} endpoint=${this.endpoint} session=${this.sessionId}`
+    )
 
     const payload = sharedPool.acquire()
     try {
-      payload.guildId = this._guildId
-      const v = payload.data.voice
-      v.token = this.token
-      v.endpoint = this.endpoint
-      v.sessionId = this.sessionId
-      v.resume = true
-      v.sequence = this.sequence
-      payload.data.volume = this._player?.volume ?? 100
-
+      _functions.fillVoicePayload(payload, this._guildId, this, this._player, true)
       await this._sendUpdate(payload)
-      this._reconnectAttempts = this._consecutiveFailures = 0
+
+      this._reconnectAttempts = 0
+      this._consecutiveFailures = 0
       if (this._player) this._player._resuming = false
       this._aqua.emit(AqualinkEvents.Debug, `Resume successful for guild ${this._guildId}`)
       return true
@@ -264,8 +298,7 @@ class Connection {
 
       if (this._reconnectAttempts < MAX_RECONNECT_ATTEMPTS && !this._destroyed && this._consecutiveFailures < 5) {
         const delay = Math.min(RECONNECT_DELAY * (1 << (this._reconnectAttempts - 1)), RESUME_BACKOFF_MAX)
-        this._reconnectTimer = setTimeout(() => this._handleReconnect(), delay)
-        _functions.safeUnref(this._reconnectTimer)
+        this._setReconnectTimer(delay)
       } else {
         this._aqua.emit(AqualinkEvents.Debug, `Max reconnect attempts or failures reached for guild ${this._guildId}`)
         if (this._player) this._player._resuming = false
@@ -288,10 +321,9 @@ class Connection {
   }
 
   _clearReconnectTimer() {
-    if (this._reconnectTimer) {
-      clearTimeout(this._reconnectTimer)
-      this._reconnectTimer = null
-    }
+    if (!this._reconnectTimer) return
+    clearTimeout(this._reconnectTimer)
+    this._reconnectTimer = null
   }
 
   _clearPendingUpdate() {
@@ -304,16 +336,11 @@ class Connection {
     if (this._destroyed || !this._hasValidVoiceData() || (this._stateFlags & STATE.UPDATE_SCHEDULED)) return
 
     this._clearPendingUpdate()
+
     const payload = sharedPool.acquire()
-    payload.guildId = this._guildId
-    const v = payload.data.voice
-    v.token = this.token
-    v.endpoint = this.endpoint
-    v.sessionId = this.sessionId
-    v.resume = v.sequence = undefined
-    payload.data.volume = this._player.volume
+    _functions.fillVoicePayload(payload, this._guildId, this, this._player, false)
 
-    this._pendingUpdate = {payload, timestamp: Date.now()}
+    this._pendingUpdate = { payload, timestamp: Date.now() }
     this._stateFlags |= STATE.UPDATE_SCHEDULED
     queueMicrotask(() => this._executeVoiceUpdate())
   }
@@ -358,7 +385,11 @@ class Connection {
 
     this._player = this._aqua = this._rest = null
     this.voiceChannel = this.sessionId = this.endpoint = this.token = this.region = this._lastEndpoint = null
-    this._stateFlags = this.sequence = this._reconnectAttempts = this._consecutiveFailures = this._lastVoiceDataUpdate = 0
+    this._stateFlags = 0
+    this.sequence = 0
+    this._reconnectAttempts = 0
+    this._consecutiveFailures = 0
+    this._lastVoiceDataUpdate = 0
   }
 }
 

package/build/structures/Player.js

@@ -22,10 +22,12 @@ const EVENT_HANDLERS = Object.freeze({
   FiltersChangedEvent: 'filtersChanged',
   SeekEvent: 'seekEvent',
   PlayerCreatedEvent: 'playerCreated',
-  pauseEvent: 'PauseEvent',
+  PauseEvent: 'pauseEvent',
   PlayerConnectedEvent: 'playerConnected',
   PlayerDestroyedEvent: 'playerDestroyed',
-  LyricsNotFoundEvent: 'lyricsNotFound'
+  LyricsNotFoundEvent: 'lyricsNotFound',
+  MixStartedEvent: 'mixStarted',
+  MixEndedEvent: 'mixEnded'
 })
 
 const WATCHDOG_INTERVAL = 15000
@@ -285,11 +287,37 @@ class Player extends EventEmitter {
     return this
   }
 
+  async _waitForConnection(timeout = RESUME_TIMEOUT) {
+    if (this.destroyed) return
+    if (this.connected) return
+    return new Promise((resolve, reject) => {
+      let timer
+      const cleanup = () => {
+        if (timer) { this._pendingTimers?.delete(timer); clearTimeout(timer) }
+        this.off('playerUpdate', onUpdate)
+      }
+      const onUpdate = payload => {
+        if (this.destroyed) { cleanup(); return reject(new Error('Player destroyed')) }
+        if (payload?.state?.connected || _functions.isNum(payload?.state?.time)) {
+          cleanup()
+          return resolve()
+        }
+      }
+      this.on('playerUpdate', onUpdate)
+      timer = this._createTimer(() => { cleanup(); reject(new Error('No connection confirmation')) }, timeout)
+    })
+  }
+
   async play() {
     if (this.destroyed || !this.queue.size) return this
-    // most lazy fix i ever did lol
-    if (this.nodes.isNodelink && !this.connected) { await this._delay(1000); if (!this.connected || this.destroyed) return this }
-    if (!this.connected) return this
+    if (!this.connected) {
+      try {
+        await this._waitForConnection(RESUME_TIMEOUT)
+        if (!this.connected || this.destroyed) return this
+      } catch {
+        return this
+      }
+    }
 
     const item = this.queue.dequeue()
     if (!item) return this
@@ -313,7 +341,6 @@ class Player extends EventEmitter {
     if (!voiceChannel) throw new TypeError('Voice channel required')
     this.deaf = options.deaf !== undefined ? !!options.deaf : true
     this.mute = !!options.mute
-    this.connected = true
     this.destroyed = false
     this.voiceChannel = voiceChannel
     this.send({ guild_id: this.guildId, channel_id: voiceChannel, self_deaf: this.deaf, self_mute: this.mute })
@@ -435,11 +462,54 @@ class Player extends EventEmitter {
     return this
   }
 
+  async getActiveMixer(guildId) {
+    if (this.destroyed) return null
+    return await this.nodes.rest.getActiveMixer(guildId)
+  }
+
+  async updateMixerVolume(guildId, mix, volume) {
+    if (this.destroyed) return null
+    return await this.nodes.rest.updateMixerVolume(guildId, mix, volume)
+  }
+
+  async removeMixer(guildId, mix) {
+    if (this.destroyed) return null
+    return await this.nodes.rest.removeMixer(guildId, mix)
+  }
+
+  async addMixer(guildId, options) {
+    if (this.destroyed) return null
+
+    if (options.identifier && !options.encoded) {
+      try {
+        const resolved = await this.aqua.resolve({
+          query: options.identifier,
+          requester: options.requester || this.current?.requester
+        })
+
+        if (resolved?.tracks?.[0]) {
+          const track = resolved.tracks[0]
+          options = {
+            ...options,
+            encoded: track.track || track.encoded,
+            userData: options.userData
+          }
+        } else {
+          throw new Error('Failed to resolve track identifier')
+        }
+      } catch (error) {
+        throw new Error(`Failed to resolve track: ${error.message}`)
+      }
+    }
+
+    return await this.nodes.rest.addMixer(guildId, options)
+  }
+
   stop() {
     if (this.destroyed || !this.playing) return this
     this.playing = this.paused = false
     this.position = 0
-    this.batchUpdatePlayer({ guildId: this.guildId, track: { encoded: null } }, true).catch(() => { })
+    this.batchUpdatePlayer({ guildId: this.guildId, track: { encoded: null, paused: this.paused } }, true).catch(() => { })
     return this
   }
 
@@ -659,7 +729,9 @@ class Player extends EventEmitter {
   playerCreated(p, t, payload) { _functions.emitIfActive(this, AqualinkEvents.PlayerCreated, payload) }
   playerConnected(p, t, payload) { _functions.emitIfActive(this, AqualinkEvents.PlayerConnected, payload) }
   playerDestroyed(p, t, payload) { _functions.emitIfActive(this, AqualinkEvents.PlayerDestroyed, payload) }
-  PauseEvent(p, t, payload) { _functions.emitIfActive(this, AqualinkEvents.PauseEvent, payload) }
+  pauseEvent(p, t, payload) { _functions.emitIfActive(this, AqualinkEvents.PauseEvent, payload) }
+  mixStarted(p, t, payload) { _functions.emitIfActive(this, AqualinkEvents.MixStarted, t, payload) }
+  mixEnded(p, t, payload) { _functions.emitIfActive(this, AqualinkEvents.MixEnded, t, payload) }
 
   async _attemptVoiceResume() {
     if (!this.connection?.sessionId) throw new Error('No session')
@@ -820,4 +892,4 @@ class Player extends EventEmitter {
   }
 }
 
-module.exports = Player
+module.exports = Player

package/build/structures/Rest.js

@@ -317,7 +317,7 @@ class Rest {
 
   _closeH2() {
     if (this._h2Timer) { clearTimeout(this._h2Timer); this._h2Timer = null }
-    if (this._h2) { try { this._h2.close() } catch {} this._h2 = null }
+    if (this._h2) { try { this._h2.close() } catch { } this._h2 = null }
   }
 
   _h2Request(method, path, headers, payload) {
@@ -480,14 +480,14 @@ class Rest {
       try {
         const lyrics = await this.makeRequest('GET', `${this._getSessionPath()}/players/${guildId}/track/lyrics?skipTrackSource=${skip}`)
         if (this._validLyrics(lyrics)) return lyrics
-      } catch {}
+      } catch { }
     }
 
     if (hasEncoded) {
       try {
         const lyrics = await this.makeRequest('GET', `${this._endpoints.lyrics}?track=${encodeURIComponent(encoded)}&skipTrackSource=${skip}`)
         if (this._validLyrics(lyrics)) return lyrics
-      } catch {}
+      } catch { }
     }
 
     if (title) {
@@ -495,7 +495,7 @@ class Rest {
       try {
         const lyrics = await this.makeRequest('GET', `${this._endpoints.lyrics}/search?query=${encodeURIComponent(query)}`)
         if (this._validLyrics(lyrics)) return lyrics
-      } catch {}
+      } catch { }
     }
 
     return null
@@ -524,6 +524,44 @@ class Rest {
     }
   }
 
+  async addMixer(guildId, options) {
+    if (!this.node.isNodelink) throw new Error('Mixer endpoints are only available on Nodelink nodes')
+    if (!options?.encoded && !options?.identifier) throw new Error('You must provide either encoded or identifier')
+
+    const track = {}
+    if (options.encoded) track.encoded = options.encoded
+    if (options.identifier) track.identifier = options.identifier
+    if (options.userData) track.userData = options.userData
+
+    const payload = {
+      track,
+      volume: options.volume !== undefined ? options.volume : 0.8
+    }
+
+    return await this.makeRequest("POST", `/v4/sessions/${this.sessionId}/players/${guildId}/mix`, payload)
+  }
+
+  async getActiveMixer(guildId) {
+    if (!this.node.isNodelink) throw new Error('Mixer endpoints are only available on Nodelink nodes')
+    const response = await this.makeRequest("GET", `/v4/sessions/${this.sessionId}/players/${guildId}/mix`)
+    return response?.mixes || []
+  }
+
+  async updateMixerVolume(guildId, mix, volume) {
+    if (!this.node.isNodelink) throw new Error('Mixer endpoints are only available on Nodelink nodes')
+    if (!guildId || !mix || typeof volume !== 'number') throw new Error('You forget to set the guild_id, mix or volume options')
+
+    return await this.makeRequest("PATCH", `/v4/sessions/${this.sessionId}/players/${guildId}/mix/${mix}`, { volume })
+  }
+
+  async removeMixer(guildId, mix) {
+    if (!this.node.isNodelink) throw new Error('Mixer endpoints are only available on Nodelink nodes')
+    if (!guildId || !mix) throw new Error('You forget to set the guild_id and/or mix options')
+
+    return await this.makeRequest("DELETE", `/v4/sessions/${this.sessionId}/players/${guildId}/mix/${mix}`)
+  }
+
+
   destroy() {
     if (this.agent) { this.agent.destroy(); this.agent = null }
     this._closeH2()
@@ -532,4 +570,4 @@ class Rest {
   }
 }
 
-module.exports = Rest
+module.exports = Rest

package/package.json

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