aqualink 2.20.1 → 3.1.0

package/build/structures/Player.js

@@ -2,6 +2,9 @@ const { EventEmitter } = require('node:events')
 const { AqualinkEvents } = require('./AqualinkEvents')
 const Connection = require('./Connection')
 const Filters = require('./Filters')
+const PlayerLifecycle = require('./PlayerLifecycle')
+const { attachPlayerLifecycleState } = require('./PlayerLifecycleState')
+const { reportSuppressedError } = require('./Reporting')
 const { spAutoPlay, scAutoPlay } = require('../handlers/autoplay')
 const Queue = require('./Queue')
 
@@ -43,6 +46,8 @@ const MUTE_TOGGLE_DELAY = 300
 const SEEK_DELAY = 800
 const PAUSE_DELAY = 1200
 const VOICE_TRACE_INTERVAL = 15000
+const PLAYER_UPDATE_SILENCE_THRESHOLD = 45000
+const VOICE_FORCE_DESTROY_MS = 15 * 60 * 1000
 const RETRY_BACKOFF_BASE = 1500
 const RETRY_BACKOFF_MAX = 5000
 const PREVIOUS_TRACKS_SIZE = 50
@@ -75,6 +80,20 @@ const _functions = {
     for (const t of set) clearTimeout(t)
     set.clear()
   },
+  safeCall(fn) {
+    try {
+      return fn?.()
+    } catch {}
+    return null
+  },
+  emitAquaError(aqua, error) {
+    if (!aqua?.listenerCount) return
+    try {
+      if (aqua.listenerCount(AqualinkEvents.Error) > 0) {
+        aqua.emit(AqualinkEvents.Error, error)
+      }
+    } catch {}
+  },
   emitIfActive(player, event, ...args) {
     if (!player.destroyed) player.aqua.emit(event, player, ...args)
   }
