aqualink 2.9.0 → 2.9.2

package/build/structures/Aqua.js

@@ -8,8 +8,8 @@ const Player = require('./Player')
 const Track = require('./Track')
 const { version: pkgVersion } = require('../../package.json')
 
-const URL_REGEX = /^https?:\/\//
-const GUILD_ID_REGEX = /^\d+$/
+const URL_PATTERN = /^https?:\/\//
+const SEARCH_PREFIX = ':'
 
 const DEFAULT_OPTIONS = Object.freeze({
   shouldDeleteMessage: false,
@@ -19,7 +19,7 @@ const DEFAULT_OPTIONS = Object.freeze({
   plugins: [],
   autoResume: false,
   infiniteReconnects: false,
-  failoverOptions: {
+  failoverOptions: Object.freeze({
     enabled: true,
     maxRetries: 3,
     retryDelay: 1000,
@@ -27,22 +27,27 @@ const DEFAULT_OPTIONS = Object.freeze({
     resumePlayback: true,
     cooldownTime: 5000,
     maxFailoverAttempts: 5
-  }
+  })
 })
 
 const CLEANUP_INTERVAL = 60000
-const MAX_CONCURRENT_OPERATIONS = 3
+const MAX_CONCURRENT_OPS = 3
 const BROKEN_PLAYER_TTL = 300000
 const FAILOVER_CLEANUP_TTL = 600000
+const NODE_BATCH_SIZE = 2
+const PLAYER_BATCH_SIZE = 5
+const SEEK_DELAY = 200
+const RECONNECT_DELAY = 1000
+const NODE_CHECK_INTERVAL = 100
+
+
+const delay = ms => new Promise(resolve => setTimeout(resolve, ms))
 
 class Aqua extends EventEmitter {
   constructor(client, nodes, options = {}) {
     super()
-
     if (!client) throw new Error('Client is required')
-    if (!Array.isArray(nodes) || !nodes.length) {
-      throw new TypeError(`Nodes must be non-empty Array (got ${typeof nodes})`)
-    }
+    if (!Array.isArray(nodes) || !nodes.length) throw new TypeError('Nodes must be non-empty Array')
 
     this.client = client
     this.nodes = nodes
@@ -55,14 +60,16 @@ class Aqua extends EventEmitter {
     this.options = { ...DEFAULT_OPTIONS, ...options }
     this.failoverOptions = { ...DEFAULT_OPTIONS.failoverOptions, ...options.failoverOptions }
 
-    this.shouldDeleteMessage = this.options.shouldDeleteMessage
-    this.defaultSearchPlatform = this.options.defaultSearchPlatform
-    this.leaveOnEnd = this.options.leaveOnEnd
-    this.restVersion = this.options.restVersion
-    this.plugins = this.options.plugins
-    this.autoResume = this.options.autoResume
-    this.infiniteReconnects = this.options.infiniteReconnects
-    this.send = this.options.send || this._defaultSend
+    Object.assign(this, {
+      shouldDeleteMessage: this.options.shouldDeleteMessage,
+      defaultSearchPlatform: this.options.defaultSearchPlatform,
+      leaveOnEnd: this.options.leaveOnEnd,
+      restVersion: this.options.restVersion,
+      plugins: this.options.plugins,
+      autoResume: this.options.autoResume,
+      infiniteReconnects: this.options.infiniteReconnects,
+      send: this.options.send || this._defaultSend
+    })
 
     this._nodeStates = new Map()
     this._failoverQueue = new Map()
@@ -73,27 +80,17 @@ class Aqua extends EventEmitter {
     this._startCleanupTimer()
   }
 
-  _defaultSend = (packet) => {
+  _defaultSend = packet => {
     const guildId = packet.d.guild_id
-    const guild = this.client?.cache?.guilds.get(guildId) ?? this.client.guilds?.cache?.get(guildId)
-
-    if (!guild) return;
-
-    if (this.client.gateway) {
-      this.client.gateway.send(this.client.gateway.calculateShardId(guildId), packet)
-    } else {
-      guild.shard?.send(packet)
-    }
+    const guild = this.client.cache?.guilds.get(guildId) ?? this.client.guilds?.cache?.get(guildId)
+    if (!guild) return
+    const gateway = this.client.gateway
+    gateway ? gateway.send(gateway.calculateShardId(guildId), packet) : guild.shard?.send(packet)
   }
 
   _bindEventHandlers() {
-    this._boundCleanupPlayer = this._cleanupPlayer.bind(this)
-    this._boundHandleDestroy = this._handlePlayerDestroy.bind(this)
-    this._boundNodeConnect = this._handleNodeConnect.bind(this)
-    this._boundNodeDisconnect = this._handleNodeDisconnect.bind(this)
-
-    this.on('nodeConnect', this._boundNodeConnect)
-    this.on('nodeDisconnect', this._boundNodeDisconnect)
+    this.on('nodeConnect', node => this.autoResume && process.nextTick(() => this._rebuildBrokenPlayers(node)))
+    this.on('nodeDisconnect', node => this.autoResume && process.nextTick(() => this._storeBrokenPlayers(node)))
   }
 
   _startCleanupTimer() {
@@ -114,29 +111,19 @@ class Aqua extends EventEmitter {
 
   async init(clientId) {
     if (this.initiated) return this
-
     this.clientId = clientId
     let successCount = 0
 
-    const batchSize = 2
-    for (let i = 0; i < this.nodes.length; i += batchSize) {
-      const batch = this.nodes.slice(i, i + batchSize)
-      const results = await Promise.allSettled(batch.map(node => this._createNode(node)))
+    for (let i = 0; i < this.nodes.length; i += NODE_BATCH_SIZE) {
+      const batch = this.nodes.slice(i, i + NODE_BATCH_SIZE)
+      const results = await Promise.allSettled(batch.map(n => this._createNode(n)))
       successCount += results.filter(r => r.status === 'fulfilled').length
     }
+    if (!successCount) throw new Error('No nodes connected')
 
-    if (successCount === 0) {
-      throw new Error('No nodes connected')
-    }
-
-    if (this.plugins.length > 0) {
-      this.plugins.forEach(plugin => {
-        Promise.resolve(plugin.load(this)).catch(err =>
-          this.emit('error', null, new Error(`Plugin error: ${err.message}`))
-        )
-      })
+    for (const plugin of this.plugins) {
+      try { await plugin.load(this) } catch (err) { this.emit('error', null, new Error(`Plugin error: ${err.message}`)) }
     }
-
     this.initiated = true
     return this
   }
@@ -144,11 +131,9 @@ class Aqua extends EventEmitter {
   async _createNode(options) {
     const nodeId = options.name || options.host
     this._destroyNode(nodeId)
-
     const node = new Node(this, options, this.options)
     node.players = new Set()
     this.nodeMap.set(nodeId, node)
-
     this._nodeStates.set(nodeId, { connected: false, failoverInProgress: false })
 
     try {
@@ -162,36 +147,16 @@ class Aqua extends EventEmitter {
     }
   }
 
-  _handleNodeConnect(node) {
-    if (!this.autoResume) return;
-
-    const nodeId = node.name || node.host
-    this._nodeStates.set(nodeId, { connected: true, failoverInProgress: false })
-
-    process.nextTick(() => this._rebuildBrokenPlayers(node))
-  }
-
-  _handleNodeDisconnect(node) {
-    if (!this.autoResume) return;
-
-    const nodeId = node.name || node.host
-    this._nodeStates.set(nodeId, { connected: false, failoverInProgress: false })
-
-    process.nextTick(() => this._storeBrokenPlayers(node))
-  }
-
   _storeBrokenPlayers(node) {
     const nodeId = node.name || node.host
     const now = Date.now()
-
     for (const player of this.players.values()) {
-      if (player.nodes === node) {
-        const state = this._capturePlayerState(player)
-        if (state) {
-          state.originalNodeId = nodeId
-          state.brokenAt = now
-          this._brokenPlayers.set(player.guildId, state)
-        }
+      if (player.nodes !== node) continue
+      const state = this._capturePlayerState(player)
+      if (state) {
+        state.originalNodeId = nodeId
+        state.brokenAt = now
+        this._brokenPlayers.set(player.guildId, state)
       }
     }
   }
@@ -199,54 +164,34 @@ class Aqua extends EventEmitter {
   _rebuildBrokenPlayers(node) {
     const nodeId = node.name || node.host
     let rebuiltCount = 0
-
-    for (const [guildId, brokenState] of this._brokenPlayers.entries()) {
-      if (brokenState.originalNodeId === nodeId) {
-        this._rebuildPlayer(brokenState, node)
-          .then(() => {
-            this._brokenPlayers.delete(guildId)
-            rebuiltCount++
-          })
-          .catch(() => {
-            if (Date.now() - brokenState.brokenAt > BROKEN_PLAYER_TTL) {
-              this._brokenPlayers.delete(guildId)
-            }
-          })
-      }
-    }
-
-    if (rebuiltCount > 0) {
-      this.emit('playersRebuilt', node, rebuiltCount)
+    for (const [guildId, brokenState] of this._brokenPlayers) {
+      if (brokenState.originalNodeId !== nodeId) continue
+      this._rebuildPlayer(brokenState, node)
+        .then(() => {
+          this._brokenPlayers.delete(guildId)
+          rebuiltCount++
+        })
+        .catch(() => {
+          if (Date.now() - brokenState.brokenAt > BROKEN_PLAYER_TTL) this._brokenPlayers.delete(guildId)
+        })
     }
+    if (rebuiltCount) this.emit('playersRebuilt', node, rebuiltCount)
   }
 
   async _rebuildPlayer(brokenState, targetNode) {
     const { guildId, textChannel, voiceChannel, current, volume = 65, deaf = true } = brokenState
-
     const existingPlayer = this.players.get(guildId)
-    if (existingPlayer) {
-      await existingPlayer.destroy()
-    }
-
+    if (existingPlayer) await existingPlayer.destroy()
     setTimeout(async () => {
       try {
-        const player = await this.createConnection({
-          guildId,
-          textChannel,
-          voiceChannel,
-          defaultVolume: volume,
-          deaf
-        })
-
+        const player = await this.createConnection({ guildId, textChannel, voiceChannel, defaultVolume: volume, deaf })
         if (current) {
           await player.queue.add(current)
           await player.play()
           this.emit('trackStart', player, current)
         }
-      } catch (error) {
-        this._brokenPlayers.delete(guildId)
-      }
-    }, 1000)
+      } catch { this._brokenPlayers.delete(guildId) }
+    }, RECONNECT_DELAY)
   }
 
   _destroyNode(identifier) {
@@ -259,10 +204,7 @@ class Aqua extends EventEmitter {
 
   _cleanupNode(nodeId) {
     const node = this.nodeMap.get(nodeId)
-    if (node) {
-      node.removeAllListeners()
-    }
-
+    node?.removeAllListeners()
     this.nodeMap.delete(nodeId)
     this._nodeStates.delete(nodeId)
     this._failoverQueue.delete(nodeId)
@@ -270,19 +212,15 @@ class Aqua extends EventEmitter {
   }
 
   async handleNodeFailover(failedNode) {
-    if (!this.failoverOptions.enabled) return;
-
+    if (!this.failoverOptions.enabled) return
     const nodeId = failedNode.name || failedNode.host
     const now = Date.now()
-
     const nodeState = this._nodeStates.get(nodeId)
-    if (nodeState?.failoverInProgress) return;
-
+    if (nodeState?.failoverInProgress) return
     const lastAttempt = this._lastFailoverAttempt.get(nodeId)
-    if (lastAttempt && (now - lastAttempt) < this.failoverOptions.cooldownTime) return;
-
+    if (lastAttempt && (now - lastAttempt) < this.failoverOptions.cooldownTime) return
     const attempts = this._failoverQueue.get(nodeId) || 0
-    if (attempts >= this.failoverOptions.maxFailoverAttempts) return;
+    if (attempts >= this.failoverOptions.maxFailoverAttempts) return
 
     this._nodeStates.set(nodeId, { connected: false, failoverInProgress: true })
     this._lastFailoverAttempt.set(nodeId, now)
@@ -290,25 +228,19 @@ class Aqua extends EventEmitter {
 
     try {
       this.emit('nodeFailover', failedNode)
-
       const affectedPlayers = Array.from(failedNode.players)
-      if (affectedPlayers.length === 0) {
+      if (!affectedPlayers.length) {
         this._nodeStates.set(nodeId, { connected: false, failoverInProgress: false })
-        return;
+        return
       }
-
       const availableNodes = this._getAvailableNodes(failedNode)
-      if (availableNodes.length === 0) {
+      if (!availableNodes.length) {
         this.emit('error', null, new Error('No failover nodes available'))
-        return;
+        return
       }
-
       const results = await this._migratePlayersOptimized(affectedPlayers, availableNodes)
       const successful = results.filter(r => r.success).length
-
-      if (successful > 0) {
-        this.emit('nodeFailoverComplete', failedNode, successful, results.length - successful)
-      }
+      if (successful) this.emit('nodeFailoverComplete', failedNode, successful, results.length - successful)
     } catch (error) {
       this.emit('error', null, new Error(`Failover failed: ${error.message}`))
     } finally {
@@ -318,41 +250,29 @@ class Aqua extends EventEmitter {
 
   async _migratePlayersOptimized(players, availableNodes) {
     const results = []
-
-    for (let i = 0; i < players.length; i += MAX_CONCURRENT_OPERATIONS) {
-      const batch = players.slice(i, i + MAX_CONCURRENT_OPERATIONS)
-      const batchResults = await Promise.allSettled(
-        batch.map(player => this._migratePlayer(player, availableNodes))
-      )
-
-      results.push(...batchResults.map(r => ({
-        success: r.status === 'fulfilled',
-        error: r.reason
-      })))
+    for (let i = 0; i < players.length; i += MAX_CONCURRENT_OPS) {
+      const batch = players.slice(i, i + MAX_CONCURRENT_OPS)
+      const batchResults = await Promise.allSettled(batch.map(p => this._migratePlayer(p, availableNodes)))
+      results.push(...batchResults.map(r => ({ success: r.status === 'fulfilled', error: r.reason })))
     }
-
     return results
   }
 
   async _migratePlayer(player, availableNodes) {
     let retryCount = 0
-
     while (retryCount < this.failoverOptions.maxRetries) {
       try {
         const targetNode = availableNodes[0]
         const playerState = this._capturePlayerState(player)
-
         if (!playerState) throw new Error('Failed to capture state')
-
         const newPlayer = await this._createPlayerOnNode(targetNode, playerState)
         await this._restorePlayerState(newPlayer, playerState)
-
         this.emit('playerMigrated', player, newPlayer, targetNode)
         return newPlayer
       } catch (error) {
         retryCount++
         if (retryCount >= this.failoverOptions.maxRetries) throw error
-        await this._delay(this.failoverOptions.retryDelay)
+        await delay(this.failoverOptions.retryDelay)
       }
     }
   }
@@ -373,9 +293,7 @@ class Aqua extends EventEmitter {
         deaf: player.deaf || false,
         connected: player.connected || false
       }
-    } catch {
-      return null
-    }
+    } catch { return null }
   }
 
   async _createPlayerOnNode(targetNode, playerState) {
@@ -389,76 +307,60 @@ class Aqua extends EventEmitter {
   }
 
   async _restorePlayerState(newPlayer, playerState) {
-    if (playerState.volume !== undefined) {
-      newPlayer.setVolume(playerState.volume)
-    }
-
-    if (playerState.queue?.length > 0) {
-      newPlayer.queue.add(...playerState.queue)
-    }
-
+    if (playerState.volume !== undefined) newPlayer.setVolume(playerState.volume)
+    if (playerState.queue?.length) newPlayer.queue.add(...playerState.queue)
     if (playerState.current && this.failoverOptions.preservePosition) {
       newPlayer.queue.unshift(playerState.current)
-
       if (this.failoverOptions.resumePlayback) {
         await newPlayer.play()
-
-        if (playerState.position > 0) {
-          setTimeout(() => newPlayer.seek(playerState.position), 200)
-        }
-
-        if (playerState.paused) {
-          newPlayer.pause()
-        }
+        if (playerState.position > 0) setTimeout(() => newPlayer.seek(playerState.position), SEEK_DELAY)
+        if (playerState.paused) newPlayer.pause()
       }
     }
-
     newPlayer.repeat = playerState.repeat
     newPlayer.shuffle = playerState.shuffle
   }
 
-  _delay(ms) {
-    return new Promise(resolve => setTimeout(resolve, ms))
-  }
-
   _cleanupPlayer(player) {
-    if (player) {
-      player.destroy()
-    }
+    if (!player) return
+    player.destroy()
+    player.voiceChannel = null
+    this.emit('playerDestroy', player)
   }
 
+
+
   updateVoiceState({ d, t }) {
-    if (!GUILD_ID_REGEX.test(d.guild_id)) return;
+    if (!d.guild_id || (t !== 'VOICE_STATE_UPDATE' && t !== 'VOICE_SERVER_UPDATE')) {
+      return;
+    }
 
-    const player = this.players.get(d.guild_id)
+    const player = this.players.get(d.guild_id);
     if (!player) return;
+    if (t === 'VOICE_STATE_UPDATE') {
+      if (d.user_id !== this.clientId) return;
+      if (!d.channel_id) return this._cleanupPlayer(player);
 
-    if (t === 'VOICE_SERVER_UPDATE' || (t === 'VOICE_STATE_UPDATE' && d.user_id === this.clientId)) {
-      if (t === 'VOICE_SERVER_UPDATE') {
-        player.connection?.setServerUpdate?.(d)
-      } else {
-        player.connection?.setStateUpdate?.(d)
-      }
+      if (!player.connection?.sessionId && d.session_id) return player.connection.sessionId = d.session_id
 
-      if (d.channel_id === null) {
-        this._boundCleanupPlayer(player)
+      if (d.session_id && player.connection && player.connection.sessionId !== d.session_id) {
+        player.connection.sessionId = d.session_id
+        this.emit('debug', `[Player ${player.guildId}] Session was outdated, updated to ${d.session_id}`)
       }
+
+      player.connection.setStateUpdate(d);
+
+    } else {
+      player.connection.setServerUpdate(d);
     }
   }
 
   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)
-      }
-    }
-
-    return regionNodes.sort((a, b) => this._getNodeLoad(a) - this._getNodeLoad(b))
+    return Array.from(this.nodeMap.values())
+      .filter(n => n.connected && n.regions?.includes(lowerRegion))
+      .sort((a, b) => this._getNodeLoad(a) - this._getNodeLoad(b))
   }
 
   _getNodeLoad(node) {
@@ -468,24 +370,18 @@ class Aqua extends EventEmitter {
 
   createConnection(options) {
     if (!this.initiated) throw new Error('Aqua not initialized')
-
     const existingPlayer = this.players.get(options.guildId)
     if (existingPlayer?.voiceChannel) return existingPlayer
-
     const availableNodes = options.region ? this.fetchRegion(options.region) : this.leastUsedNodes
-
     if (!availableNodes.length) throw new Error('No nodes available')
-
     return this.createPlayer(availableNodes[0], options)
   }
 
   createPlayer(node, options) {
     this.destroyPlayer(options.guildId)
-
     const player = new Player(this, node, options)
     this.players.set(options.guildId, player)
-
-    player.once('destroy', this._boundHandleDestroy)
+    player.once('destroy', this._handlePlayerDestroy.bind(this))
     player.connect(options)
     this.emit('playerCreate', player)
     return player
@@ -493,42 +389,33 @@ class Aqua extends EventEmitter {
 
   _handlePlayerDestroy(player) {
     const node = player.nodes
-    if (node?.players) {
-      node.players.delete(player)
-    }
+    node?.players?.delete(player)
     this.players.delete(player.guildId)
     this.emit('playerDestroy', player)
   }
 
   async destroyPlayer(guildId) {
     const player = this.players.get(guildId)
-    if (!player) return;
-
+    if (!player) return
     try {
       await player.clearData()
       player.removeAllListeners()
       this.players.delete(guildId)
+      this.nodes.rest.destroyPlayer(guildId)
       this.emit('playerDestroy', player)
-    } catch {
-      // Silent cleanup
-    }
+    } catch { }
   }
 
   async resolve({ query, source = this.defaultSearchPlatform, requester, nodes }) {
     if (!this.initiated) throw new Error('Aqua not initialized')
-
     const requestNode = this._getRequestNode(nodes)
-    const formattedQuery = URL_REGEX.test(query) ? query : `${source}:${query}`
-
+    const formattedQuery = URL_PATTERN.test(query) ? query : `${source}${SEARCH_PREFIX}${query}`
     try {
       const endpoint = `/v4/loadtracks?identifier=${encodeURIComponent(formattedQuery)}`
       const response = await requestNode.rest.makeRequest('GET', endpoint)
-
-      if (['empty', 'NO_MATCHES'].includes(response.loadType)) {
-        return this._createEmptyResponse()
-      }
-
+      if (['empty', 'NO_MATCHES'].includes(response.loadType)) return this._createEmptyResponse()
       return this._constructResponse(response, requester, requestNode)
+
     } catch (error) {
       throw new Error(error.name === 'AbortError' ? 'Request timeout' : `Resolve failed: ${error.message}`)
     }
@@ -537,20 +424,12 @@ class Aqua extends EventEmitter {
   _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') return this.nodeMap.get(nodes) || this.leastUsedNodes[0]
     throw new TypeError(`Invalid nodes parameter: ${typeof nodes}`)
   }
 
   _createEmptyResponse() {
-    return {
-      loadType: 'empty',
-      exception: null,
-      playlistInfo: null,
-      pluginInfo: {},
-      tracks: []
-    }
+    return { loadType: 'empty', exception: null, playlistInfo: null, pluginInfo: {}, tracks: [] }
   }
 
   _constructResponse(response, requester, requestNode) {
@@ -561,46 +440,33 @@ class Aqua extends EventEmitter {
       pluginInfo: response.pluginInfo || {},
       tracks: []
     }
-
     if (response.loadType === 'error' || response.loadType === 'LOAD_FAILED') {
       baseResponse.exception = response.data || response.exception
       return baseResponse
     }
-
     switch (response.loadType) {
       case 'track':
-        if (response.data) {
-          baseResponse.tracks.push(new Track(response.data, requester, requestNode))
-        }
+        if (response.data) baseResponse.tracks.push(new Track(response.data, requester, requestNode))
         break
-
       case 'playlist': {
         const info = response.data?.info
         if (info) {
           baseResponse.playlistInfo = {
             name: info.name || info.title,
-            thumbnail: response.data.pluginInfo?.artworkUrl ||
-              response.data.tracks?.[0]?.info?.artworkUrl || null,
+            thumbnail: response.data.pluginInfo?.artworkUrl || response.data.tracks?.[0]?.info?.artworkUrl || null,
             ...info
           }
         }
-
         const tracks = response.data?.tracks
-        if (tracks?.length) {
-          baseResponse.tracks = tracks.map(track => new Track(track, requester, requestNode))
-        }
+        if (tracks?.length) baseResponse.tracks = tracks.map(t => new Track(t, requester, requestNode))
         break
       }
-
       case 'search': {
         const searchData = response.data || []
-        if (searchData.length) {
-          baseResponse.tracks = searchData.map(track => new Track(track, requester, requestNode))
-        }
+        if (searchData.length) baseResponse.tracks = searchData.map(t => new Track(t, requester, requestNode))
         break
       }
     }
-
     return baseResponse
   }
 
@@ -612,75 +478,58 @@ class Aqua extends EventEmitter {
 
   async search(query, requester, source = this.defaultSearchPlatform) {
     if (!query || !requester) return null
-
     try {
       const { tracks } = await this.resolve({ query, source, requester })
       return tracks || null
-    } catch {
-      return null
-    }
+    } catch { return null }
   }
 
-  async loadPlayers(filePath = './AquaPlayers.json') {
+  async loadPlayers(filePath = './AquaPlayers.jsonl') {
     try {
       await fs.access(filePath)
       await this._waitForFirstNode()
-
-      const data = JSON.parse(await fs.readFile(filePath, 'utf8'))
-
-      const batchSize = 5
-      for (let i = 0; i < data.length; i += batchSize) {
-        const batch = data.slice(i, i + batchSize)
+      const rawData = await fs.readFile(filePath, 'utf8')
+      const lines = rawData.trim().split('\n').filter(Boolean)
+      for (let i = 0; i < lines.length; i += PLAYER_BATCH_SIZE) {
+        const batch = lines.slice(i, i + PLAYER_BATCH_SIZE).map(line => JSON.parse(line))
         await Promise.all(batch.map(p => this._restorePlayer(p)))
       }
-
-      await fs.writeFile(filePath, '[]', 'utf8')
-    } catch (error) {
-      // Silent error handling
-    }
+      await fs.writeFile(filePath, '', 'utf8')
+    } catch { }
   }
 
-  async savePlayer(filePath = './AquaPlayers.json') {
-    const data = Array.from(this.players.values()).map(player => {
+  async savePlayer(filePath = './AquaPlayers.jsonl') {
+    const lines = []
+    for (const player of this.players.values()) {
       const requester = player.requester || player.current?.requester
-
-      return {
+      const compactData = {
         g: player.guildId,
         t: player.textChannel,
         v: player.voiceChannel,
         u: player.current?.uri || null,
         p: player.position || 0,
         ts: player.timestamp || 0,
-        q: player.queue?.tracks?.map(tr => tr.uri).slice(0, 5) || [],
-        r: requester ? {
-          id: requester.id,
-          username: requester.username,
-          globalName: requester.globalName,
-          discriminator: requester.discriminator,
-          avatar: requester.avatar
-        } : null,
+        q: player.queue?.tracks?.slice(0, 5).map(tr => tr.uri) || [],
+        r: requester ? `${requester.id}:${requester.username}` : null,
         vol: player.volume,
-        pa: player.paused,
-        isPlaying: player.playing,
-        sessionId: player.connection.sessionId,
-        endpoint: player.connection.endpoint,
-        token: player.connection.token
+        pa: !!player.paused,
+        pl: !!player.playing,
+        s: player.connection.sessionId,
+        e: player.connection.endpoint,
+        tk: player.connection.token
       }
-    })
-
-    await fs.writeFile(filePath, JSON.stringify(data), 'utf8')
-    this.emit('debug', 'Aqua', `Saved ${data.length} players to ${filePath}`)
+      lines.push(JSON.stringify(compactData))
+    }
+    await fs.writeFile(filePath, lines.join('\n'), 'utf8')
+    this.emit('debug', 'Aqua', `Saved ${lines.length} players to ${filePath}`)
   }
 
   async _restorePlayer(p) {
     try {
       let player = this.players.get(p.g)
       if (!player) {
-        const targetNode = (p.n && this.nodeMap.get(p.n)?.connected) ?
-          this.nodeMap.get(p.n) : this.leastUsedNodes[0]
-
-        if (!targetNode) return;
-
+        const targetNode = this.leastUsedNodes[0]
+        if (!targetNode) return
         player = await this.createConnection({
           guildId: p.g,
           textChannel: p.t,
@@ -689,44 +538,31 @@ class Aqua extends EventEmitter {
           deaf: true
         })
       }
-
       if (player?.connection) {
-        if (p.sessionId) player.connection.sessionId = p.sessionId
-        if (p.endpoint) player.connection.endpoint = p.endpoint
-        if (p.token) player.connection.token = p.token
+        if (p.s) player.connection.sessionId = p.s
+        if (p.e) player.connection.endpoint = p.e
+        if (p.tk) player.connection.token = p.tk
       }
-
       if (p.u && player) {
-        const resolved = await this.resolve({ query: p.u, requester: p.r })
+        const resolved = await this.resolve({ query: p.u, requester: this._parseRequester(p.r) })
         if (resolved.tracks?.[0]) {
           player.queue.add(resolved.tracks[0])
           player.position = p.p || 0
-          if (typeof p.ts === 'number') player.timestamp = p.ts
         }
       }
-
       if (p.q?.length && player) {
-        const queuePromises = p.q
-          .filter(uri => uri !== p.u)
-          .map(uri => this.resolve({ query: uri, requester: p.r }))
-
+        const queuePromises = p.q.filter(uri => uri !== p.u).map(uri => this.resolve({ query: uri, requester: p.r }))
         const queueResults = await Promise.allSettled(queuePromises)
         queueResults.forEach(result => {
-          if (result.status === 'fulfilled' && result.value.tracks?.[0]) {
-            player.queue.add(result.value.tracks[0])
-          }
+          if (result.status === 'fulfilled' && result.value.tracks?.[0]) player.queue.add(result.value.tracks[0])
         })
       }
-
       if (player) {
-        if (typeof p.vol === 'number') {
-          player.volume = p.vol
-        }
-
+        if (typeof p.vol === 'number') player.volume = p.vol
         player.paused = !!p.pa
-
-        if ((p.isPlaying || (p.pa && p.u)) && player.queue.size > 0) {
+        if ((p.pl || (p.pa && p.u)) && player.queue.size > 0) {
           player.play()
+          player.seek(p.p || 0)
         }
       }
     } catch (error) {
@@ -734,29 +570,30 @@ class Aqua extends EventEmitter {
     }
   }
 
-  async _waitForFirstNode() {
-    if (this.leastUsedNodes.length > 0) return;
+  _parseRequester(requesterString) {
+    if (!requesterString) return null
+    const [id, username] = requesterString.split(':')
+    return { id, username }
+  }
 
+  async _waitForFirstNode() {
+    if (this.leastUsedNodes.length) return
     return new Promise(resolve => {
       const checkInterval = setInterval(() => {
-        if (this.leastUsedNodes.length > 0) {
+        if (this.leastUsedNodes.length) {
           clearInterval(checkInterval)
           resolve()
         }
-      }, 100)
+      }, NODE_CHECK_INTERVAL)
     })
   }
 
   _performCleanup() {
     const now = Date.now()
-
-    for (const [guildId, state] of this._brokenPlayers.entries()) {
-      if (now - state.brokenAt > BROKEN_PLAYER_TTL) {
-        this._brokenPlayers.delete(guildId)
-      }
+    for (const [guildId, state] of this._brokenPlayers) {
+      if (now - state.brokenAt > BROKEN_PLAYER_TTL) this._brokenPlayers.delete(guildId)
     }
-
-    for (const [nodeId, timestamp] of this._lastFailoverAttempt.entries()) {
+    for (const [nodeId, timestamp] of this._lastFailoverAttempt) {
       if (now - timestamp > FAILOVER_CLEANUP_TTL) {
         this._lastFailoverAttempt.delete(nodeId)
         this._failoverQueue.delete(nodeId)
@@ -764,58 +601,8 @@ class Aqua extends EventEmitter {
     }
   }
 
-  getBrokenPlayersCount() {
-    return this._brokenPlayers.size
-  }
-
-  getNodeStats() {
-    const stats = {}
-    for (const [name, node] of this.nodeMap) {
-      const nodeStats = node.stats || {}
-      stats[name] = {
-        connected: node.connected,
-        players: nodeStats.players || 0,
-        playingPlayers: nodeStats.playingPlayers || 0,
-        uptime: nodeStats.uptime || 0,
-        cpu: nodeStats.cpu || {},
-        memory: nodeStats.memory || {},
-        ping: nodeStats.ping || 0
-      }
-    }
-    return stats
-  }
-
-  destroy() {
-    if (this._cleanupTimer) {
-      clearInterval(this._cleanupTimer)
-    }
-
-    this.removeAllListeners()
-
-    for (const player of this.players.values()) {
-      this._cleanupPlayer(player)
-    }
-
-    for (const node of this.nodeMap.values()) {
-      node.removeAllListeners()
-    }
-
-    this.players.clear()
-    this.nodeMap.clear()
-    this._brokenPlayers.clear()
-    this._nodeStates.clear()
-    this._failoverQueue.clear()
-    this._lastFailoverAttempt.clear()
-  }
-
   _getAvailableNodes(excludeNode) {
-    const available = []
-    for (const node of this.nodeMap.values()) {
-      if (node !== excludeNode && node.connected) {
-        available.push(node)
-      }
-    }
-    return available
+    return Array.from(this.nodeMap.values()).filter(n => n !== excludeNode && n.connected)
   }
 }