ziplayer 0.2.6 → 0.2.7-dev.1

package/dist/structures/Player.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Player = void 0;
 const events_1 = require("events");
 const voice_1 = require("@discordjs/voice");
+const lru_cache_1 = require("lru-cache");
 const Queue_1 = require("./Queue");
 const plugins_1 = require("../plugins");
 const extensions_1 = require("../extensions");
@@ -54,12 +55,17 @@ class Player extends events_1.EventEmitter {
         this.leaveTimeout = null;
         this.currentResource = null;
         this.volumeInterval = null;
+        this.stuckTimer = null;
         this.skipLoop = false;
-        // Cache for search results to avoid duplicate calls
-        this.searchCache = new Map();
+        this.refreshLock = false;
+        //preloaded resource
+        this.preloadedResource = null;
+        this.preloadedTrack = null;
         this.SEARCH_CACHE_TTL = 2 * 60 * 1000; // 2 minutes
-        this.searchCacheTimestamps = new Map();
         this.ttsPlayer = null;
+        this.lastDuration = 0;
+        this.lastSaveTime = 0;
+        this.AUTO_SAVE_INTERVAL = 30000; // 30 seconds
         this.debug(`[Player] Constructor called for guildId: ${guildId}`);
         this.guildId = guildId;
         this.queue = new Queue_1.Queue();
@@ -84,7 +90,7 @@ class Player extends events_1.EventEmitter {
                 createPlayer: false,
                 interrupt: true,
                 volume: 100,
-                Max_Time_TTS: 60_000,
+                maxTimeTts: 60_000,
                 ...(options?.tts || {}),
             },
         };
@@ -95,6 +101,10 @@ class Player extends events_1.EventEmitter {
         });
         this.volume = this.options.volume || 100;
         this.userdata = this.options.userdata;