@@ -103,13 +122,13 @@ class MicrotaskUpdateBatcher {
     const { player: p, updates: u } = this
     this.updates = null
     this.scheduled = false
-    if (!u || !p) return Promise.resolve()
+    if (!u || !p || p.destroyed || p.state === PLAYER_STATE.DISCONNECTING)
+      return Promise.resolve()
     return p.updatePlayer(u).catch((err) => {
-      p.aqua?.emit?.(
-        AqualinkEvents.Error,
+      _functions.emitAquaError(
+        p.aqua,
         new Error(`Update error: ${err.message}`)
       )
-      throw err
     })
   }
 
@@ -190,11 +209,11 @@ class Player extends EventEmitter {
     this.mute = !!options.mute
     this.autoplayRetries = this.reconnectionRetries = 0
     this._voiceDownSince = 0
-    this._voiceRecovering = this._reconnecting = false
-    this._resuming = !!options.resuming
+    attachPlayerLifecycleState(this, { resuming: !!options.resuming })
     this._voiceWatchdogTimer = null
     this._pendingTimers = new Set()
     this._reconnectTimers = null
+    this._reconnectNonce = 0
     this._dataStore = null
 
     this.volume = _functions.clamp(options.defaultVolume || 100)
@@ -210,12 +229,30 @@ class Player extends EventEmitter {
     this.previousIdentifiers = new Set()
     this.previousTracks = new CircularBuffer(PREVIOUS_TRACKS_SIZE)
     this._updateBatcher = batcherPool.acquire(this)
+    this._lifecycleController = new PlayerLifecycle(this, {
+      _functions,
+      PLAYER_STATE,
+      VOICE_TRACE_INTERVAL,
+      PLAYER_UPDATE_SILENCE_THRESHOLD,
+      VOICE_DOWN_THRESHOLD,
+      VOICE_ABANDON_MULTIPLIER,
+      VOICE_FORCE_DESTROY_MS,
+      RECONNECT_MAX,
+      MUTE_TOGGLE_DELAY,
+      SEEK_DELAY,
+      PAUSE_DELAY,
+      RETRY_BACKOFF_BASE,
+      RETRY_BACKOFF_MAX
+    })
 
     this._voiceRequestAt = 0
     this._voiceRequestChannel = null
     this._suppressResumeUntil = 0
-    this._deferredStart = false
     this._lastVoiceUpTraceAt = 0
+    this._lastPlayerUpdateAt = Date.now()
+    this._voiceRecoverySeq = 0
+    this._activeVoiceRecoveryToken = 0
+    this._voiceRecoveryReason = null
     this._bindEvents()
     this._startWatchdog()
   }
@@ -252,58 +289,28 @@ class Player extends EventEmitter {
     return new Promise((r) => this._createTimer(r, ms))
   }
 
-  _handlePlayerUpdate(packet) {
-    if (this.destroyed || !packet?.state) return
-    const s = packet.state
-    const wasConnected = this.connected
-    this.position = _functions.isNum(s.position) ? s.position : 0
-    this.connected = !!s.connected
-    this.ping = _functions.isNum(s.ping) ? s.ping : 0
-    this.timestamp = _functions.isNum(s.time) ? s.time : Date.now()
-
-    if (!this.connected) {
-      if (wasConnected || !this._voiceDownSince) {
-        this.aqua?._trace?.('player.voice.down', {
-          guildId: this.guildId,
-          reconnecting: !!this._reconnecting,
-          recovering: !!this._voiceRecovering
-        })
-      }
-      if (
-        !this._voiceDownSince &&
-        !this._reconnecting &&
-        !this._voiceRecovering
-      ) {
-        this._voiceDownSince = Date.now()
-        this._createTimer(() => {
-          if (
-            this.connected ||
-            this.destroyed ||
-            this._reconnecting ||
-            this._voiceRecovering ||
-            this.nodes?.info?.isNodelink
-          )
-            return
-          this.connection.attemptResume()
-        }, 1000)
-      }
-    } else {
-      this._voiceDownSince = 0
-      this.state = PLAYER_STATE.READY
-      const now = Date.now()
-      if (
-        !wasConnected ||
-        now - this._lastVoiceUpTraceAt >= VOICE_TRACE_INTERVAL
-      ) {
-        this._lastVoiceUpTraceAt = now
-        this.aqua?._trace?.('player.voice.up', {
-          guildId: this.guildId,
-          ping: this.ping
-        })
-      }
-    }
+  _claimVoiceRecovery(reason = 'unknown') {
+    const token = ++this._voiceRecoverySeq
+    this._activeVoiceRecoveryToken = token
+    this._voiceRecoveryReason = reason
+    return token
+  }
+
+  _isVoiceRecoveryActive(token) {
+    return (
+      !!token && !this.destroyed && this._activeVoiceRecoveryToken === token
+    )
+  }
 
-    this.aqua.emit(AqualinkEvents.PlayerUpdate, this, packet)
+  _clearVoiceRecovery(token = this._activeVoiceRecoveryToken, reason = null) {
+    if (!token || this._activeVoiceRecoveryToken !== token) return false
+    this._activeVoiceRecoveryToken = 0
+    this._voiceRecoveryReason = reason
+    return true
+  }
+
+  _handlePlayerUpdate(packet) {
+    return this._lifecycleController.handlePlayerUpdate(packet)
   }
 
   async _handleEvent(payload) {
@@ -318,13 +325,9 @@ class Player extends EventEmitter {
       return
     }
     try {
-      const trackArg =
-        payload.type === 'TrackStartEvent'
-          ? payload.track || this.current
-          : this.current
-      await this[handler](this, trackArg, payload)
+      await this[handler](this, this.current, payload)
     } catch (error) {
-      this.aqua.emit(AqualinkEvents.Error, error)
+      _functions.emitAquaError(this.aqua, error)
     }
   }
 
@@ -352,6 +355,11 @@ class Player extends EventEmitter {
 
   async play(track, options = {}) {
     if (this.destroyed || !this.queue) return this
+    if (options != null && typeof options !== 'object') {
+      throw new TypeError(
+        `Player.play(): options must be an object, got ${typeof options}`
+      )
+    }
 
     let item = track
     if (!item) {
@@ -370,30 +378,85 @@ class Player extends EventEmitter {
       }
       this.current = resolvedItem
       if (this.destroyed) return this
-      if (!this.current?.track) throw new Error('Failed to resolve track')
+      if (!this.current?.track) {
+        this.current = null
+        this.playing = false
+        if (this.aqua?.debugTrace) {
+          this.aqua._trace('player.play.unresolved', {
+            guildId: this.guildId,
+            reconnecting: !!this._reconnecting,
+            resuming: !!this._resuming,
+            voiceRecovering: !!this._voiceRecovering
+          })
+        }
+        if (this._reconnecting || this._resuming || this._voiceRecovering)
+          return this
+        throw new Error('Failed to resolve track')
+      }
 
       this.playing = true
       this.paused = !!options.paused
       this.position = options.startTime || 0
-      this.aqua?._trace?.('player.play', {
-        guildId: this.guildId,
-        paused: this.paused,
-        startTime: this.position,
-        hasTrack: !!this.current?.track
-      })
+      if (this.aqua?.debugTrace) {
+        this.aqua._trace('player.play', {
+          guildId: this.guildId,
+          paused: this.paused,
+          startTime: this.position,
+          hasTrack: !!this.current?.track
+        })
+      }
 
       if (this.destroyed || !this._updateBatcher) return this
 
+      if (
+        this.voiceChannel &&
+        !this.connected &&
+        !this._reconnecting &&
+        !this._voiceRecovering
+      ) {
+        this._deferredStart = true
+        const recoveryToken = this._claimVoiceRecovery('play_deferred')
+        if (this.aqua?.debugTrace) {
+          this.aqua._trace('player.play.deferred', {
+            guildId: this.guildId,
+            reason: 'voice_not_connected'
+          })
+        }
+        const now = Date.now()
+        if (
+          now - (this._voiceRequestAt || 0) >= 1200 &&
+          this._isVoiceRecoveryActive(recoveryToken)
+        ) {
+          this._voiceRequestAt = now
+          if (this._isVoiceRecoveryActive(recoveryToken))
+            this.connection?._requestVoiceState?.()
+          if (this._isVoiceRecoveryActive(recoveryToken))
+            this.connection?.resendVoiceUpdate?.(true)
+          if (this._isVoiceRecoveryActive(recoveryToken))
+            _functions.safeCall(() =>
+              this.connect({
+                guildId: this.guildId,
+                voiceChannel: this.voiceChannel,
+                deaf: this.deaf,
+                mute: this.mute
+              })
+            )
+        }
+        return this
+      }
+
       if (
         this.aqua?.autoRegionMigrate &&
         !this._resuming &&
         !this.connection?.endpoint
       ) {
         this._deferredStart = true
-        this.aqua?._trace?.('player.play.deferred', {
-          guildId: this.guildId,
-          reason: 'awaiting_voice_server_update'
-        })
+        if (this.aqua?.debugTrace) {
+          this.aqua._trace('player.play.deferred', {
+            guildId: this.guildId,
+            reason: 'awaiting_voice_server_update'
+          })
+        }
         return this
       }
 
@@ -404,16 +467,33 @@ class Player extends EventEmitter {
       if (this.position > 0) updateData.position = this.position
 
       this._deferredStart = false
-      await this.batchUpdatePlayer(updateData, true)
+      await this.batchUpdatePlayer(updateData, true).catch((err) => {
+        if (!this.destroyed) _functions.emitAquaError(this.aqua, err)
+      })
     } catch (error) {
-      if (!this.destroyed) this.aqua?.emit(AqualinkEvents.Error, error)
-      if (this.queue?.size && !track) return this.play()
+      if (
+        !this.destroyed &&
+        !this._reconnecting &&
+        !this._resuming &&
+        !this._voiceRecovering
+      ) {
+        _functions.emitAquaError(this.aqua, error)
+      }
+      if (
+        this.queue?.size &&
+        !track &&
+        !this._reconnecting &&
+        !this._resuming &&
+        !this._voiceRecovering
+      )
+        return this.play()
     }
     return this
   }
 
   connect(options = {}) {
-    if (this.destroyed) throw new Error('Cannot connect destroyed player')
+    if (this.destroyed)
+      throw new Error(`Cannot connect destroyed player (guild=${this.guildId})`)
 
     const voiceChannel = _functions.toId(
       options.voiceChannel || this.voiceChannel
@@ -429,19 +509,22 @@ class Player extends EventEmitter {
     this._voiceRequestChannel = voiceChannel
 
     this.voiceChannel = voiceChannel
+    this._voiceDownSince = 0
     this.send({
       guild_id: this.guildId,
       channel_id: voiceChannel,
       self_deaf: this.deaf,
       self_mute: this.mute
     })
-    this.aqua?._trace?.('player.connect.request', {
-      guildId: this.guildId,
-      txId: this.txId,
-      voiceChannel,
-      deaf: this.deaf,
-      mute: this.mute
-    })
+    if (this.aqua?.debugTrace) {
+      this.aqua._trace('player.connect.request', {
+        guildId: this.guildId,
+        txId: this.txId,
+        voiceChannel,
+        deaf: this.deaf,
+        mute: this.mute
+      })
+    }
     return this
   }
 
@@ -464,72 +547,33 @@ class Player extends EventEmitter {
   }
 
   async _voiceWatchdog() {
-    if (!this._shouldAttemptVoiceRecovery()) return
-
-    const hasVoiceData =
-      this.connection?.sessionId &&
-      this.connection?.endpoint &&
-      this.connection?.token
-    if (!hasVoiceData) {
-      if (
-        Date.now() - this._voiceDownSince >
-        VOICE_DOWN_THRESHOLD * VOICE_ABANDON_MULTIPLIER
-      )
-        this.destroy()
-      return
-    }
-
-    this._voiceRecovering = true
-    try {
-      if (await this.connection.attemptResume()) {
-        this.reconnectionRetries = this._voiceDownSince = 0
-        return
-      }
-      const originalMute = this.mute
-      this.send({
-        guild_id: this.guildId,
-        channel_id: this.voiceChannel,
-        self_deaf: this.deaf,
-        self_mute: !originalMute
-      })
-      await this._delay(MUTE_TOGGLE_DELAY)
-      if (!this.destroyed) {
-        this.send({
-          guild_id: this.guildId,
-          channel_id: this.voiceChannel,
-          self_deaf: this.deaf,
-          self_mute: originalMute
-        })
-      }
-      this.connection.resendVoiceUpdate()
-      this.reconnectionRetries++
-    } catch {
-      if (++this.reconnectionRetries >= RECONNECT_MAX) this.destroy()
-    } finally {
-      this._voiceRecovering = false
-    }
+    return this._lifecycleController.voiceWatchdog()
   }
 
   destroy(options = {}) {
+    if (this.destroyed) return this
+
     const {
       preserveClient = true,
       skipRemote = false,
       preserveMessage = false,
       preserveReconnecting = false,
-      preserveTracks = false
+      preserveTracks = false,
+      abortSignal = null
     } = options
-    if (this.destroyed && !this.queue) return this
 
-    if (!this.destroyed) {
-      this.destroyed = true
-      this.aqua?._trace?.('player.destroy', {
+    this._reconnectNonce++
+    this.destroyed = true
+    this._clearVoiceRecovery(undefined, 'destroyed')
+    if (this.aqua?.debugTrace) {
+      this.aqua._trace('player.destroy', {
         guildId: this.guildId,
         skipRemote: !!skipRemote,
         preserveTracks: !!preserveTracks,
         preserveReconnecting: !!preserveReconnecting
       })
-      this.emit('destroy')
     }
+    this.emit('destroy')
 
     if (this._voiceWatchdogTimer) {
       clearInterval(this._voiceWatchdogTimer)
@@ -539,7 +583,6 @@ class Player extends EventEmitter {
     _functions.clearTimers(this._pendingTimers)
     this._pendingTimers = null
 
-    // Clear reconnection timers to prevent memory leaks when destroyed externally
     if (this._reconnectTimers) {
       _functions.clearTimers(this._reconnectTimers)
       this._reconnectTimers = null
@@ -553,6 +596,7 @@ class Player extends EventEmitter {
     this._lastVoiceChannel = this.voiceChannel
     this._lastTextChannel = this.textChannel
     this.voiceChannel = null
+    this._isActivelyReconnecting = false
 
     if (
       this.shouldDeleteMessage &&
@@ -574,12 +618,37 @@ class Player extends EventEmitter {
       this._updateBatcher = null
     }
 
+    if (this.filters) {
+      try {
+        this.filters.destroy()
+      } catch (error) {
+        reportSuppressedError(this, 'player.destroy.filters', error, {
+          guildId: this.guildId
+        })
+      }
+    }
+
     this.previousTracks?.clear()
     this.previousTracks = null
     this.previousIdentifiers?.clear()
     this.previousIdentifiers = null
-    this.queue?.clear()
+    if (this.queue) {
+      for (
+        let i = this.queue._head || 0;
+        i < (this.queue._items?.length || 0);
+        i++
+      ) {
+        const t = this.queue._items[i]
+        if (t && typeof t.dispose === 'function') {
+          try {
+            t.dispose()
+          } catch {}
+        }
+      }
+      this.queue.clear()
+    }
     this.queue = null
+    // ML-1: Clear _dataStore to prevent unbounded growth
     this._dataStore?.clear()
     this._dataStore = null
 
@@ -592,39 +661,92 @@ class Player extends EventEmitter {
     if (this.connection) {
       try {
         this.connection.destroy()
-      } catch {}
+      } catch (error) {
+        reportSuppressedError(this, 'player.destroy.connection', error, {
+          guildId: this.guildId
+        })
+      }
     }
-    this.connection = this.filters = this.current = this.autoplaySeed = null
+    this.connection =
+      this.filters =
+      this.current =
+      this.autoplaySeed =
+      this._lifecycleController =
+        null
 
     if (!skipRemote) {
       try {
-        this.send({ guild_id: this.guildId, channel_id: null })
-        this.aqua?.destroyPlayer?.(this.guildId)
-        if (this.nodes?.connected)
-          this.nodes.rest?.destroyPlayer(this.guildId).catch(() => {})
-      } catch {}
+        if (abortSignal?.aborted) {
+          if (this.aqua?.debugTrace) {
+            this.aqua._trace('player.destroy.aborted', {
+              guildId: this.guildId,
+              reason: 'abort_signal_already_set'
+            })
+          }
+        } else {
+          this.send({ guild_id: this.guildId, channel_id: null })
+          this.aqua?.destroyPlayer?.(this.guildId)
+          if (this.nodes?.connected)
+            this.nodes.rest
+              ?.destroyPlayer(this.guildId, abortSignal)
+              .catch((error) => {
+                reportSuppressedError(this, 'player.destroy.remote', error, {
+                  guildId: this.guildId
+                })
+              })
+        }
+      } catch (error) {
+        reportSuppressedError(this, 'player.destroy.gateway', error, {
+          guildId: this.guildId
+        })
+      }
     }
 
-    if (!preserveClient) this.aqua = this.nodes = null
+    if (!preserveClient) {
+      try {
+        this.aqua?.removeListener?.('playerUpdate', this._boundPlayerUpdate)
+      } catch {}
+      this.aqua = this.nodes = null
+    }
     return this
   }
 
   pause(paused) {
-    if (this.destroyed || this.paused === !!paused) return this
+    if (this.destroyed) return this
+    if (paused != null && typeof paused !== 'boolean') {
+      throw new TypeError(
+        `Player.pause(): paused must be a boolean, got ${typeof paused}`
+      )
+    }
+    if (this.paused === !!paused) return this
     this.paused = !!paused
-    this.batchUpdatePlayer({ paused: this.paused }, true).catch(() => {})
+    this.batchUpdatePlayer({ paused: this.paused }, true).catch((error) =>
+      reportSuppressedError(this, 'player.pause', error, {
+        guildId: this.guildId,
+        paused: this.paused
+      })
+    )
     return this
   }
 
   seek(position) {
-    if (this.destroyed || !this.playing || !_functions.isNum(position))
-      return this
+    if (position == null || !_functions.isNum(position)) {
+      throw new TypeError(
+        `Player.seek(): position must be a non-negative number, got ${typeof position}`
+      )
+    }
+    if (this.destroyed || !this.playing) return this
     const len = this.current?.info?.length || 0
     const clamped = len
       ? Math.min(Math.max(position, 0), len)
       : Math.max(position, 0)
     this.position = clamped
-    this.batchUpdatePlayer({ position: clamped }, true).catch(() => {})
+    this.batchUpdatePlayer({ position: clamped }, true).catch((error) =>
+      reportSuppressedError(this, 'player.seek', error, {
+        guildId: this.guildId,
+        position: clamped
+      })
+    )
     return this
   }
 
@@ -678,15 +800,32 @@ class Player extends EventEmitter {
     this.batchUpdatePlayer(
       { track: { encoded: null }, paused: this.paused },
       true
-    ).catch(() => {})
+    ).catch((error) =>
+      reportSuppressedError(this, 'player.stop', error, {
+        guildId: this.guildId
+      })
+    )
     return this
   }
 
   setVolume(volume) {
+    if (
+      volume == null ||
+      (typeof volume !== 'number' && typeof volume !== 'string')
+    ) {
+      throw new TypeError(
+        `Player.setVolume(): volume must be a number, got ${typeof volume}`
+      )
+    }
     const vol = _functions.clamp(volume)
     if (this.destroyed || this.volume === vol) return this
     this.volume = vol
-    this.batchUpdatePlayer({ volume: vol }).catch(() => {})
+    this.batchUpdatePlayer({ volume: vol }).catch((error) =>
+      reportSuppressedError(this, 'player.setVolume', error, {
+        guildId: this.guildId,
+        volume: vol
+      })
+    )
     return this
   }
 
@@ -703,7 +842,6 @@ class Player extends EventEmitter {
     const id = _functions.toId(channel)
     if (!id) throw new TypeError('Invalid text channel')
     this.textChannel = id
-    this.batchUpdatePlayer({ text_channel: id }).catch(() => {})
     return this
   }
 
@@ -739,7 +877,31 @@ class Player extends EventEmitter {
   replay() {
     return this.seek(0)
   }
-  skip() {
+  skip(target) {
+    if (this.destroyed || !this.playing) return this
+
+    if (target === undefined || target === null) return this.stop()
+
+    if (typeof target === 'number') {
+      const idx = target | 0
+      if (idx <= 0) return this.stop()
+      if (!this.queue?.size || idx >= this.queue.size) return this.stop()
+      for (let i = 0; i < idx; i++) this.queue.dequeue()
+      return this.stop()
+    }
+
+    const targetId = _functions.toId(target)
+    if (targetId && this.queue?.size) {
+      const arr = this.queue.toArray()
+      const idx = arr.findIndex(
+        (t) =>
+          _functions.toId(t) === targetId ||
+          _functions.toId(t?.info?.identifier) === targetId
+      )
+      if (idx > 0) {
+        for (let i = 0; i < idx; i++) this.queue.dequeue()
+      }
+    }
     return this.stop()
   }
 
@@ -835,8 +997,8 @@ class Player extends EventEmitter {
         }
       } catch (err) {
         if (this.destroyed) return this
-        this.aqua?.emit(
-          AqualinkEvents.Error,
+        _functions.emitAquaError(
+          this.aqua,
           new Error(`Autoplay ${i + 1} fail: ${err.message}`)
         )
       }
@@ -858,7 +1020,7 @@ class Player extends EventEmitter {
   }
 
   async _getAutoplayTrack(sourceName, identifier, uri, requester) {
-    if (sourceName === 'youtube') {
+    if (sourceName === 'youtube' || sourceName === 'ytmusic') {
       const res = await this.aqua.resolve({
         query: `https://www.youtube.com/watch?v=${identifier}&list=RD${identifier}`,
         source: 'ytmsearch',
@@ -915,6 +1077,7 @@ class Player extends EventEmitter {
     const isReplaced = reason === 'replaced'
 
     if (track) this.previousTracks.push(track)
+    if (isReplaced) return
     if (this.shouldDeleteMessage && !this._reconnecting && !this._resuming)
       _functions.safeDel(this.nowPlayingMessage)
     if (!isReplaced) this.current = null
@@ -930,12 +1093,15 @@ class Player extends EventEmitter {
       return
     }
 
-    if (
-      track &&
-      reason === 'finished' &&
-      (this.loop === LOOP_MODES.TRACK || this.loop === LOOP_MODES.QUEUE)
-    ) {
-      this.queue.add(track)
+    if (track && reason === 'finished') {
+      if (this.loop === LOOP_MODES.TRACK) {
+        this.aqua.emit(AqualinkEvents.TrackEnd, this, track, reason)
+        await this.play(track)
+        return
+      }
+      if (this.loop === LOOP_MODES.QUEUE) {
+        this.queue.add(track)
+      }
     }
 
     if (this.queue.size) {
@@ -1006,171 +1172,28 @@ class Player extends EventEmitter {
     _functions.emitIfActive(this, AqualinkEvents.MixEnded, t, payload)
   }
 
-  async _attemptVoiceResume() {
-    if (!this.connection?.sessionId) throw new Error('No session')
-    if (!(await this.connection.attemptResume()))
-      throw new Error('Resume failed')
+  async _attemptVoiceResume(abortSignal) {
+    return this._lifecycleController.attemptVoiceResume(abortSignal)
   }
 
   async socketClosed(_player, _track, payload) {
-    if (this.destroyed || this._reconnecting) return
-    this.aqua?._trace?.('player.socketClosed', {
-      guildId: this.guildId,
-      code: payload?.code
-    })
-
-    const code = payload?.code
-    if (code === 4006 && this._resuming) {
-      this.aqua?._trace?.('player.socketClosed.ignored', {
-        guildId: this.guildId,
-        code,
-        reason: 'transient_while_resuming'
-      })
-      return
-    }
-
-    let isRecoverable = [4015, 4009, 4006, 4014, 4022].includes(code)
-    if (code === 4014 && this.connection?.isWaitingForDisconnect)
-      isRecoverable = false
-
-    if (code === 4015 && !this.nodes?.info?.isNodelink) {
-      this._reconnecting = true
-      try {
-        await this._attemptVoiceResume()
-        this._reconnecting = false
-        return
-      } catch {
-        this._reconnecting = false
-      }
-    }
-
-    if (!isRecoverable) {
-      this.aqua.emit(AqualinkEvents.SocketClosed, this, payload)
-      this.destroy()
-      return
-    }
-
-    if (code === 4014 || code === 4022) {
-      this.connected = false
-      if (!this._voiceDownSince) this._voiceDownSince = Date.now()
-      if (code === 4022) this._suppressResumeUntil = Date.now() + 3000
-    }
-
-    const aqua = this.aqua
-    const vcId = _functions.toId(this.voiceChannel)
-    const tcId = _functions.toId(this.textChannel)
-    const { guildId, deaf, mute } = this
-
-    if (!vcId) {
-      aqua?.emit?.(AqualinkEvents.SocketClosed, this, payload)
-      return
-    }
-
-    const state = {
-      volume: this.volume,
-      position: this.position,
-      paused: this.paused,
-      loop: this.loop,
-      isAutoplayEnabled: this.isAutoplayEnabled,
-      currentTrack: this.current,
-      queue: this.queue?.toArray() || [],
-      previousIdentifiers: Array.from(this.previousIdentifiers),
-      autoplaySeed: this.autoplaySeed,
-      nowPlayingMessage: this.nowPlayingMessage
-    }
-
-    this._reconnecting = true
-    this.destroy({
-      preserveClient: true,
-      skipRemote: true,
-      preserveMessage: true,
-      preserveReconnecting: true,
-      preserveTracks: true
-    })
-
-    // Store reconnect timers on instance for cleanup in destroy()
-    this._reconnectTimers = new Set()
-    const reconnectTimers = this._reconnectTimers
-    const tryReconnect = async (attempt) => {
-      if (aqua?.destroyed) {
-        _functions.clearTimers(reconnectTimers)
-        return
-      }
-      try {
-        const np = await aqua.createConnection({
-          guildId,
-          voiceChannel: vcId,
-          textChannel: tcId,
-          deaf,
-          mute,
-          defaultVolume: state.volume,
-          preserveMessage: true,
-          resuming: true
-        })
-        if (!np) throw new Error('Failed to create player')
-
-        np.reconnectionRetries = 0
-        np.loop = state.loop
-        np.isAutoplayEnabled = state.isAutoplayEnabled
-        np.autoplaySeed = state.autoplaySeed
-        np.previousIdentifiers = new Set(state.previousIdentifiers)
-        np.nowPlayingMessage = state.nowPlayingMessage
-
-        const ct = state.currentTrack
-        if (ct) np.queue.add(ct)
-        for (const q of state.queue) if (q !== ct) np.queue.add(q)
-
-        if (ct) {
-          await np.play()
-          if (state.position > 5000)
-            np._createTimer(
-              () => !np.destroyed && np.seek(state.position),
-              SEEK_DELAY
-            )
-          if (state.paused)
-            np._createTimer(() => !np.destroyed && np.pause(true), PAUSE_DELAY)
-        }
-
-        _functions.clearTimers(reconnectTimers)
-        this._reconnecting = false
-        aqua.emit(AqualinkEvents.PlayerReconnected, np, {
-          oldPlayer: this,
-          restoredState: state
-        })
-      } catch (error) {
-        const retriesLeft = RECONNECT_MAX - attempt
-        aqua.emit(AqualinkEvents.ReconnectionFailed, this, {
-          error,
-          code,
-          payload,
-          retriesLeft
-        })
-
-        if (retriesLeft > 0) {
-          _functions.createTimer(
-            () => tryReconnect(attempt + 1),
-            Math.min(RETRY_BACKOFF_BASE * attempt, RETRY_BACKOFF_MAX),
-            reconnectTimers
-          )
-        } else {
-          _functions.clearTimers(reconnectTimers)
-          this._reconnecting = false
-          aqua.emit(AqualinkEvents.SocketClosed, this, payload)
-        }
-      }
-    }
-
-    tryReconnect(1)
+    return this._lifecycleController.socketClosed(_player, _track, payload)
   }
 
   send(data) {
     try {
-      this.aqua.send({ op: 4, d: data })
+      if (this.aqua?.queueVoiceStateUpdate) {
+        return this.aqua.queueVoiceStateUpdate(data)
+      } else {
+        this.aqua.send({ op: 4, d: data })
+        return true
+      }
     } catch (err) {
-      this.aqua.emit(
-        AqualinkEvents.Error,
-        new Error(`Send fail: ${err.message}`)
+      _functions.emitAquaError(
+        this.aqua,
+        new Error(`Send fail (guild=${this.guildId}): ${err.message}`)
       )
+      return false
     }
   }
 
@@ -1203,24 +1226,7 @@ class Player extends EventEmitter {
   }
 
   _flushDeferredPlay() {
-    if (
-      !this._deferredStart ||
-      this.destroyed ||
-      !this.current?.track ||
-      !this._updateBatcher
-    )
-      return
-    this._deferredStart = false
-    const updateData = {
-      track: { encoded: this.current.track },
-      paused: this.paused
-    }
-    if (this.position > 0) updateData.position = this.position
-    this.aqua?._trace?.('player.play.deferred.flush', {
-      guildId: this.guildId,
-      hasEndpoint: !!this.connection?.endpoint
-    })
-    this.batchUpdatePlayer(updateData, true).catch(() => {})
+    return this._lifecycleController.flushDeferredPlay()
   }
 
   cleanup() {