ziplayer 0.3.0 → 0.3.2

package/dist/structures/Player.js

@@ -9,6 +9,7 @@ const plugins_1 = require("../plugins");
 const extensions_1 = require("../extensions");
 const FilterManager_1 = require("./FilterManager");
 const StreamManager_1 = require("./StreamManager");
+const PreloadManager_1 = require("./PreloadManager");
 /**
  * Represents a music player for a specific Discord guild.
  *
@@ -59,16 +60,6 @@ class Player extends events_1.EventEmitter {
         this.stuckTimer = null;
         this.skipLoop = false;
         this.refreshLock = false;
-        //preloaded resource
-        this.preloadState = {
-            resource: null,
-            track: null,
-            abortController: null,
-            timeoutId: null,
-            isValid: false,
-            isBeingUsed: false,
-        };
-        this.isPreloading = false;
         this.currentSlot = {
             resource: null,
             track: null,
@@ -78,16 +69,6 @@ class Player extends events_1.EventEmitter {
             isLoading: false,
             loadPromise: null,
         };
-        this.preloadSlot = {
-            resource: null,
-            track: null,
-            streamId: null,
-            abortController: null,
-            isValid: false,
-            isLoading: false,
-            loadPromise: null,
-        };
-        this.preloadLock = false;
         this.preloadEnabled = true;
         this.crossfadeEnabled = true;
         this.crossfadeDurationMs = 500;
@@ -122,6 +103,7 @@ class Player extends events_1.EventEmitter {
         this.loudnessMaxBoostDb = 8;
         this.loudnessMaxCutDb = 10;
         this.loudnessLimiterCeiling = 0.95;
+        this.destroyed = false;
         this.SEARCH_CACHE_TTL = 2 * 60 * 1000; // 2 minutes
         this.ttsPlayer = null;
         this.lastDuration = 0;
@@ -163,7 +145,7 @@ class Player extends events_1.EventEmitter {
         const crossfadeOptions = this.options.crossfade || {};
         const crossfadeAutoEnable = crossfadeOptions.autoEnable ?? true;
         const crossfadeAutoDisable = crossfadeOptions.autoDisableInLowPerformance ?? true;
-        this.crossfadeDurationMs = Math.max(0, crossfadeOptions.durationMs ?? 5000);
+        this.crossfadeDurationMs = Math.max(0, crossfadeOptions.durationMs ?? 500);
         if (typeof crossfadeOptions.enabled === "boolean") {
             this.crossfadeEnabled = crossfadeOptions.enabled;
         }
@@ -205,12 +187,20 @@ class Player extends events_1.EventEmitter {
             extractorTimeout: this.options.extractorTimeout,
         });
         this.streamManager = new StreamManager_1.StreamManager({
-            maxConcurrentStreams: 20,
+            maxConcurrentStreams: 2,
             streamTimeout: 5 * 60 * 1000,
             maxListenersPerStream: 15,
             enableMetrics: true,
             autoDestroy: true,
         });
+        this.preloadManager = new PreloadManager_1.PreloadManager({
+            streamManager: this.streamManager,
+            debug: this.debug.bind(this),
+            getNextTrack: () => this.queue.nextTrack,
+            getStream: (track) => this.getStream(track),
+            isDestroyed: () => this.destroyed,
+            isEnabled: () => this.preloadEnabled,
+        });
         this.volume = this.options.volume || 100;
         this.userdata = this.options.userdata;
         this.searchCache = new lru_cache_1.LRUCache({
@@ -495,6 +485,9 @@ class Player extends events_1.EventEmitter {
                 this.queue.add(tracksToAdd[0]);
                 this.emit("queueAdd", tracksToAdd[0]);
             }
+            if (this.isPlaying && !this.destroyed) {
+                void this.preloadNextTrack().catch((err) => this.debug("[Player] Preload after queue add error:", err));
+            }
             const started = !this.isPlaying ? await this.playNext() : true;
             await this.extensionManager.afterPlayHooks({
                 success: started,
@@ -525,273 +518,20 @@ class Player extends events_1.EventEmitter {
      * Main preload method - only one at a time
      */
     async preloadNextTrack() {
-        if (!this.preloadEnabled) {
-            this.debug(`[Preload] Disabled by options/runtime profile`);
-            return;
-        }
-        // Prevent concurrent preloads
-        if (this.preloadLock) {
-            this.debug(`[Preload] Already preloading, skipping`);
-            return;
-        }
-        const nextTrack = this.queue.nextTrack;
-        if (!nextTrack) {
-            this.debug(`[Preload] No next track to preload`);
-            return;
-        }
-        // Check if already preloaded correctly
-        if (this.preloadSlot.isValid && this.preloadSlot.track?.id === nextTrack.id && this.preloadSlot.resource) {
-            this.debug(`[Preload] Already have valid preload for: ${nextTrack.title}`);
-            return;
-        }
-        // Check if currently loading the same track
-        if (this.preloadSlot.isLoading && this.preloadSlot.track?.id === nextTrack.id) {
-            this.debug(`[Preload] Currently loading same track, waiting...`);
-            if (this.preloadSlot.loadPromise) {
-                await this.preloadSlot.loadPromise;
-            }
-            return;
-        }
-        // Cancel old preload if different track
-        if (this.preloadSlot.isValid && this.preloadSlot.track?.id !== nextTrack.id) {
-            this.debug(`[Preload] Cancelling old preload for different track: ${this.preloadSlot.track?.title}`);
-            await this.safeCancelPreload();
-        }
-        this.preloadLock = true;
-        // Create new abort controller
-        const abortController = new AbortController();
-        // Setup preload slot
-        this.preloadSlot.track = nextTrack;
-        this.preloadSlot.abortController = abortController;
-        this.preloadSlot.isLoading = true;
-        // Create load promise
-        const loadPromise = this.executePreload(nextTrack, abortController);
-        this.preloadSlot.loadPromise = loadPromise;
-        try {
-            await loadPromise;
-        }
-        catch (err) {
-            if (err instanceof Error && err.message === "PRELOAD_CANCELLED") {
-                this.debug(`[Preload] Cancelled for ${nextTrack.title}`);
-            }
-            else {
-                this.debug(`[Preload] Failed for ${nextTrack.title}:`, err);
-            }
-            this.clearSlot(this.preloadSlot);
-        }
-        finally {
-            this.preloadLock = false;
-            this.preloadSlot.isLoading = false;
-            this.preloadSlot.loadPromise = null;
-        }
-    }
-    /**
-     * Execute actual preload
-     */
-    async executePreload(track, abortController) {
-        this.debug(`[Preload] Starting preload for: ${track.title}`);
-        // Check for cancellation
-        if (abortController.signal.aborted) {
-            throw new Error("PRELOAD_CANCELLED");
-        }
-        // Check if track still relevant
-        if (this.queue.nextTrack?.id !== track.id) {
-            this.debug(`[Preload] Track changed, cancelling`);
-            throw new Error("PRELOAD_CANCELLED");
-        }
-        try {
-            // Get stream with abort support - NO TIMEOUT
-            const streamInfo = await this.getStreamWithCancel(track, abortController.signal);
-            // Check cancellation
-            if (abortController.signal.aborted) {
-                throw new Error("PRELOAD_CANCELLED");
-            }
-            // Check track relevance again
-            if (this.queue.nextTrack?.id !== track.id) {
-                this.debug(`[Preload] Track changed after stream fetch`);
-                throw new Error("PRELOAD_CANCELLED");
-            }
-            if (!streamInfo?.stream) {
-                throw new Error(`No stream available`);
-            }
-            // Register with StreamManager as preload
-            const streamId = this.streamManager.registerStream(streamInfo.stream, track, {
-                source: track.source || "preload",
-                isPreload: true,
-                priority: 5,
-            });
-            // Create resource
-            const resource = (0, voice_1.createAudioResource)(streamInfo.stream, {
-                inlineVolume: true,
-                metadata: { ...track, preloaded: true },
-            });
-            // Verify resource is valid
-            if (!resource.playStream || resource.playStream.readable === false) {
-                throw new Error("Resource not readable");
-            }
-            // Update preload slot
-            this.preloadSlot.resource = resource;
-            this.preloadSlot.streamId = streamId;
-            this.preloadSlot.isValid = true;
-            this.preloadSlot.track = track;
-            this.debug(`[Preload] Successfully preloaded: ${track.title} (Stream ID: ${streamId})`);
-        }
-        catch (err) {
-            if (err instanceof Error && err.message === "PRELOAD_CANCELLED") {
-                throw err;
-            }
-            this.debug(`[Preload] Error during preload:`, err);
-            throw err;
-        }
+        await this.preloadManager.preloadNextTrack();
     }
     /**
      * Safe cancel preload - doesn't throw
      */
     async safeCancelPreload() {
-        if (!this.preloadSlot.abortController && !this.preloadSlot.resource) {
-            return;
-        }
-        this.debug(`[Preload] Safely cancelling preload for: ${this.preloadSlot.track?.title || "unknown"}`);
-        // Abort the operation
-        if (this.preloadSlot.abortController) {
-            this.preloadSlot.abortController.abort();
-            this.preloadSlot.abortController = null;
-        }
-        // Clean up stream
-        if (this.preloadSlot.streamId && this.streamManager) {
-            this.streamManager.unregisterStream(this.preloadSlot.streamId, true);
-        }
-        // Clean up resource
-        if (this.preloadSlot.resource) {
-            try {
-                const stream = this.preloadSlot.resource.playStream;
-                if (stream && typeof stream.destroy === "function" && !stream.destroyed) {
-                    stream.destroy();
-                }
-            }
-            catch (err) {
-                // Ignore destroy errors
-            }
-        }
-        // Clear slot
-        this.clearSlot(this.preloadSlot);
-    }
-    /**
-     * Get stream with proper cancellation
-     */
-    async getStreamWithCancel(track, signal) {
-        // Create abort promise
-        const abortPromise = new Promise((_, reject) => {
-            if (signal.aborted) {
-                reject(new Error("PRELOAD_CANCELLED"));
-                return;
-            }
-            const handler = () => {
-                signal.removeEventListener("abort", handler);
-                reject(new Error("PRELOAD_CANCELLED"));
-            };
-            signal.addEventListener("abort", handler);
-        });
-        try {
-            // Check if stream already exists and is valid
-            const existingStream = this.streamManager.getStreamByTrack(track.id || track.title);
-            if (existingStream && !existingStream.destroyed && existingStream.readable !== false) {
-                this.debug(`[Stream] Using existing stream for preload: ${track.title}`);
-                return { stream: existingStream, type: "arbitrary" };
-            }
-            // Race between stream fetch and abort
-            const streamPromise = this.getStream(track);
-            const result = await Promise.race([streamPromise, abortPromise]);
-            return result;
-        }
-        catch (err) {
-            if (err instanceof Error && err.message === "PRELOAD_CANCELLED") {
-                throw err;
-            }
-            throw err;
-        }
+        await this.preloadManager.safeCancelPreload();
     }
