ziplayer 0.3.1 → 0.3.3

package/dist/structures/Player.js

@@ -4,11 +4,13 @@ exports.Player = void 0;
 const events_1 = require("events");
 const voice_1 = require("@discordjs/voice");
 const lru_cache_1 = require("lru-cache");
+const types_1 = require("../types");
 const Queue_1 = require("./Queue");
 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.
  *
@@ -52,6 +54,7 @@ class Player extends events_1.EventEmitter {
         this.volume = 100;
         this.isPlaying = false;
         this.isPaused = false;
+        this.forwardMode = false;
         this._lastActivity = Date.now();
         this.leaveTimeout = null;
         this.currentResource = null;
@@ -59,16 +62,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 +71,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 +105,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 +147,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;
         }
@@ -199,18 +183,27 @@ class Player extends events_1.EventEmitter {
         this.loudnessMaxCutDb = Math.max(0, loudnessOptions.maxCutDb ?? 10);
         this.loudnessLimiterCeiling = Math.min(1, Math.max(0.1, loudnessOptions.limiterCeiling ?? 0.95));
         this.debug(`[Player] Runtime options resolved: lowPerformance=${this.lowPerformanceMode}, preload=${this.preloadEnabled}, crossfade=${this.crossfadeEnabled} (${this.crossfadeDurationMs}ms), smartTransition=${this.smartTransitionEnabled}, antiStuck=${this.antiStuckEnabled}, loudnessNormalization=${this.loudnessNormalizationEnabled}`);
+        this.trackMiddlewareChain = [...this.manager.getTrackMiddlewareChain(), ...(0, types_1.normalizeTrackMiddleware)(options.trackMiddleware)];
         this.filter = new FilterManager_1.FilterManager(this, this.manager);
         this.extensionManager = new extensions_1.ExtensionManager(this, this.manager);
         this.pluginManager = new plugins_1.PluginManager(this, this.manager, {
             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 +488,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 +521,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 +659,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 +688,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 +725,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
@@ -1097,7 +775,37 @@ class Player extends events_1.EventEmitter {
             }
         }
     }
+    mergeTrackPreserveRef(target, source) {
+        if (source === target)
+            return;
+        const mergedMeta = {
+            ...(target.metadata || {}),
+            ...(source.metadata || {}),
+        };
+        Object.assign(target, source);
+        target.metadata = mergedMeta;
+    }
+    async applyTrackMiddleware(track) {
+        if (this.trackMiddlewareChain.length === 0)
+            return;
+        const ctx = { player: this, manager: this.manager };
+        for (const mw of this.trackMiddlewareChain) {
+            try {
+                const out = await mw(track, ctx);
+                if (out != null && out !== track) {
+                    this.mergeTrackPreserveRef(track, out);
+                }
+            }
+            catch (err) {
+                this.debug(`[TrackMiddleware] Error:`, err);
+            }
+        }
+    }
     async getStream(track) {
+        if (this.destroyed) {
+            throw new Error("PLAYER_DESTROYED");
+        }
+        await this.applyTrackMiddleware(track);
         const trackId = track.id || track.url || track.title;
         const existingStream = this.streamManager.getStreamByTrack(trackId);
         if (existingStream && !existingStream.destroyed) {
@@ -1105,17 +813,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,12 +838,7 @@ 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)) {
@@ -1146,12 +855,11 @@ class Player extends events_1.EventEmitter {
      * 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);
@@ -1200,12 +908,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)
@@ -1249,6 +955,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 {
@@ -1286,9 +994,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) {
@@ -1300,6 +1010,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
@@ -1311,6 +1023,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;
                     }
                 }
@@ -1398,6 +1118,7 @@ class Player extends events_1.EventEmitter {
             if (!this.connection)
                 throw new Error("No voice connection for TTS");
             const ttsPlayer = this.ensureTTSPlayer();
+            await this.applyTrackMiddleware(track);
             // Build resource from plugin stream
             const streamInfo = await this.pluginManager.getStream(track);
             if (!streamInfo) {
@@ -1515,6 +1236,54 @@ class Player extends events_1.EventEmitter {
             throw error;
         }
     }
+    /**
+     * Subscribe this player's voice connection
+     * to another player's audio stream.
+     *
+     * This is primarily used for:
+     * - playback mirroring
+     * - radio/broadcast systems
+     * - multi-guild synchronized playback
+     * - forwardMode shared streaming
+     *
+     * Instead of creating a separate audio stream,
+     * this player will directly receive audio packets
+     * from the target player's AudioPlayer instance.
+     *
+     * Benefits:
+     * - drastically lower CPU usage
+     * - only one ffmpeg/extractor stream
+     * - lower bandwidth and memory usage
+     * - perfect sync across guilds
+     *
+     * Important:
+     * - both players must already have active voice connections
+     * - this does NOT transfer queue ownership
+     * - this does NOT clone playback state automatically
+     *
+     * @param {Player} player - Source player to subscribe to
+     *
+     * @returns {boolean}
+     * Returns true if subscription succeeded,
+     * otherwise false.
+     *
+     * @example
+     * follower.subscribeTo(leader);
+     *
+     * @example
+     * if (!player.subscribeTo(leader)) {
+     *   console.log("Failed to subscribe");
+     * }
+     */
+    subscribeTo(player) {
+        if (!this.connection)
+            return false;
+        this.connection.subscribe(player.audioPlayer);
+        this.isPlaying = player.isPlaying;
+        this.isPaused = player.isPaused;
+        this.forwardMode = true;
+        return true;
+    }
     /**
      * Pause the current track
      *
@@ -1702,6 +1471,7 @@ class Player extends events_1.EventEmitter {
             saveOptions = options;
         }
         try {
+            await this.applyTrackMiddleware(track);
             // Skip extension manager for saving - we want the raw stream without filters/seek applied, and extensions may not support this
             let streamInfo = await this.pluginManager.getStream(track);
             if (!streamInfo || !streamInfo.stream) {
@@ -2061,6 +1831,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;
@@ -2069,10 +1842,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);
@@ -2230,6 +2003,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
@@ -2238,7 +2013,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)) {
@@ -2300,18 +2075,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) {