+        this.searchCache = new lru_cache_1.LRUCache({
+            max: 200,
+            ttl: this.SEARCH_CACHE_TTL,
+        });
         this.setupEventListeners();
         // Initialize filters from options
         if (this.options.filters && this.options.filters.length > 0) {
@@ -114,11 +124,12 @@ class Player extends events_1.EventEmitter {
      * @private
      */
     destroyCurrentStream() {
+        this.audioPlayer.stop(true);
         if (!this.currentResource)
             return;
         const stream = this.currentResource?.metadata?.stream ?? this.currentResource?.stream;
-        if (stream?.destroy) {
-            stream.destroy();
+        if (stream && typeof stream.destroy === "function") {
+            stream.destroy().catch((e) => this.debug("Stream destroy error:", e));
         }
         this.currentResource = null;
     }
@@ -135,11 +146,6 @@ class Player extends events_1.EventEmitter {
      */
     async search(query, requestedBy) {
         this.debug(`[Player] Search called with query: ${query}, requestedBy: ${requestedBy}`);
-        // Clear expired search cache periodically
-        if (Math.random() < 0.1) {
-            // 10% chance to clean cache
-            this.clearExpiredSearchCache();
-        }
         // Check cache first
         const cachedResult = this.getCachedSearchResult(query);
         if (cachedResult) {
@@ -198,14 +204,10 @@ class Player extends events_1.EventEmitter {
      */
     getCachedSearchResult(query) {
         const cacheKey = query.toLowerCase().trim();
-        const now = Date.now();
-        const cachedTimestamp = this.searchCacheTimestamps.get(cacheKey);
-        if (cachedTimestamp && now - cachedTimestamp < this.SEARCH_CACHE_TTL) {
-            const cachedResult = this.searchCache.get(cacheKey);
-            if (cachedResult) {
-                this.debug(`[SearchCache] Using cached search result for: ${query}`);
-                return cachedResult;
-            }
+        const cached = this.searchCache.get(cacheKey);
+        if (cached) {
+            this.debug(`[SearchCache] Using cached search result for: ${query}`);
+            return cached;
         }
         return null;
     }
@@ -216,23 +218,15 @@ class Player extends events_1.EventEmitter {
      */
     cacheSearchResult(query, result) {
         const cacheKey = query.toLowerCase().trim();
-        const now = Date.now();
         this.searchCache.set(cacheKey, result);
-        this.searchCacheTimestamps.set(cacheKey, now);
         this.debug(`[SearchCache] Cached search result for: ${query} (${result.tracks.length} tracks)`);
     }
     /**
      * Clear expired search cache entries
      */
     clearExpiredSearchCache() {
-        const now = Date.now();
-        for (const [key, timestamp] of this.searchCacheTimestamps.entries()) {
-            if (now - timestamp >= this.SEARCH_CACHE_TTL) {
-                this.searchCache.delete(key);
-                this.searchCacheTimestamps.delete(key);
-                this.debug(`[SearchCache] Cleared expired cache entry: ${key}`);
-            }
-        }
+        this.searchCache.purgeStale();
+        this.debug(`[SearchCache] Purged stale search cache entries`);
     }
     /**
      * Clear all search cache entries
@@ -242,7 +236,6 @@ class Player extends events_1.EventEmitter {
     clearSearchCache() {
         const cacheSize = this.searchCache.size;
         this.searchCache.clear();
-        this.searchCacheTimestamps.clear();
         this.debug(`[SearchCache] Cleared all ${cacheSize} search cache entries`);
     }
     /**
@@ -252,9 +245,8 @@ class Player extends events_1.EventEmitter {
      */
     debugSearchQuery(query) {
         const cacheKey = query.toLowerCase().trim();
-        const now = Date.now();
-        const cachedTimestamp = this.searchCacheTimestamps.get(cacheKey);
-        const isCached = cachedTimestamp && now - cachedTimestamp < this.SEARCH_CACHE_TTL;
+        const cached = this.searchCache.get(cacheKey);
+        const isCached = !!cached;
         const allPlugins = this.pluginManager.getAll();
         const plugins = allPlugins.filter((p) => {
             if (p.name.toLowerCase() === "tts" && !query.toLowerCase().startsWith("tts:")) {
@@ -263,8 +255,8 @@ class Player extends events_1.EventEmitter {
             return true;
         });
         return {
-            isCached: !!isCached,
-            cacheAge: cachedTimestamp ? now - cachedTimestamp : undefined,
+            isCached,
+            cacheAge: undefined,
             pluginCount: plugins.length,
             ttsFiltered: allPlugins.length > plugins.length,
         };
@@ -334,7 +326,7 @@ class Player extends events_1.EventEmitter {
             }
             else {
                 // Handle other types (string, Track)
-                const hookOutcome = await this.extensionManager.BeforePlayHooks(effectiveRequest);
+                const hookOutcome = await this.extensionManager.beforePlayHooks(effectiveRequest);
                 effectiveRequest = hookOutcome.request;
                 hookResponse = hookOutcome.response;
                 if (effectiveRequest.requestedBy === undefined) {
@@ -350,7 +342,7 @@ class Player extends events_1.EventEmitter {
                         isPlaylist: hookResponse.isPlaylist ?? false,
                         error: hookResponse.error,
                     };
-                    await this.extensionManager.AfterPlayHooks(handledPayload);
+                    await this.extensionManager.afterPlayHooks(handledPayload);
                     if (hookResponse.error) {
                         this.emit("playerError", hookResponse.error);
                     }
@@ -393,7 +385,7 @@ class Player extends events_1.EventEmitter {
                 (isTTS(tracksToAdd[0]) || queryLooksTTS)) {
                 this.debug(`[Player] Interrupting with TTS: ${tracksToAdd[0].title}`);
                 await this.interruptWithTTSTrack(tracksToAdd[0]);
-                await this.extensionManager.AfterPlayHooks({
+                await this.extensionManager.afterPlayHooks({
                     success: true,
                     query: effectiveRequest.query,
                     requestedBy: effectiveRequest.requestedBy,
@@ -411,7 +403,7 @@ class Player extends events_1.EventEmitter {
                 this.emit("queueAdd", tracksToAdd[0]);
             }
             const started = !this.isPlaying ? await this.playNext() : true;
-            await this.extensionManager.AfterPlayHooks({
+            await this.extensionManager.afterPlayHooks({
                 success: started,
                 query: effectiveRequest.query,
                 requestedBy: effectiveRequest.requestedBy,
@@ -421,7 +413,7 @@ class Player extends events_1.EventEmitter {
             return started;
         }
         catch (error) {
-            await this.extensionManager.AfterPlayHooks({
+            await this.extensionManager.afterPlayHooks({
                 success: false,
                 query: effectiveRequest.query,
                 requestedBy: effectiveRequest.requestedBy,
@@ -434,6 +426,27 @@ class Player extends events_1.EventEmitter {
             return false;
         }
     }
+    async preloadNext() {
+        const next = this.queue.nextTrack;
+        if (!next)
+            return;
+        try {
+            const stream = await this.getStream(next);
+            if (!stream || !stream.stream) {
+                this.debug(`[Player] No stream available to preload for track: ${next.title}`);
+                return;
+            }
+            const resource = (0, voice_1.createAudioResource)(stream.stream, {
+                inlineVolume: true,
+            });
+            this.preloadedResource = resource;
+            this.preloadedTrack = next;
+            this.debug("Preloaded next track:", next.title);
+        }
+        catch (err) {
+            this.debug("Preload failed:", err);
+        }
+    }
     /**
      * Create AudioResource with filters and seek applied
      *
@@ -495,6 +508,26 @@ class Player extends events_1.EventEmitter {
      */
     async startTrack(track) {
         try {
+            if (this.preloadedResource &&
+                this.preloadedTrack?.id === track.id &&
+                this.preloadedResource.playStream?.readable !== false) {
+                this.debug(`[Player] Using preloaded resource for track: ${track.title}`);
+                this.audioPlayer.stop(true);
+                this.destroyCurrentStream();
+                this.currentResource = this.preloadedResource;
+                this.currentResource.volume?.setVolume(this.volume / 100);
+                this.audioPlayer.play(this.currentResource);
+                await (0, voice_1.entersState)(this.audioPlayer, voice_1.AudioPlayerStatus.Playing, 5_000);
+                if (this.preloadedResource) {
+                    try {
+                        this.preloadedResource.playStream?.destroy?.();
+                    }
+                    catch { }
+                }
+                this.preloadedResource = null;
+                this.preloadedTrack = null;
+                return true;
+            }
             let streamInfo = await this.getStream(track);
             this.debug(`[Player] Using stream for track: ${track.title}`);
             // Kiểm tra nếu có stream thực sự để tạo AudioResource
@@ -556,7 +589,7 @@ class Player extends events_1.EventEmitter {
         }
     }
     async playNext() {
-        this.debug(`[Player] playNext called by ${new Error().stack?.split("\n")[2]?.trim()}`);
+        this.debug("[Player] playNext called");
         while (true) {
             const track = this.queue.next(this.skipLoop);
             this.skipLoop = false;
@@ -576,11 +609,17 @@ class Player extends events_1.EventEmitter {
                 }
                 return false;
             }
-            this.generateWillNext();
+            this.generateWillNext().catch((err) => this.debug("[Player] generateWillNext error:", err));
             this.clearLeaveTimeout();
             this.debug(`[Player] playNext called for track: ${track.title}`);
             try {
-                return await this.startTrack(track);
+                const started = await this.startTrack(track);
+                if (started) {
+                    setImmediate(() => {
+                        this.preloadNext();
+                    });
+                }
+                return started;
             }
             catch (err) {
                 this.debug(`[Player] playNext error:`, err);
@@ -624,12 +663,12 @@ class Player extends events_1.EventEmitter {
             // Build resource from plugin stream
             const streamInfo = await this.pluginManager.getStream(track);
             if (!streamInfo) {
-                throw new Error("No stream available for track: ${track.title}");
+                throw new Error(`No stream available for track: ${track.title}`);
             }
             ttsStream = streamInfo.stream;
             const resource = await this.createResource(streamInfo, track);
             if (!resource) {
-                throw new Error("No resource available for track: ${track.title}");
+                throw new Error(`No resource available for track: ${track.title}`);
             }
             ttsResource = resource;
             if (resource.volume) {
@@ -656,7 +695,7 @@ class Player extends events_1.EventEmitter {
                     declared
                     : declared * 1000
                 : undefined;
-            const cap = this.options?.tts?.Max_Time_TTS ?? 60_000;
+            const cap = this.options?.tts?.maxTimeTts ?? 60_000;
             const idleTimeout = declaredMs ? Math.min(cap, Math.max(1_000, declaredMs + 1_500)) : cap;
             await (0, voice_1.entersState)(ttsPlayer, voice_1.AudioPlayerStatus.Idle, idleTimeout).catch(() => null);
             // Swap back and resume if needed
@@ -707,9 +746,21 @@ class Player extends events_1.EventEmitter {
             });
             await (0, voice_1.entersState)(connection, voice_1.VoiceConnectionStatus.Ready, 50_000);
             this.connection = connection;
-            connection.on(voice_1.VoiceConnectionStatus.Disconnected, () => {
-                this.debug(`[Player] VoiceConnectionStatus.Disconnected`);
-                this.destroy();
+            connection.on(voice_1.VoiceConnectionStatus.Disconnected, async () => {
+                try {
+                    //  move channel
+                    await Promise.race([
+                        (0, voice_1.entersState)(connection, voice_1.VoiceConnectionStatus.Signalling, 5_000),
+                        (0, voice_1.entersState)(connection, voice_1.VoiceConnectionStatus.Connecting, 5_000),
+                    ]);
+                    //  Signalling/Connecting → reconnect
+                    this.debug(`[Player] Reconnecting after channel move...`);
+                }
+                catch {
+                    // no reconnect in 5 giây → disconnect
+                    this.debug(`[Player] Truly disconnected, destroying player`);
+                    this.destroy();
+                }
             });
             connection.on("error", (error) => {
                 this.debug(`[Player] Voice connection error:`, error);
@@ -757,7 +808,7 @@ class Player extends events_1.EventEmitter {
                 const track = this.queue.currentTrack;
                 if (track) {
                     this.debug(`[Player] Player resumed on track: ${track.title}`);
-                    this.emit("playerResume", track);
+                    // this.emit("playerResume", track); //đã có trong stateChange
                 }
             }
             return result;
@@ -776,6 +827,8 @@ class Player extends events_1.EventEmitter {
         this.debug(`[Player] stop called`);
         this.queue.clear();
         const result = this.audioPlayer.stop();
+        this.destroyCurrentStream();
+        this.currentResource = null;
         this.isPlaying = false;
         this.isPaused = false;
         this.emit("playerStop");
@@ -806,12 +859,7 @@ class Player extends events_1.EventEmitter {
             this.debug(`[Player] Invalid seek position: ${position}ms (track duration: ${totalDuration}ms)`);
             return false;
         }
-        const streaminfo = await this.getStream(track);
-        if (!streaminfo?.stream) {
-            this.debug(`[Player] No stream to seek`);
-            return false;
-        }
-        await this.refeshPlayerResource(true, position);
+        await this.refreshPlayerResource(true, position);
         return true;
     }
     /**
@@ -917,7 +965,7 @@ class Player extends events_1.EventEmitter {
             saveOptions = options;
         }
         try {
-            // Try extensions first
+            // 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) {
                 throw new Error(`No save stream available for track: ${track.title}`);
@@ -1131,21 +1179,96 @@ class Player extends events_1.EventEmitter {
      * @example
      * const progressBar = player.getProgressBar();
      * console.log(`Progress bar: ${progressBar}`);
+     *
+     * // Custom options
+     * const customBar = player.getProgressBar({
+     *   size: 30,
+     *   barChar: "─",
+     *   progressChar: "●",
+     *   timeFormat: "compact" // "compact" = 1:22:12, "full" = 01:22:12
+     * });
      */
     getProgressBar(options = {}) {
-        const { size = 20, barChar = "▬", progressChar = "🔘" } = options;
+        const { size = 20, barChar = "▬", progressChar = "🔘", timeFormat = "compact", // "compact" or "full"
+        showPercentage = false, showTime = true, } = options;
         const track = this.queue.currentTrack;
         const resource = this.currentResource;
-        if (!track || !resource)
+        // Handle live stream
+        if (this.isLive || !track || !resource) {
+            if (this.isLive)
+                return "🔴 LIVE";
             return "";
+        }
         const total = track.duration > 1000 ? track.duration : track.duration * 1000;
         if (!total)
-            return this.formatTime(resource.playbackDuration);
+            return this.formatTimeCompact(resource.playbackDuration);
         const current = resource.playbackDuration;
-        const ratio = Math.min(current / total, 1);
+        const ratio = Math.min(Math.max(current / total, 0), 1);
         const progress = Math.round(ratio * size);
-        const bar = barChar.repeat(progress) + progressChar + barChar.repeat(size - progress);
-        return `${this.formatTime(current)} | ${bar} | ${this.formatTime(total)}`;
+        // Build progress bar
+        let bar = "";
+        if (progressChar === "none" || options.hideProgressChar) {
+            // Continuous bar without separator
+            const filled = barChar.repeat(progress);
+            const empty = barChar.repeat(size - progress);
+            bar = filled + empty;
+        }
+        else {
+            // Bar with progress character
+            const filled = barChar.repeat(progress);
+            const empty = barChar.repeat(Math.max(0, size - progress));
+            bar = filled + progressChar + empty;
+        }
+        // Format time based on option
+        const formatTimeFn = timeFormat === "compact" ? this.formatTimeCompact.bind(this) : this.formatTime.bind(this);
+        const currentTimeStr = formatTimeFn(current);
+        const totalTimeStr = formatTimeFn(total);
+        // Build result
+        let result = "";
+        if (showTime) {
+            result = `${currentTimeStr} ${bar} ${totalTimeStr}`;
+        }
+        else {
+            result = bar;
+        }
+        // Add percentage if requested
+        if (showPercentage) {
+            const percent = Math.round(ratio * 100);
+            result += ` (${percent}%)`;
+        }
+        return result;
+    }
+    /**
+     * Format time with leading zeros (00:00 or 00:00:00)
+     * @param ms - Time in milliseconds
+     * @returns Formatted time string with leading zeros
+     */
+    formatTime(ms) {
+        const totalSeconds = Math.floor(ms / 1000);
+        const hours = Math.floor(totalSeconds / 3600);
+        const minutes = Math.floor((totalSeconds % 3600) / 60);
+        const seconds = totalSeconds % 60;
+        const parts = [];
+        if (hours > 0)
+            parts.push(String(hours).padStart(2, "0"));
+        parts.push(String(minutes).padStart(2, "0"));
+        parts.push(String(seconds).padStart(2, "0"));
+        return parts.join(":");
+    }
+    /**
+     * Format time without leading zeros for hours (1:22:12 or 3:45)
+     * @param ms - Time in milliseconds
+     * @returns Compact formatted time string
+     */
+    formatTimeCompact(ms) {
+        const totalSeconds = Math.floor(ms / 1000);
+        const hours = Math.floor(totalSeconds / 3600);
+        const minutes = Math.floor((totalSeconds % 3600) / 60);
+        const seconds = totalSeconds % 60;
+        if (hours > 0) {
+            return `${hours}:${String(minutes).padStart(2, "0")}:${String(seconds).padStart(2, "0")}`;
+        }
+        return `${minutes}:${String(seconds).padStart(2, "0")}`;
     }
     /**
      * Get the time of the current track
@@ -1154,44 +1277,44 @@ class Player extends events_1.EventEmitter {
      * @example
      * const time = player.getTime();
      * console.log(`Time: ${time.current}`);
+     * console.log(`Formatted: ${time.formatted.current}`); // "1:22:12" or "3:45"
      */
     getTime() {
+        if (this.isLive)
+            return {
+                current: 0,
+                total: 0,
+                format: "LIVE",
+                formatted: {
+                    current: "LIVE",
+                    total: "LIVE",
+                },
+            };
         const resource = this.currentResource;
         const track = this.queue.currentTrack;
-        if (!track || !resource)
+        if (!track || !resource) {
             return {
                 current: 0,
                 total: 0,
                 format: "00:00",
+                formatted: {
+                    current: "00:00",
+                    total: "00:00",
+                },
             };
+        }
         const total = track.duration > 1000 ? track.duration : track.duration * 1000;
+        const current = resource.playbackDuration;
         return {
-            current: resource?.playbackDuration,
+            current: current,
             total: total,
-            format: this.formatTime(resource.playbackDuration),
+            format: this.formatTime(current),
+            formatted: {
+                current: this.formatTimeCompact(current),
+                total: this.formatTimeCompact(total),
+            },
         };
     }
-    /**
-     * Format the time in the format of HH:MM:SS
-     *
-     * @param {number} ms - The time in milliseconds
-     * @returns {string} The formatted time
-     * @example
-     * const formattedTime = player.formatTime(1000);
-     * console.log(`Formatted time: ${formattedTime}`);
-     */
-    formatTime(ms) {
-        const totalSeconds = Math.floor(ms / 1000);
-        const hours = Math.floor(totalSeconds / 3600);
-        const minutes = Math.floor((totalSeconds % 3600) / 60);
-        const seconds = totalSeconds % 60;
-        const parts = [];
-        if (hours > 0)
-            parts.push(String(hours).padStart(2, "0"));
-        parts.push(String(minutes).padStart(2, "0"));
-        parts.push(String(seconds).padStart(2, "0"));
-        return parts.join(":");
-    }
     /**
      * Destroy the player
      *
@@ -1207,6 +1330,7 @@ class Player extends events_1.EventEmitter {
         }
         // Destroy current stream before stopping audio
         this.destroyCurrentStream();
+        this.audioPlayer.removeAllListeners();
         this.audioPlayer.stop(true);
         if (this.ttsPlayer) {
             try {
@@ -1240,7 +1364,7 @@ class Player extends events_1.EventEmitter {
         if (this.leaveTimeout) {
             clearTimeout(this.leaveTimeout);
         }
-        if (this.options.leaveOnEmpty && this.options.leaveTimeout) {
+        if (this.options.leaveOnEnd && this.options.leaveTimeout) {
             this.leaveTimeout = setTimeout(() => {
                 this.debug(`[Player] Leaving voice channel after timeoutMs`);
                 this.destroy();
@@ -1254,13 +1378,16 @@ class Player extends events_1.EventEmitter {
      * @param {number} position - Position to seek to in milliseconds
      * @returns {Promise<boolean>}
      * @example
-     * const refreshed = await player.refeshPlayerResource(true, 1000);
+     * const refreshed = await player.refreshPlayerResource(true, 1000);
      * console.log(`Refreshed: ${refreshed}`);
      */
-    async refeshPlayerResource(applyToCurrent = true, position = -1) {
+    async refreshPlayerResource(applyToCurrent = true, position = -1) {
         if (!applyToCurrent || !this.queue.currentTrack || !(this.isPlaying || this.isPaused)) {
             return false;
         }
+        if (this.refreshLock)
+            return false;
+        this.refreshLock = true;
         try {
             const track = this.queue.currentTrack;
             this.debug(`[Player] Refreshing player resource for track: ${track.title}`);
@@ -1287,7 +1414,10 @@ class Player extends events_1.EventEmitter {
                 }
             }
             catch (error) {
-                this.debug(`[Player] Error destroying old stream in refeshPlayerResource:`, error);
+                this.debug(`[Player] Error destroying old stream in refreshPlayerResource:`, error);
+            }
+            finally {
+                this.refreshLock = false;
             }
             this.currentResource = resource;
             // Subscribe to new resource
@@ -1404,6 +1534,19 @@ class Player extends events_1.EventEmitter {
             }
             else if (newState.status === voice_1.AudioPlayerStatus.Buffering) {
                 this.debug(`[Player] AudioPlayerStatus.Buffering`);
+                this.lastDuration = this.currentResource?.playbackDuration || 0;
+                this.stuckTimer = setTimeout(() => {
+                    if (this.currentResource?.playbackDuration === this.lastDuration) {
+                        this.emit("trackStuck", this.currentTrack);
+                        this.skip();
+                    }
+                }, 10000);
+            }
+            else {
+                if (this.stuckTimer) {
+                    clearTimeout(this.stuckTimer);
+                    this.stuckTimer = null;
+                }
             }
         });
         this.audioPlayer.on("error", (error) => {
@@ -1425,6 +1568,113 @@ class Player extends events_1.EventEmitter {
         this.debug(`[Player] Removing plugin: ${name}`);
         return this.pluginManager.unregister(name);
     }
+    /**
+     * Save the current session of the player, including queue, current track, position, volume, loop mode, auto-play mode, and active extensions/plugins.
+     *
+     * @returns {PlayerSession} The saved session data
+     */
+    saveSession() {
+        return {
+            guildId: this.guildId,
+            currentTrack: this.currentTrack,
+            position: this.currentResource?.playbackDuration || null,
+            volume: this.volume,
+            queue: this.queue.getTracks(),
+            loopMode: this.queue.loop(),
+            autoPlay: this.queue.autoPlay(),
+            extensions: this.extensionManager.getAll().map((ext) => ext.name),
+            plugins: this.pluginManager.getAll().map((plugin) => plugin.name),
+        };
+    }
+    /**
+     * Set persistence manager for auto-save
+     */
+    setPersistenceManager(manager) {
+        this.persistenceManager = manager;
+        this.startAutoSaveTracking();
+    }
+    startAutoSaveTracking() {
+        // Track state changes for auto-save
+        const trackChanges = () => {
+            this.scheduleAutoSave();
+        };
+        this.on("trackStart", trackChanges);
+        this.on("trackEnd", trackChanges);
+        this.on("queueAdd", trackChanges);
+        this.on("queueRemove", trackChanges);
+        this.on("volumeChange", trackChanges);
+        // Save periodically
+        setInterval(() => {
+            this.saveIfNeeded();
+        }, this.AUTO_SAVE_INTERVAL);
+    }
+    scheduleAutoSave() {
+        if (!this.persistenceManager)
+            return;
+        this.lastSaveTime = Date.now();
+        // Can implement debounced save here
+    }
+    async saveIfNeeded() {
+        if (!this.persistenceManager)
+            return;
+        if (Date.now() - this.lastSaveTime < this.AUTO_SAVE_INTERVAL)
+            return;
+        await this.persistenceManager.savePlayer(this);
+        this.lastSaveTime = Date.now();
+    }
+    /**
+     * Save current player state
+     */
+    async savePlayer() {
+        if (!this.persistenceManager) {
+            this.debug("[Player] No persistence manager configured");
+            return false;
+        }
+        return await this.persistenceManager.savePlayer(this);
+    }
+    /**
+     * Get serializable state (for manual persistence)
+     */
+    getSerializableState() {
+        return {
+            guildId: this.guildId,
+            queue: this.queue.getTracks(),
+            currentTrack: this.currentTrack,
+            volume: this.volume,
+            isPlaying: this.isPlaying,
+            isPaused: this.isPaused,
+            loopMode: this.queue.loop(),
+            autoPlay: this.queue.autoPlay(),
+            filters: this.filter.getFilterString(),
+            timestamp: Date.now(),
+        };
+    }
+    /**
+     * Restore from saved state
+     */
+    async restoreState(state) {
+        try {
+            if (state.volume)
+                this.setVolume(state.volume);
+            if (state.loopMode)
+                this.queue.loop(state.loopMode);
+            if (typeof state.autoPlay === "boolean")
+                this.queue.autoPlay(state.autoPlay);
+            if (state.filters)
+                await this.filter.applyFilters(state.filters.split(","));
+            // Restore queue
+            if (state.queue && Array.isArray(state.queue)) {
+                this.queue.clear();
+                this.queue.addMultiple(state.queue);
+            }
+            this.debug("[Player] State restored");
+            return true;
+        }
+        catch (error) {
+            this.debug("[Player] Failed to restore state:", error);
+            return false;
+        }
+    }
     //#endregion
     //#region Getters
     /**
@@ -1504,6 +1754,9 @@ class Player extends events_1.EventEmitter {
     get relatedTracks() {
         return this.queue.relatedTracks();
     }
+    get isLive() {
+        return this.currentTrack?.isLive === true;
+    }
 }
 exports.Player = Player;
 //# sourceMappingURL=Player.js.map