+    // Preload stream fetch/cancel flow has been moved to PreloadManager.
     /**
      * Preload next track with proper error handling and cleanup
      */
     async preloadNext() {
-        if (!this.preloadEnabled) {
-            this.debug(`[Preload] Disabled by options/runtime profile`);
-            return;
-        }
-        this.cancelPreload();
-        const next = this.queue.nextTrack;
-        if (!next || this.isPreloading) {
-            this.debug(`[Preload] Skipped - ${!next ? "no next track" : "already preloading"}`);
-            return;
-        }
-        this.isPreloading = true;
-        // Create new AbortController
-        const abortController = new AbortController();
-        const timeoutId = setTimeout(() => {
-            // this.debug(`[Preload] Timeout for track: ${next.title}`);
-            // abortController.abort();
-        }, 30000);
-        this.preloadState.abortController = abortController;
-        this.preloadState.timeoutId = timeoutId;
-        try {
-            this.debug(`[Preload] Starting preload for: ${next.title}`);
-            // Check if already aborted
-            if (abortController.signal.aborted) {
-                throw new Error("Preload aborted before start");
-            }
-            // Check if this track is still the next one
-            if (this.queue.nextTrack?.id !== next.id) {
-                this.debug(`[Preload] Track changed, cancelling preload`);
-                return;
-            }
-            const streamInfo = await this.getStreamWithCancel(next, abortController.signal);
-            // Double check
-            if (abortController.signal.aborted) {
-                throw new Error("Preload aborted after stream fetch");
-            }
-            if (this.queue.nextTrack?.id !== next.id) {
-                this.debug(`[Preload] Track changed after stream fetch`);
-                return;
-            }
-            if (!streamInfo?.stream) {
-                throw new Error(`No stream available`);
-            }
-            // Register with StreamManager
-            const streamId = this.streamManager.registerStream(streamInfo.stream, next, {
-                source: next.source || "preload",
-                isPreload: true,
-                priority: 8,
-            });
-            // Create resource
-            const resource = (0, voice_1.createAudioResource)(streamInfo.stream, {
-                inlineVolume: true,
-                metadata: { ...next, preloaded: true },
-            });
-            // Store preload state
-            this.preloadState = {
-                resource,
-                track: next,
-                abortController,
-                timeoutId,
-                isValid: true,
-                isBeingUsed: false,
-                streamId,
-            };
-            this.debug(`[Preload] Successfully preloaded: ${next.title} (Stream ID: ${streamId})`);
-        }
-        catch (err) {
-            if (err instanceof Error && err.message.includes("aborted")) {
-                this.debug(`[Preload] Cancelled for ${next.title}`);
-            }
-            else {
-                this.debug(`[Preload] Failed for ${next?.title}:`, err);
-            }
-            this.cancelPreload();
-        }
-        finally {
-            this.isPreloading = false;
-        }
+        await this.preloadManager.preloadNextTrack();
     }
     async fadeResourceVolume(resource, from, to, durationMs) {
         if (!resource.volume)
@@ -916,7 +656,7 @@ class Player extends events_1.EventEmitter {
                 await new Promise((resolve) => setTimeout(resolve, this.antiStuckRetryDelayMs));
             }
             try {
-                if (this.antiStuckReusePreloadFirst && this.preloadSlot.isValid && this.preloadSlot.track?.id === track.id) {
+                if (this.antiStuckReusePreloadFirst && this.preloadManager.hasValidPreload(track)) {
                     const startedFromPreload = await this.startTrack(track);
                     if (startedFromPreload) {
                         this.antiStuckConsecutiveFailures = 0;
@@ -945,59 +685,11 @@ class Player extends events_1.EventEmitter {
         this.debug(`[AntiStuck] Keeping track for controlled retry window: ${track.title}`);
         return false;
     }
-    /**
-     * Clear preloaded resource with proper cleanup
-     */
-    clearPreload() {
-        // Abort ongoing preload
-        if (this.preloadState.abortController) {
-            this.preloadState.abortController.abort();
-            this.preloadState.abortController = null;
-        }
-        // Clean up stream
-        const stream = this.preloadState.stream;
-        if (stream && typeof stream.destroy === "function") {
-            try {
-                stream.destroy();
-            }
-            catch (err) {
-                this.debug(`[Preload] Error destroying stream:`, err);
-            }
-        }
-        // Clean up resource
-        if (this.preloadState.resource) {
-            try {
-                const playStream = this.preloadState.resource.playStream;
-                if (playStream && typeof playStream.destroy === "function") {
-                    playStream.destroy();
-                }
-            }
-            catch (err) {
-                this.debug(`[Preload] Error destroying resource:`, err);
-            }
-        }
-        this.preloadState = {
-            resource: null,
-            track: null,
-            abortController: null,
-            timeoutId: null,
-            isValid: false,
-            isBeingUsed: false,
-            streamId: undefined,
-        };
-    }
     /**
      * Cancel preload (when skipping or stopping)
      */
     cancelPreload() {
-        if (this.preloadSlot.abortController) {
-            this.debug(`[Preload] Cancelling preload for: ${this.preloadSlot.track?.title}`);
-            this.preloadSlot.abortController.abort();
-        }
-        if (this.preloadSlot.streamId && this.streamManager) {
-            this.streamManager.unregisterStream(this.preloadSlot.streamId, true);
-        }
-        this.clearSlot(this.preloadSlot);
+        this.preloadManager.cancelPreload();
     }
     /**
      * Clear a stream slot
@@ -1030,25 +722,8 @@ class Player extends events_1.EventEmitter {
      * Promote preload slot to current slot without destroying promoted stream.
      */
     promotePreloadToCurrent(track) {
-        const promotedResource = this.preloadSlot.resource;
-        const promotedStreamId = this.preloadSlot.streamId;
-        // Move ownership to current slot.
-        this.currentSlot.resource = promotedResource;
-        this.currentSlot.track = track;
-        this.currentSlot.streamId = promotedStreamId;
-        this.currentSlot.abortController = null;
-        this.currentSlot.isValid = !!promotedResource;
-        this.currentSlot.isLoading = false;
-        this.currentSlot.loadPromise = null;
-        this.currentResource = promotedResource;
-        // Reset preload slot only (do not destroy promoted resource/stream).
-        this.preloadSlot.resource = null;
-        this.preloadSlot.track = null;
-        this.preloadSlot.streamId = null;
-        this.preloadSlot.abortController = null;
-        this.preloadSlot.isValid = false;
-        this.preloadSlot.isLoading = false;
-        this.preloadSlot.loadPromise = null;
+        const promoted = this.preloadManager.promoteToCurrent(track, this.currentSlot);
+        this.currentResource = promoted;
     }
     /**
      * Create AudioResource with filters and seek applied
@@ -1098,6 +773,9 @@ class Player extends events_1.EventEmitter {
         }
     }
     async getStream(track) {
+        if (this.destroyed) {
+            throw new Error("PLAYER_DESTROYED");
+        }
         const trackId = track.id || track.url || track.title;
         const existingStream = this.streamManager.getStreamByTrack(trackId);
         if (existingStream && !existingStream.destroyed) {
@@ -1105,17 +783,23 @@ class Player extends events_1.EventEmitter {
             return { stream: existingStream, type: "arbitrary" };
         }
         let stream = await this.extensionManager.provideStream(track);
+        if (this.destroyed) {
+            if (stream?.stream && typeof stream.stream.destroy === "function" && !stream.stream.destroyed) {
+                stream.stream.destroy();
+            }
+            throw new Error("PLAYER_DESTROYED");
+        }
         if (stream?.stream) {
-            // Register with StreamManager
-            const streamId = this.streamManager.registerStream(stream.stream, track, {
-                source: "extension",
-                isPreload: false,
-                priority: 10,
-            });
-            this.debug(`[Stream] Extension stream registered with ID: ${streamId}`);
+            this.debug(`[Stream] Extension provided stream for: ${track.title}`);
             return stream;
         }
         stream = await this.pluginManager.getStream(track);
+        if (this.destroyed) {
+            if (stream?.stream && typeof stream.stream.destroy === "function" && !stream.stream.destroyed) {
+                stream.stream.destroy();
+            }
+            throw new Error("PLAYER_DESTROYED");
+        }
         if (stream?.stream) {
             const existingAgain = this.streamManager.getStreamByTrack(trackId);
             if (existingAgain && !existingAgain.destroyed) {
@@ -1124,26 +808,28 @@ class Player extends events_1.EventEmitter {
                 return { stream: existingAgain, type: "arbitrary" };
             }
             // Register with StreamManager
-            const streamId = this.streamManager.registerStream(stream.stream, track, {
-                source: track.source || "plugin",
-                isPreload: false,
-                priority: 5,
-            });
-            this.debug(`[Stream] Plugin stream registered with ID: ${streamId}`);
+            this.debug(`[Stream] Plugin provided stream for: ${track.title}`);
             return stream;
         }
+        if (!this.pluginManager.hasStreamCandidate(track)) {
+            throw new Error(`UNRECOVERABLE_NO_PLUGIN:${track.title}`);
+        }
         throw new Error(`No stream available for track: ${track.title}`);
     }
+    isUnrecoverableStreamError(error) {
+        if (!(error instanceof Error))
+            return false;
+        return error.message.startsWith("UNRECOVERABLE_NO_PLUGIN:");
+    }
     /**
      * Start playing a specific track immediately, replacing the current resource.
      */
     async startTrack(track) {
+        if (this.destroyed)
+            return false;
         try {
             // Try to use preloaded resource
-            if (this.preloadSlot.isValid &&
-                this.preloadSlot.track?.id === track.id &&
-                this.preloadSlot.resource &&
-                this.preloadSlot.resource.playStream?.readable !== false) {
+            if (this.preloadManager.hasValidPreload(track)) {
                 this.debug(`[Player] Using preloaded stream for: ${track.title}`);
                 // Stop current playback
                 this.audioPlayer.stop(true);
@@ -1192,12 +878,10 @@ class Player extends events_1.EventEmitter {
      * Swap preload slot to current slot
      */
     async swapToCurrent(track) {
-        // Store preload resource
-        const newResource = this.preloadSlot.resource;
-        const oldStreamId = this.currentSlot.streamId;
-        if (!newResource) {
+        if (!this.preloadManager.hasValidPreload(track)) {
             return false;
         }
+        const oldStreamId = this.currentSlot.streamId;
         // Stop current playback
         this.audioPlayer.stop(true);
         // Clean up old current stream (but keep it for a moment)
@@ -1241,6 +925,8 @@ class Player extends events_1.EventEmitter {
      * Load fresh stream when no preload available
      */
     async loadFreshStream(track) {
+        if (this.destroyed)
+            return false;
         // Cancel preload to free resources
         await this.safeCancelPreload();
         try {
@@ -1278,9 +964,11 @@ class Player extends events_1.EventEmitter {
             await (0, voice_1.entersState)(this.audioPlayer, voice_1.AudioPlayerStatus.Playing, 10_000);
             await this.applyCrossfadeIn(resource, track);
             // Preload next (async)
-            this.preloadNextTrack().catch((err) => {
-                this.debug(`[Player] Preload error:`, err);
-            });
+            if (!this.destroyed) {
+                this.preloadNextTrack().catch((err) => {
+                    this.debug(`[Player] Preload error:`, err);
+                });
+            }
             return true;
         }
         catch (error) {
@@ -1292,6 +980,8 @@ class Player extends events_1.EventEmitter {
      * Play the next track in the queue, handling errors and edge cases gracefully
      */
     async playNext() {
+        if (this.destroyed)
+            return false;
         this.debug("[Player] playNext called");
         // Don't cancel preload here unless absolutely necessary
         // Let startTrack handle it
@@ -1303,6 +993,14 @@ class Player extends events_1.EventEmitter {
                     const willnext = this.queue.willNextTrack();
                     if (willnext) {
                         this.queue.addMultiple([willnext]);
+                        void this.preloadNextTrack().catch((err) => this.debug("[Player] Preload autoplay error:", err));
+                        continue;
+                    }
+                    await this.generateWillNext().catch((err) => this.debug("[Player] generateWillNext autoplay fallback error:", err));
+                    const generatedNext = this.queue.willNextTrack();
+                    if (generatedNext) {
+                        this.queue.add(generatedNext);
+                        void this.preloadNextTrack().catch((err) => this.debug("[Player] Preload autoplay generated error:", err));
                         continue;
                     }
                 }
@@ -1340,6 +1038,10 @@ class Player extends events_1.EventEmitter {
             catch (err) {
                 this.debug(`[Player] playNext error:`, err);
                 this.emit("playerError", err, track);
+                if (this.isUnrecoverableStreamError(err)) {
+                    this.debug(`[Player] Skipping unrecoverable track (no plugin): ${track.title}`);
+                    continue;
+                }
                 const recovered = await this.attemptTrackRecovery(track, err);
                 if (recovered) {
                     return true;
@@ -2049,6 +1751,9 @@ class Player extends events_1.EventEmitter {
      */
     destroy() {
         this.debug(`[Player] destroy called`);
+        if (this.destroyed)
+            return;
+        this.destroyed = true;
         if (this.leaveTimeout) {
             clearTimeout(this.leaveTimeout);
             this.leaveTimeout = null;
@@ -2057,10 +1762,10 @@ class Player extends events_1.EventEmitter {
         // Destroy current stream before stopping audio
         this.destroyCurrentStream();
         this.clearSlot(this.currentSlot);
-        this.clearSlot(this.preloadSlot);
+        this.preloadManager.clearPreloadSlot();
         this.audioPlayer.removeAllListeners();
         this.audioPlayer.stop(true);
-        this.clearPreload();
+        this.preloadManager.cancelPreload();
         if (this.ttsPlayer) {
             try {
                 this.ttsPlayer.stop(true);
@@ -2218,6 +1923,8 @@ class Player extends events_1.EventEmitter {
     }
     setupEventListeners() {
         this.audioPlayer.on("stateChange", (oldState, newState) => {
+            if (this.destroyed)
+                return;
             this.debug(`[Player] AudioPlayer stateChange from ${oldState.status} to ${newState.status}`);
             if (newState.status === voice_1.AudioPlayerStatus.Idle && oldState.status !== voice_1.AudioPlayerStatus.Idle) {
                 // Track ended
@@ -2226,7 +1933,7 @@ class Player extends events_1.EventEmitter {
                     this.debug(`[Player] Track ended: ${track.title}`);
                     this.emit("trackEnd", track);
                 }
-                this.playNext();
+                void this.playNext();
             }
             else if (newState.status === voice_1.AudioPlayerStatus.Playing &&
                 (oldState.status === voice_1.AudioPlayerStatus.Idle || oldState.status === voice_1.AudioPlayerStatus.Buffering)) {
@@ -2288,18 +1995,20 @@ class Player extends events_1.EventEmitter {
             }
         });
         this.audioPlayer.on("error", (error) => {
+            if (this.destroyed)
+                return;
             this.debug(`[Player] AudioPlayer error:`, error);
             this.emit("playerError", error, this.queue.currentTrack || undefined);
             const track = this.queue.currentTrack;
             if (track && this.antiStuckEnabled) {
                 void this.attemptTrackRecovery(track, error).then((recovered) => {
                     if (!recovered) {
-                        this.playNext();
+                        void this.playNext();
                     }
                 });
                 return;
             }
-            this.playNext();
+            void this.playNext();
         });
         this.audioPlayer.on("debug", (...args) => {
             if (this.manager.debugEnabled) {