ziplayer 0.3.2 → 0.3.4

package/dist/structures/Player.js

@@ -4,6 +4,7 @@ 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");
@@ -51,11 +52,14 @@ class Player extends events_1.EventEmitter {
         super();
         this.connection = null;
         this.volume = 100;
-        this.isPlaying = false;
-        this.isPaused = 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;
@@ -103,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;
@@ -181,6 +184,7 @@ 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, {
@@ -375,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`
@@ -772,16 +780,44 @@ 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) {
             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) {
@@ -789,10 +825,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) {
@@ -807,10 +857,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}`);
         }
@@ -827,13 +878,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(() => {
@@ -842,29 +905,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);
         }
@@ -874,53 +932,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
      */
@@ -931,6 +942,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`);
             }
@@ -983,8 +998,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;
@@ -1005,7 +1018,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);
@@ -1024,6 +1036,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;
@@ -1038,6 +1055,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;
@@ -1056,6 +1078,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() {
@@ -1088,6 +1131,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) {
@@ -1205,6 +1249,145 @@ class Player extends events_1.EventEmitter {
             throw error;
         }
     }
+    /**
+     * 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.
+     *
+     * Greatly reduces CPU, bandwidth, and extractor usage because only the leader
+     * creates and decodes the audio resource.
+     *
+     * ## Features
+     * - Real-time shared playback
+     * - Followers may join at any time
+     * - Automatic track synchronization
+     * - Optional volume synchronization
+     * - Automatic cleanup on destroy
+     * - Supports unlimited followers
+     *
+     * ## 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.
+     *
+     * ## Notes
+     * - Both players must already be connected to voice.
+     * - A player cannot subscribe to itself.
+     * - Existing playback subscriptions are automatically replaced.
+     *
+     * @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} True if subscription succeeded.
+     *
+     * @example
+     * follower.subscribeTo(leader);
+     *
+     * @example
+     * follower.subscribeTo(leader, {
+     *   syncVolume: true,
+     * });
+     */
+    subscribeTo(leader, options) {
+        if (!leader)
+            return false;
+        if (leader === this) {
+            this.debug(`[Player] Cannot subscribe to self`);
+            return false;
+        }
+        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;
+    }
     /**
      * Pause the current track
      *
@@ -1214,10 +1397,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;
     }
     /**
@@ -1229,7 +1424,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) {
@@ -1252,16 +1460,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;
     }
     /**
@@ -1278,7 +1503,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`);
@@ -1303,7 +1538,20 @@ 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; TrackEndEvent triggers playNext()
+            void this.remoteHandle?.stop().catch((e) => this.debug("[Player] Remote skip:", e));
+            return true;
+        }
         try {
             if (typeof index === "number" && index >= 0) {
                 const targetTrack = this.queue.getTrack(index);
@@ -1340,6 +1588,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)
@@ -1392,6 +1644,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) {
@@ -1468,6 +1721,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);
     }
     /**
@@ -1480,11 +1739,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)
@@ -1504,6 +1772,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;
     }
     /**
@@ -1544,6 +1818,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;
@@ -1754,6 +2032,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;
@@ -1781,14 +2063,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
@@ -1860,13 +2149,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`);
@@ -1932,6 +2215,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();
             }
@@ -1939,30 +2225,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) {
@@ -2056,6 +2353,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)
      */
@@ -2109,6 +2425,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
     /**
@@ -2189,8 +2558,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