ziplayer 0.3.3 → 0.3.5

package/dist/structures/Player.js

@@ -52,12 +52,14 @@ class Player extends events_1.EventEmitter {
         super();
         this.connection = null;
         this.volume = 100;
-        this.isPlaying = false;
-        this.isPaused = false;
-        this.forwardMode = false;
         this._lastActivity = Date.now();
-        this.leaveTimeout = null;
+        this._remotePaused = false;
         this.currentResource = null;
+        this.destroyed = false;
+        this.playbackMode = types_1.PlaybackMode.NATIVE;
+        this.forwardFollowers = new Set();
+        this.forwardLeader = null;
+        this.leaveTimeout = null;
         this.volumeInterval = null;
         this.stuckTimer = null;
         this.skipLoop = false;
@@ -105,7 +107,6 @@ 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;
@@ -378,6 +379,10 @@ class Player extends events_1.EventEmitter {
      * await player.play(null); // play from queue
      */
     async play(query, requestedBy) {
+        if (this.playbackMode === types_1.PlaybackMode.FORWARD) {
+            this.debug("[Player] Cannot play while subscribed to another player. Call unsubscribeForward() first.");
+            return false;
+        }
         const debugInfo = query === null ? "null"
             : typeof query === "string" ? query
                 : "tracks" in query ? `${query.tracks.length} tracks`
@@ -808,10 +813,12 @@ class Player extends events_1.EventEmitter {
         await this.applyTrackMiddleware(track);
         const trackId = track.id || track.url || track.title;
         const existingStream = this.streamManager.getStreamByTrack(trackId);
+        this.playbackMode = types_1.PlaybackMode.NATIVE;
         if (existingStream && !existingStream.destroyed) {
             this.debug(`[Stream] Using existing stream from manager for: ${track.title}`);
             return { stream: existingStream, type: "arbitrary" };
         }
+        // FIRST: Try to get stream from extensions
         let stream = await this.extensionManager.provideStream(track);
         if (this.destroyed) {
             if (stream?.stream && typeof stream.stream.destroy === "function" && !stream.stream.destroyed) {
@@ -819,10 +826,24 @@ class Player extends events_1.EventEmitter {
             }
             throw new Error("PLAYER_DESTROYED");
         }
+        // Handle remote playback - THIS SHOULD BE FIRST PRIORITY
+        if (stream?.remote && stream.handle) {
+            this.debug(`[Stream] Remote handle provided by extension for: ${track.title}`);
+            this.playbackMode = types_1.PlaybackMode.REMOTE;
+            this.preloadEnabled = false;
+            this.crossfadeEnabled = false;
+            // Clear any existing preload for remote mode
+            this.cancelPreload();
+            return stream;
+        }
+        // If extension returned a regular stream
         if (stream?.stream) {
             this.debug(`[Stream] Extension provided stream for: ${track.title}`);
+            this.playbackMode = types_1.PlaybackMode.NATIVE;
             return stream;
         }
+        // SECOND: Try plugins only if extension didn't handle it
+        this.debug(`[Stream] Extension didn't provide stream, trying plugins for: ${track.title}`);
         stream = await this.pluginManager.getStream(track);
         if (this.destroyed) {
             if (stream?.stream && typeof stream.stream.destroy === "function" && !stream.stream.destroyed) {
@@ -837,10 +858,11 @@ class Player extends events_1.EventEmitter {
                     stream.stream.destroy();
                 return { stream: existingAgain, type: "arbitrary" };
             }
-            // Register with StreamManager
             this.debug(`[Stream] Plugin provided stream for: ${track.title}`);
+            this.playbackMode = types_1.PlaybackMode.NATIVE;
             return stream;
         }
+        // Check if any plugin claims to support this track but failed
         if (!this.pluginManager.hasStreamCandidate(track)) {
             throw new Error(`UNRECOVERABLE_NO_PLUGIN:${track.title}`);
         }
@@ -857,13 +879,25 @@ class Player extends events_1.EventEmitter {
     async startTrack(track) {
         if (this.destroyed)
             return false;
+        // First, get stream info (this will handle remote detection)
+        let streamInfo = null;
+        try {
+            streamInfo = await this.getStream(track);
+        }
+        catch (error) {
+            this.debug(`[Player] Failed to get stream for track: ${track.title}`, error);
+            throw error;
+        }
+        // Handle remote playback
+        if (streamInfo?.remote && streamInfo.handle) {
+            return await this.playRemote(track, streamInfo);
+        }
+        // Handle native playback
         try {
             // Try to use preloaded resource
             if (this.preloadManager.hasValidPreload(track)) {
                 this.debug(`[Player] Using preloaded stream for: ${track.title}`);
-                // Stop current playback
                 this.audioPlayer.stop(true);
-                // Clean up old current stream (but delay to be safe)
                 const oldStreamId = this.currentSlot.streamId;
                 if (oldStreamId && this.streamManager) {
                     setTimeout(() => {
@@ -872,29 +906,24 @@ class Player extends events_1.EventEmitter {
                         }
                     }, 3000);
                 }
-                // Set current slot from preload
                 this.promotePreloadToCurrent(track);
                 const currentResource = this.currentSlot.resource;
                 if (!currentResource) {
                     return false;
                 }
                 const targetVolume = this.getTrackTargetVolume(track);
-                // Apply volume
                 if (currentResource.volume) {
                     currentResource.volume.setVolume(this.crossfadeEnabled ? 0 : targetVolume);
                 }
-                // Play
                 await this.maybeAlignToBeatBoundary();
                 this.audioPlayer.play(currentResource);
                 await (0, voice_1.entersState)(this.audioPlayer, voice_1.AudioPlayerStatus.Playing, 10_000);
                 await this.applyCrossfadeIn(currentResource, track);
-                // Start preloading next track (async, don't await)
                 this.preloadNextTrack().catch((err) => {
                     this.debug(`[Player] Preload error:`, err);
                 });
                 return true;
             }
-            // No valid preload, load fresh
             this.debug(`[Player] No preload available, loading fresh: ${track.title}`);
             return await this.loadFreshStream(track);
         }
@@ -904,53 +933,6 @@ class Player extends events_1.EventEmitter {
             return false;
         }
     }
-    /**
-     * Swap preload slot to current slot
-     */
-    async swapToCurrent(track) {
-        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)
-        if (oldStreamId && this.streamManager) {
-            // Delay cleanup to avoid destroying if still needed
-            setTimeout(() => {
-                if (this.currentSlot.streamId === oldStreamId) {
-                    this.streamManager.unregisterStream(oldStreamId, true);
-                }
-            }, 5000);
-        }
-        // Set new current
-        this.promotePreloadToCurrent(track);
-        const currentResource = this.currentSlot.resource;
-        if (!currentResource) {
-            return false;
-        }
-        const targetVolume = this.getTrackTargetVolume(track);
-        // Apply volume
-        if (currentResource.volume) {
-            currentResource.volume.setVolume(this.crossfadeEnabled ? 0 : targetVolume);
-        }
-        // Play
-        await this.maybeAlignToBeatBoundary();
-        this.audioPlayer.play(currentResource);
-        try {
-            await (0, voice_1.entersState)(this.audioPlayer, voice_1.AudioPlayerStatus.Playing, 10_000);
-            await this.applyCrossfadeIn(currentResource, track);
-            // Start preloading next track
-            this.preloadNextTrack().catch((err) => {
-                this.debug(`[Player] Preload error:`, err);
-            });
-            return true;
-        }
-        catch (err) {
-            this.debug(`[Player] Failed to play swapped track:`, err);
-            return false;
-        }
-    }
     /**
      * Load fresh stream when no preload available
      */
@@ -961,6 +943,10 @@ class Player extends events_1.EventEmitter {
         await this.safeCancelPreload();
         try {
             const streamInfo = await this.getStream(track);
+            // Handle remote playback
+            if (streamInfo?.remote && streamInfo.handle) {
+                return await this.playRemote(track, streamInfo);
+            }
             if (!streamInfo?.stream) {
                 throw new Error(`No stream available`);
             }
@@ -968,6 +954,7 @@ class Player extends events_1.EventEmitter {
             const streamId = this.streamManager.registerStream(streamInfo.stream, track, {
                 source: track.source || "stream",
                 isPreload: false,
+                isRemote: !!streamInfo?.remote,
                 priority: 10,
             });
             // Create resource
@@ -1013,8 +1000,6 @@ class Player extends events_1.EventEmitter {
         if (this.destroyed)
             return false;
         this.debug("[Player] playNext called");
-        // Don't cancel preload here unless absolutely necessary
-        // Let startTrack handle it
         while (true) {
             const track = this.queue.next(this.skipLoop);
             this.skipLoop = false;
@@ -1035,7 +1020,6 @@ class Player extends events_1.EventEmitter {
                     }
                 }
                 this.debug(`[Player] No next track in queue`);
-                this.isPlaying = false;
                 this.emit("queueEnd");
                 // Clean up both slots when queue is empty
                 this.clearSlot(this.currentSlot);
@@ -1054,6 +1038,11 @@ class Player extends events_1.EventEmitter {
                     this.antiStuckConsecutiveFailures = 0;
                     return true;
                 }
+                // For remote playback, if startTrack returns false, it's a failure
+                if (this.playbackMode === types_1.PlaybackMode.REMOTE) {
+                    this.debug(`[Player] Remote track failed to start: ${track.title}`);
+                    continue; // Skip to next track
+                }
                 const recovered = await this.attemptTrackRecovery(track, new Error("TRACK_START_RETURNED_FALSE"));
                 if (recovered) {
                     return true;
@@ -1068,6 +1057,11 @@ class Player extends events_1.EventEmitter {
             catch (err) {
                 this.debug(`[Player] playNext error:`, err);
                 this.emit("playerError", err, track);
+                // For remote playback, just skip to next track
+                if (this.playbackMode === types_1.PlaybackMode.REMOTE) {
+                    this.debug(`[Player] Remote track error, skipping: ${track.title}`);
+                    continue;
+                }
                 if (this.isUnrecoverableStreamError(err)) {
                     this.debug(`[Player] Skipping unrecoverable track (no plugin): ${track.title}`);
                     continue;
@@ -1086,6 +1080,27 @@ class Player extends events_1.EventEmitter {
             }
         }
     }
+    async playRemote(track, stream) {
+        if (!stream.handle)
+            return false;
+        try {
+            // Store the remote handle for later use
+            this.remoteHandle = stream.handle;
+            // Set current track before playing
+            this.queue.setCurrentTrack(track);
+            // Emit track start event before playing (so UI updates)
+            this.emit("trackStart", track);
+            // Start playback via remote handle
+            await stream.handle.play();
+            this.debug(`[Player] Remote playback started for: ${track.title}`);
+            return true;
+        }
+        catch (error) {
+            this.debug(`[Player] Remote playback error:`, error);
+            this.emit("playerError", error, track);
+            return false;
+        }
+    }
     //#endregion
     //#region TTS
     ensureTTSPlayer() {
@@ -1237,51 +1252,142 @@ class Player extends events_1.EventEmitter {
         }
     }
     /**
-     * Subscribe this player's voice connection
-     * to another player's audio stream.
+     * Subscribe this player to another player's playback stream.
+     *
+     * This enables "forward mode", where the follower player directly subscribes
+     * to the leader player's {@link audioPlayer} instead of creating its own stream.
      *
-     * This is primarily used for:
-     * - playback mirroring
-     * - radio/broadcast systems
-     * - multi-guild synchronized playback
-     * - forwardMode shared streaming
+     * Greatly reduces CPU, bandwidth, and extractor usage because only the leader
+     * creates and decodes the audio resource.
      *
-     * Instead of creating a separate audio stream,
-     * this player will directly receive audio packets
-     * from the target player's AudioPlayer instance.
+     * ## Features
+     * - Real-time shared playback
+     * - Followers may join at any time
+     * - Automatic track synchronization
+     * - Optional volume synchronization
+     * - Automatic cleanup on destroy
+     * - Supports unlimited followers
      *
-     * Benefits:
-     * - drastically lower CPU usage
-     * - only one ffmpeg/extractor stream
-     * - lower bandwidth and memory usage
-     * - perfect sync across guilds
+     * ## Lifecycle
+     * - When the leader starts a track, followers automatically receive the same track metadata.
+     * - When the leader pauses/resumes/stops, followers are synchronized.
+     * - Destroying the leader automatically unsubscribes all followers.
+     * - Destroying a follower only removes that follower.
      *
-     * Important:
-     * - both players must already have active voice connections
-     * - this does NOT transfer queue ownership
-     * - this does NOT clone playback state automatically
+     * ## Notes
+     * - Both players must already be connected to voice.
+     * - A player cannot subscribe to itself.
+     * - Existing playback subscriptions are automatically replaced.
      *
-     * @param {Player} player - Source player to subscribe to
+     * @param {Player} leader The leader player to subscribe to.
+     * @param options Additional playback mirror options.
+     * @param options.syncVolume When true, follower volume automatically follows the leader. Default: true.
      *
-     * @returns {boolean}
-     * Returns true if subscription succeeded,
-     * otherwise false.
+     * @returns {boolean} True if subscription succeeded.
      *
      * @example
      * follower.subscribeTo(leader);
      *
      * @example
-     * if (!player.subscribeTo(leader)) {
-     *   console.log("Failed to subscribe");
-     * }
+     * follower.subscribeTo(leader, {
+     *   syncVolume: true,
+     * });
      */
-    subscribeTo(player) {
-        if (!this.connection)
+    subscribeTo(leader, options) {
+        if (!leader)
+            return false;
+        if (leader === this) {
+            this.debug(`[Player] Cannot subscribe to self`);
             return false;
-        this.connection.subscribe(player.audioPlayer);
-        this.isPlaying = player.isPlaying;
-        this.isPaused = player.isPaused;
-        this.forwardMode = true;
+        }
+        if (leader.destroyed) {
+            this.debug("[Player] Cannot subscribe to destroyed leader");
+            return false;
+        }
+        if (this.destroyed) {
+            this.debug("[Player] Cannot subscribe destroyed player");
+            return false;
+        }
+        if (!!leader.forwardLeader) {
+            this.debug("[Player] Cannot subscribe to follower player");
+            return false;
+        }
+        if (!this.connection || !leader.connection) {
+            this.debug(`[Player] Missing connection for subscribeTo`);
+            return false;
+        }
+        // cleanup old leader
+        if (this.forwardLeader) {
+            this.unsubscribeForward("This Player new subscribeTo " + leader.guildId);
+        }
+        this.forwardLeader = leader;
+        leader.forwardFollowers.add(this);
+        try {
+            // clear local playback
+            this.stop();
+            // detach current followers first
+            for (const fp of [...this.forwardFollowers]) {
+                try {
+                    fp.unsubscribeForward("Leader new subscribeTo " + leader.guildId);
+                }
+                catch { }
+            }
+            this.forwardFollowers.clear();
+            this.queue.clear();
+            if (leader.currentTrack) {
+                this.queue.setCurrentTrack(leader.currentTrack);
+            }
+            if (options?.forwardMode ?? true)
+                this.playbackMode = types_1.PlaybackMode.FORWARD;
+            if (this.playbackMode === types_1.PlaybackMode.FORWARD && this.connection) {
+                this.connection.subscribe(leader.audioPlayer);
+            }
+            this.volume = leader.volume;
+            this.emit("forwardModeStart", leader);
+            this.debug(`[Player] Forward mode subscribed ${this.guildId} -> ${leader.guildId}`);
+            return true;
+        }
+        catch (e) {
+            this.debug(`[Player] subscribeTo error:`, e);
+            this.forwardLeader = null;
+            leader.forwardFollowers.delete(this);
+            return false;
+        }
+    }
+    /**
+     * Unsubscribe this player from its current playback leader.
+     *
+     * This disables forward mode and restores the player's own audioPlayer
+     * subscription back to its voice connection.
+     *
+     * Automatically emitted when:
+     * - The leader player is destroyed
+     * - This player is destroyed
+     * - A new leader subscription replaces the old one
+     *
+     * Emits:
+     * - `forwardModeEnd`
+     *
+     * @returns {boolean} True if a playback subscription existed and was removed.
+     *
+     * @example
+     * follower.unsubscribeForward();
+     */
+    unsubscribeForward(reason) {
+        if (!this.forwardLeader) {
+            return false;
+        }
+        const leader = this.forwardLeader;
+        leader.forwardFollowers.delete(this);
+        this.forwardLeader = null;
+        this.playbackMode = types_1.PlaybackMode.NATIVE;
+        try {
+            this.connection?.subscribe(this.audioPlayer);
+        }
+        catch { }
+        this.queue.clear();
+        this.emit("forwardModeEnd", leader, reason);
+        this.debug(`[Player] Forward mode unsubscribed ${this.guildId} <- ${leader.guildId}: ${reason ?? null}`);
         return true;
     }
     /**
@@ -1293,10 +1399,22 @@ class Player extends events_1.EventEmitter {
      * console.log(`Paused: ${paused}`);
      */
     pause() {
+        if (this.playbackMode === types_1.PlaybackMode.FORWARD) {
+            this.debug("[Player] Cannot pause while subscribed to another player");
+            return false;
+        }
         this.debug(`[Player] pause called`);
-        if (this.isPlaying && !this.isPaused) {
-            return this.audioPlayer.pause();
+        if (this.playbackMode === types_1.PlaybackMode.REMOTE) {
+            if (!this.remoteHandle)
+                return false;
+            void this.remoteHandle.pause().catch((e) => this.debug("[Player] Remote pause:", e));
+            const track = this.queue.currentTrack;
+            if (track)
+                this.emit("playerPause", track);
+            return true;
         }
+        if (this.isPlaying && !this.isPaused)
+            return this.audioPlayer.pause();
         return false;
     }
     /**
@@ -1308,7 +1426,20 @@ class Player extends events_1.EventEmitter {
      * console.log(`Resumed: ${resumed}`);
      */
     resume() {
+        if (this.playbackMode === types_1.PlaybackMode.FORWARD) {
+            this.debug("[Player] Cannot resume while subscribed to another player");
+            return false;
+        }
         this.debug(`[Player] resume called`);
+        if (this.playbackMode === types_1.PlaybackMode.REMOTE) {
+            if (!this.remoteHandle)
+                return false;
+            void this.remoteHandle.resume().catch((e) => this.debug("[Player] Remote resume:", e));
+            const track = this.queue.currentTrack;
+            if (track)
+                this.emit("playerResume", track);
+            return true;
+        }
         if (this.isPaused) {
             const result = this.audioPlayer.unpause();
             if (result) {
@@ -1331,16 +1462,33 @@ class Player extends events_1.EventEmitter {
      * console.log(`Stopped: ${stopped}`);
      */
     stop() {
+        if (this.playbackMode === types_1.PlaybackMode.FORWARD) {
+            this.debug("[Player] Cannot stop while subscribed to another player");
+            return false;
+        }
         this.debug(`[Player] stop called`);
+        if (this.playbackMode === types_1.PlaybackMode.REMOTE) {
+            this.cancelPreload();
+            this.queue.clear();
+            void this.remoteHandle?.stop().catch((e) => this.debug("[Player] Remote stop:", e));
+            this.emit("playerStop");
+            return true;
+        }
         // Cancel preload when stopping
         this.cancelPreload();
         this.queue.clear();
         const result = this.audioPlayer.stop();
         this.destroyCurrentStream();
         this.currentResource = null;
-        this.isPlaying = false;
-        this.isPaused = false;
         this.emit("playerStop");
+        for (const fp of this.forwardFollowers) {
+            try {
+                fp.connection?.subscribe(fp.audioPlayer);
+                fp.audioPlayer.stop(true);
+                fp.emit("playerStop");
+            }
+            catch { }
+        }
         return result;
     }
     /**
@@ -1357,7 +1505,17 @@ class Player extends events_1.EventEmitter {
      * await player.seek(90000);
      */
     async seek(position) {
+        if (this.playbackMode === types_1.PlaybackMode.FORWARD) {
+            this.debug("[Player] Cannot seek while subscribed to another player");
+            return false;
+        }
         this.debug(`[Player] seek called with position: ${position}ms`);
+        if (this.playbackMode === types_1.PlaybackMode.REMOTE) {
+            if (!this.remoteHandle)
+                return false;
+            await this.remoteHandle.seek(position);
+            return true;
+        }
         const track = this.queue.currentTrack;
         if (!track) {
             this.debug(`[Player] No current track to seek`);
@@ -1382,7 +1540,21 @@ class Player extends events_1.EventEmitter {
      * console.log(`Skipped: ${skipped}`);
      */
     skip(index) {
+        if (this.playbackMode === types_1.PlaybackMode.FORWARD) {
+            this.debug("[Player] Cannot skip while subscribed to another player");
+            return false;
+        }
         this.debug(`[Player] skip called with index: ${index}`);
+        if (this.playbackMode === types_1.PlaybackMode.REMOTE) {
+            if (typeof index === "number" && index >= 0) {
+                for (let i = 0; i < index; i++)
+                    this.queue.remove(0);
+            }
+            // signal the remote backend to stop;
+            void this.remoteHandle?.stop().catch((e) => this.debug("[Player] Remote skip:", e));
+            this.playNext();
+            return true;
+        }
         try {
             if (typeof index === "number" && index >= 0) {
                 const targetTrack = this.queue.getTrack(index);
@@ -1419,6 +1591,10 @@ class Player extends events_1.EventEmitter {
      * console.log(`Previous: ${previous}`);
      */
     async previous() {
+        if (this.playbackMode === types_1.PlaybackMode.FORWARD) {
+            this.debug("[Player] Cannot previous while subscribed to another player");
+            return false;
+        }
         this.debug(`[Player] previous called`);
         const track = this.queue.previous();
         if (!track)
@@ -1548,6 +1724,12 @@ class Player extends events_1.EventEmitter {
      * console.log(`Auto-play mode: ${autoPlayMode}`);
      */
     autoPlay(mode) {
+        if (this.playbackMode === types_1.PlaybackMode.FORWARD) {
+            if (!mode)
+                return this.forwardLeader?.autoPlay() ?? false;
+            this.debug("[Player] Cannot autoPlay while subscribed to another player");
+            return false;
+        }
         return this.queue.autoPlay(mode);
     }
     /**
@@ -1560,11 +1742,20 @@ class Player extends events_1.EventEmitter {
      * console.log(`Volume set: ${volumeSet}`);
      */
     setVolume(volume) {
+        if (this.playbackMode === types_1.PlaybackMode.FORWARD) {
+            this.debug("[Player] Cannot setVolume while subscribed to another player");
+            return false;
+        }
         this.debug(`[Player] setVolume called: ${volume}`);
         if (volume < 0 || volume > 200)
             return false;
         const oldVolume = this.volume;
         this.volume = volume;
+        if (this.playbackMode === types_1.PlaybackMode.REMOTE) {
+            void this.remoteHandle?.setVolume(volume).catch((e) => this.debug("[Player] Remote volume:", e));
+            this.emit("volumeChange", oldVolume, volume);
+            return true;
+        }
         const resourceVolume = this.currentResource?.volume;
         if (resourceVolume) {
             if (this.volumeInterval)
@@ -1584,6 +1775,12 @@ class Player extends events_1.EventEmitter {
             }, 300);
         }
         this.emit("volumeChange", oldVolume, volume);
+        for (const fp of this.forwardFollowers) {
+            try {
+                fp.volume = volume;
+            }
+            catch { }
+        }
         return true;
     }
     /**
@@ -1624,6 +1821,10 @@ class Player extends events_1.EventEmitter {
      */
     async insert(query, index, requestedBy) {
         try {
+            if (this.playbackMode === types_1.PlaybackMode.FORWARD) {
+                this.debug("[Player] Cannot insert while subscribed to another player");
+                return false;
+            }
             this.debug(`[Player] insert called at index ${index} with type: ${typeof query}`);
             let tracksToAdd = [];
             let isPlaylist = false;
@@ -1834,6 +2035,10 @@ class Player extends events_1.EventEmitter {
         if (this.destroyed)
             return;
         this.destroyed = true;
+        if (this.remoteHandle?.destroy) {
+            this.remoteHandle.destroy().catch(() => { });
+            this.remoteHandle = undefined;
+        }
         if (this.leaveTimeout) {
             clearTimeout(this.leaveTimeout);
             this.leaveTimeout = null;
@@ -1861,14 +2066,21 @@ class Player extends events_1.EventEmitter {
         this.pluginManager.clear();
         this.filter.destroy();
         this.extensionManager.destroy();
-        this.isPlaying = false;
-        this.isPaused = false;
         // Clear any remaining intervals
         if (this.volumeInterval) {
             clearInterval(this.volumeInterval);
             this.volumeInterval = null;
         }
         this.emit("playerDestroy");
+        this.unsubscribeForward("Player destroy");
+        // release followers
+        for (const fp of [...this.forwardFollowers]) {
+            try {
+                fp.unsubscribeForward("Leader destroy");
+            }
+            catch { }
+        }
+        this.forwardFollowers.clear();
         this.removeAllListeners();
     }
     //#endregion
@@ -1940,13 +2152,7 @@ class Player extends events_1.EventEmitter {
                 this.audioPlayer.play(resource);
             }
             // Restore playing state
-            if (wasPlaying && !wasPaused) {
-                this.isPlaying = true;
-                this.isPaused = false;
-            }
-            else if (wasPaused) {
-                this.isPlaying = false;
-                this.isPaused = true;
+            if (wasPaused) {
                 this.audioPlayer.pause();
             }
             this.debug(`[Player] Successfully applied filter to current track at position ${currentPosition}ms`);
@@ -2012,6 +2218,9 @@ class Player extends events_1.EventEmitter {
                 if (track) {
                     this.debug(`[Player] Track ended: ${track.title}`);
                     this.emit("trackEnd", track);
+                    for (const fp of this.forwardFollowers) {
+                        fp.emit("trackEnd", track);
+                    }
                 }
                 void this.playNext();
             }
@@ -2019,30 +2228,41 @@ class Player extends events_1.EventEmitter {
                 (oldState.status === voice_1.AudioPlayerStatus.Idle || oldState.status === voice_1.AudioPlayerStatus.Buffering)) {
                 // Track started
                 this.clearLeaveTimeout();
-                this.isPlaying = true;
-                this.isPaused = false;
                 const track = this.queue.currentTrack;
                 if (track) {
                     this.debug(`[Player] Track started: ${track.title}`);
                     this.emit("trackStart", track);
+                    for (const fp of this.forwardFollowers) {
+                        try {
+                            fp.queue.clear();
+                            fp.connection?.subscribe(this.audioPlayer);
+                            fp.queue.setCurrentTrack(track);
+                            fp.emit("trackStart", track);
+                        }
+                        catch (e) {
+                            this.debug(`[Player] Failed to sync follower ${fp.guildId}:`, e);
+                        }
+                    }
                 }
             }
             else if (newState.status === voice_1.AudioPlayerStatus.Paused && oldState.status !== voice_1.AudioPlayerStatus.Paused) {
-                // Track paused
-                this.isPaused = true;
                 const track = this.queue.currentTrack;
                 if (track) {
                     this.debug(`[Player] Player paused on track: ${track.title}`);
                     this.emit("playerPause", track);
+                    for (const fp of this.forwardFollowers) {
+                        fp.emit("playerPause", track);
+                    }
                 }
             }
             else if (newState.status !== voice_1.AudioPlayerStatus.Paused && oldState.status === voice_1.AudioPlayerStatus.Paused) {
-                // Track resumed
-                this.isPaused = false;
                 const track = this.queue.currentTrack;
                 if (track) {
                     this.debug(`[Player] Player resumed on track: ${track.title}`);
                     this.emit("playerResume", track);
+                    for (const fp of this.forwardFollowers) {
+                        fp.emit("playerResume", track);
+                    }
                 }
             }
             else if (newState.status === voice_1.AudioPlayerStatus.AutoPaused) {
@@ -2136,6 +2356,25 @@ class Player extends events_1.EventEmitter {
             plugins: this.pluginManager.getAll().map((plugin) => plugin.name),
         };
     }
+    exitRemoteMode() {
+        if (this.playbackMode !== types_1.PlaybackMode.REMOTE)
+            return;
+        this.debug("[Player] Exiting REMOTE mode, restoring native playback");
+        void this.remoteHandle?.destroy().catch(() => { });
+        this.remoteHandle = undefined;
+        this.playbackMode = types_1.PlaybackMode.NATIVE;
+        this._remotePaused = false;
+        // Restore preload/crossfade from original options
+        const preloadOptions = this.options.preload ?? {};
+        const autoDisable = preloadOptions.autoDisableInLowPerformance ?? true;
+        this.preloadEnabled = (preloadOptions.enabled ?? true) && !(this.lowPerformanceMode && autoDisable);
+        const crossfadeOptions = this.options.crossfade ?? {};
+        const cfAutoDisable = crossfadeOptions.autoDisableInLowPerformance ?? true;
+        this.crossfadeEnabled =
+            typeof crossfadeOptions.enabled === "boolean" ? crossfadeOptions.enabled : (crossfadeOptions.autoEnable ?? true);
+        if (this.lowPerformanceMode && cfAutoDisable)
+            this.crossfadeEnabled = false;
+    }
     /**
      * Get serializable state (for manual persistence)
      */
@@ -2189,6 +2428,59 @@ class Player extends events_1.EventEmitter {
             totalStreams: this.streamManager.getStreamCount(),
         };
     }
+    getForwardHealthStatus() {
+        const issues = [];
+        const details = {};
+        if (this.playbackMode === types_1.PlaybackMode.FORWARD && this.forwardLeader) {
+            // This player is a follower
+            details.leaderId = this.forwardLeader.guildId;
+            details.connectionState = this.connection?.state.status;
+            details.audioPlayerState = this.audioPlayer.state.status;
+            if (this.forwardLeader.destroyed) {
+                issues.push("Leader is destroyed");
+            }
+            if (!this.forwardLeader.connection) {
+                issues.push("Leader has no connection");
+            }
+            if (this.forwardLeader.destroyed || !this.forwardLeader.connection) {
+                issues.push("Leader is unavailable");
+            }
+            return {
+                guildId: this.guildId,
+                healthy: issues.length === 0,
+                role: "follower",
+                issues,
+                details,
+            };
+        }
+        else if (this.forwardFollowers.size > 0) {
+            // This player is a leader
+            details.followerCount = this.forwardFollowers.size;
+            details.connectionState = this.connection?.state.status;
+            const deadFollowers = [];
+            for (const follower of this.forwardFollowers) {
+                if (follower.destroyed)
+                    deadFollowers.push(follower.guildId);
+            }
+            if (deadFollowers.length > 0) {
+                issues.push(`Has ${deadFollowers.length} dead followers: ${deadFollowers.join(", ")}`);
+            }
+            return {
+                guildId: this.guildId,
+                healthy: true, // Leader being healthy doesn't depend on followers
+                role: "leader",
+                issues,
+                details,
+            };
+        }
+        return {
+            guildId: this.guildId,
+            healthy: true,
+            role: "none",
+            issues: [],
+            details: {},
+        };
+    }
     //#endregion
     //#region Getters
     /**
@@ -2269,8 +2561,45 @@ class Player extends events_1.EventEmitter {
         return this.queue.relatedTracks();
     }
     get isLive() {
+        if (this.playbackMode === types_1.PlaybackMode.FORWARD)
+            return true; //forward Mode -> live from Leader
         return this.currentTrack?.isLive === true;
     }
+    get isPlaying() {
+        if (this.playbackMode === types_1.PlaybackMode.FORWARD) {
+            if (!this.forwardLeader || this.forwardLeader.destroyed) {
+                this.unsubscribeForward("Leader destroyed");
+                return false;
+            }
+            return this.forwardLeader.isPlaying;
+        }
+        if (this.playbackMode === types_1.PlaybackMode.REMOTE) {
+            return !!this.queue.currentTrack; // driven by queue state, not audioPlayer
+        }
+        return (this.audioPlayer.state.status === voice_1.AudioPlayerStatus.Playing || this.audioPlayer.state.status === voice_1.AudioPlayerStatus.Buffering);
+    }
+    get isPaused() {
+        if (this.playbackMode === types_1.PlaybackMode.FORWARD) {
+            return this.forwardLeader?.isPaused ?? false;
+        }
+        if (this.playbackMode === types_1.PlaybackMode.REMOTE) {
+            // Extension tracks pause state via handle; Player exposes a flag
+            return this._remotePaused;
+        }
+        return this.audioPlayer.state.status === voice_1.AudioPlayerStatus.Paused;
+    }
+    get isIdle() {
+        if (this.playbackMode === types_1.PlaybackMode.FORWARD) {
+            return this.forwardLeader?.isIdle ?? false;
+        }
+        return this.audioPlayer.state.status === voice_1.AudioPlayerStatus.Idle;
+    }
+    get isBuffering() {
+        if (this.playbackMode === types_1.PlaybackMode.FORWARD) {
+            return this.forwardLeader?.isBuffering ?? false;
+        }
+        return this.audioPlayer.state.status === voice_1.AudioPlayerStatus.Buffering;
+    }
 }
 exports.Player = Player;
 //# sourceMappingURL=Player.js.map