ziplayer 0.1.3 → 0.1.5

package/dist/structures/Player.js

@@ -201,6 +201,80 @@ class Player extends events_1.EventEmitter {
         }
         return null;
     }
+    async getStreamFromPlugin(track) {
+        let streamInfo = null;
+        const plugin = this.pluginManager.get(track.source) || this.pluginManager.findPlugin(track.url);
+        if (!plugin) {
+            this.debug(`[Player] No plugin found for track: ${track.title}`);
+            return null;
+        }
+        this.debug(`[Player] Getting stream for track: ${track.title}`);
+        this.debug(`[Player] Using plugin: ${plugin.name}`);
+        this.debug(`[Track] Track Info:`, track);
+        const timeoutMs = this.options.extractorTimeout ?? 50000;
+        try {
+            streamInfo = await (0, timeout_1.withTimeout)(plugin.getStream(track), timeoutMs, "getStream timed out");
+            if (!streamInfo?.stream) {
+                throw new Error(`No stream returned from ${plugin.name}`);
+            }
+        }
+        catch (streamError) {
+            this.debug(`[Player] getStream failed, trying getFallback:`, streamError);
+            const allplugs = this.pluginManager.getAll();
+            for (const p of allplugs) {
+                if (typeof p.getFallback !== "function" && typeof p.getStream !== "function") {
+                    continue;
+                }
+                try {
+                    streamInfo = await (0, timeout_1.withTimeout)(p.getStream(track), timeoutMs, `getStream timed out for plugin ${p.name}`);
+                    if (streamInfo?.stream) {
+                        this.debug(`[Player] getStream succeeded with plugin ${p.name} for track: ${track.title}`);
+                        break;
+                    }
+                    streamInfo = await (0, timeout_1.withTimeout)(p.getFallback(track), timeoutMs, `getFallback timed out for plugin ${p.name}`);
+                    if (!streamInfo?.stream)
+                        continue;
+                    break;
+                }
+                catch (fallbackError) {
+                    this.debug(`[Player] getFallback failed with plugin ${p.name}:`, fallbackError);
+                }
+            }
+            if (!streamInfo?.stream) {
+                throw new Error(`All getFallback attempts failed for track: ${track.title}`);
+            }
+        }
+        return streamInfo;
+    }
+    async Audioresource(streamInfo, track) {
+        function mapToStreamType(type) {
+            switch (type) {
+                case "webm/opus":
+                    return voice_1.StreamType.WebmOpus;
+                case "ogg/opus":
+                    return voice_1.StreamType.OggOpus;
+                case "arbitrary":
+                default:
+                    return voice_1.StreamType.Arbitrary;
+            }
+        }
+        const stream = streamInfo.stream;
+        const inputType = mapToStreamType(streamInfo.type);
+        const resource = (0, voice_1.createAudioResource)(stream, {
+            metadata: track ?? {
+                title: streamInfo.metadata?.title ?? "",
+                duration: streamInfo.metadata?.duration ?? 0,
+                source: streamInfo.metadata?.source ?? "",
+                requestedBy: streamInfo.metadata?.requestedBy ?? "",
+                thumbnail: streamInfo.metadata?.thumbnail ?? "",
+                url: streamInfo.metadata?.url ?? "",
+                id: streamInfo.metadata?.id ?? "",
+            },
+            inputType,
+            inlineVolume: true,
+        });
+        return resource;
+    }
     /**
      * Start playing a specific track immediately, replacing the current resource.
      */
@@ -209,70 +283,17 @@ class Player extends events_1.EventEmitter {
             let streamInfo = await this.extensionsProvideStream(track);
             let plugin;
             if (!streamInfo) {
-                plugin = this.pluginManager.findPlugin(track.url) || this.pluginManager.get(track.source);
-                if (!plugin) {
-                    this.debug(`[Player] No plugin found for track: ${track.title}`);
-                    throw new Error(`No plugin found for track: ${track.title}`);
-                }
-                this.debug(`[Player] Getting stream for track: ${track.title}`);
-                this.debug(`[Player] Using plugin: ${plugin.name}`);
-                this.debug(`[Track] Track Info:`, track);
-                try {
-                    streamInfo = await (0, timeout_1.withTimeout)(plugin.getStream(track), this.options.extractorTimeout ?? 15000, "getStream timed out");
-                }
-                catch (streamError) {
-                    this.debug(`[Player] getStream failed, trying getFallback:`, streamError);
-                    const allplugs = this.pluginManager.getAll();
-                    for (const p of allplugs) {
-                        if (typeof p.getFallback !== "function" && typeof p.getStream !== "function") {
-                            continue;
-                        }
-                        try {
-                            streamInfo = await (0, timeout_1.withTimeout)(p.getStream(track), this.options.extractorTimeout ?? 15000, `getStream timed out for plugin ${p.name}`);
-                            if (streamInfo?.stream) {
-                                this.debug(`[Player] getStream succeeded with plugin ${p.name} for track: ${track.title}`);
-                                break;
-                            }
-                            streamInfo = await (0, timeout_1.withTimeout)(p.getFallback(track), this.options.extractorTimeout ?? 15000, `getFallback timed out for plugin ${p.name}`);
-                            if (!streamInfo?.stream)
-                                continue;
-                            break;
-                        }
-                        catch (fallbackError) {
-                            this.debug(`[Player] getFallback failed with plugin ${p.name}:`, fallbackError);
-                        }
-                    }
-                    if (!streamInfo?.stream) {
-                        throw new Error(`All getFallback attempts failed for track: ${track.title}`);
-                    }
+                streamInfo = await this.getStreamFromPlugin(track);
+                if (!streamInfo) {
+                    throw new Error(`No stream available for track: ${track.title}`);
                 }
             }
             else {
                 this.debug(`[Player] Using extension-provided stream for track: ${track.title}`);
             }
-            if (plugin) {
-                this.debug(streamInfo);
-            }
             // Kiểm tra nếu có stream thực sự để tạo AudioResource
             if (streamInfo && streamInfo.stream) {
-                function mapToStreamType(type) {
-                    switch (type) {
-                        case "webm/opus":
-                            return voice_1.StreamType.WebmOpus;
-                        case "ogg/opus":
-                            return voice_1.StreamType.OggOpus;
-                        case "arbitrary":
-                        default:
-                            return voice_1.StreamType.Arbitrary;
-                    }
-                }
-                const stream = streamInfo.stream;
-                const inputType = mapToStreamType(streamInfo.type);
-                this.currentResource = (0, voice_1.createAudioResource)(stream, {
-                    metadata: track,
-                    inputType,
-                    inlineVolume: true,
-                });
+                this.currentResource = await this.Audioresource(streamInfo, track);
                 // Apply initial volume using the resource's VolumeTransformer
                 if (this.volumeInterval) {
                     clearInterval(this.volumeInterval);
@@ -306,7 +327,7 @@ class Player extends events_1.EventEmitter {
         if (this.leaveTimeout) {
             clearTimeout(this.leaveTimeout);
             this.leaveTimeout = null;
-            this.debug(`[Player] Cleared leave timeout`);
+            this.debug(`[Player] Cleared leave timeoutMs`);
         }
     }
     debug(message, ...optionalParams) {
@@ -325,18 +346,12 @@ class Player extends events_1.EventEmitter {
         this.volumeInterval = null;
         this.skipLoop = false;
         this.extensions = [];
-        // Cache for plugin matching to improve performance
-        this.pluginCache = new Map();
-        this.PLUGIN_CACHE_TTL = 5 * 60 * 1000; // 5 minutes
-        this.pluginCacheTimestamps = new Map();
         // Cache for search results to avoid duplicate calls
         this.searchCache = new Map();
         this.SEARCH_CACHE_TTL = 2 * 60 * 1000; // 2 minutes
         this.searchCacheTimestamps = new Map();
         // TTS support
         this.ttsPlayer = null;
-        this.ttsQueue = [];
-        this.ttsActive = false;
         this.debug(`[Player] Constructor called for guildId: ${guildId}`);
         this.guildId = guildId;
         this.queue = new Queue_1.Queue();
@@ -563,60 +578,91 @@ class Player extends events_1.EventEmitter {
         throw new Error(`No plugin found to handle: ${query}`);
     }
     /**
-     * Play a track or search query
+     * Play a track, search query, search result, or play from queue
      *
-     * @param {string | Track} query - Track URL, search query, or Track object
+     * @param {string | Track | SearchResult | null} query - Track URL, search query, Track object, SearchResult, or null for play
      * @param {string} requestedBy - User ID who requested the track
      * @returns {Promise<boolean>} True if playback started successfully
      * @example
-     * await player.play("Never Gonna Give You Up", userId);
-     * await player.play("https://youtube.com/watch?v=dQw4w9WgXcQ", userId);
-     * await player.play("tts: Hello everyone!", userId);
+     * await player.play("Never Gonna Give You Up", userId); // Search query
+     * await player.play("https://youtube.com/watch?v=dQw4w9WgXcQ", userId); // Direct URL
+     * await player.play("tts: Hello everyone!", userId); // Text-to-Speech
+     * await player.play(trackObject, userId); // Track object
+     * await player.play(searchResult, userId); // SearchResult object
+     * await player.play(null); // play from queue
      */
     async play(query, requestedBy) {
-        this.debug(`[Player] Play called with query: ${typeof query === "string" ? query : query?.title}`);
+        const debugInfo = query === null ? "null"
+            : typeof query === "string" ? query
+                : "tracks" in query ? `${query.tracks.length} tracks`
+                    : query.title || "unknown";
+        this.debug(`[Player] Play called with query: ${debugInfo}`);
         this.clearLeaveTimeout();
         let tracksToAdd = [];
         let isPlaylist = false;
-        let effectiveRequest = { query, requestedBy };
+        let effectiveRequest = { query: query, requestedBy };
         let hookResponse = {};
         try {
-            const hookOutcome = await this.runBeforePlayHooks(effectiveRequest);
-            effectiveRequest = hookOutcome.request;
-            hookResponse = hookOutcome.response;
-            if (effectiveRequest.requestedBy === undefined) {
-                effectiveRequest.requestedBy = requestedBy;
-            }
-            const hookTracks = Array.isArray(hookResponse.tracks) ? hookResponse.tracks : undefined;
-            if (hookResponse.handled && (!hookTracks || hookTracks.length === 0)) {
-                const handledPayload = {
-                    success: hookResponse.success ?? true,
-                    query: effectiveRequest.query,
-                    requestedBy: effectiveRequest.requestedBy,
-                    tracks: [],
-                    isPlaylist: hookResponse.isPlaylist ?? false,
-                    error: hookResponse.error,
-                };
-                await this.runAfterPlayHooks(handledPayload);
-                if (hookResponse.error) {
-                    this.emit("playerError", hookResponse.error);
+            // Handle null query - play from queue
+            if (query === null) {
+                this.debug(`[Player] Play from queue requested`);
+                if (this.queue.isEmpty) {
+                    this.debug(`[Player] Queue is empty, nothing to play`);
+                    return false;
                 }
-                return hookResponse.success ?? true;
-            }
-            if (hookTracks && hookTracks.length > 0) {
-                tracksToAdd = hookTracks;
-                isPlaylist = hookResponse.isPlaylist ?? hookTracks.length > 1;
+                if (!this.isPlaying) {
+                    return await this.playNext();
+                }
+                return true;
             }
-            else if (typeof effectiveRequest.query === "string") {
-                const searchResult = await this.search(effectiveRequest.query, effectiveRequest.requestedBy || "Unknown");
-                tracksToAdd = searchResult.tracks;
-                if (searchResult.playlist) {
-                    isPlaylist = true;
-                    this.debug(`[Player] Added playlist: ${searchResult.playlist.name} (${tracksToAdd.length} tracks)`);
+            // Handle SearchResult
+            if (query && typeof query === "object" && "tracks" in query && Array.isArray(query.tracks)) {
+                this.debug(`[Player] Playing SearchResult with ${query.tracks.length} tracks`);
+                tracksToAdd = query.tracks;
+                isPlaylist = !!query.playlist || query.tracks.length > 1;
+                if (query.playlist) {
+                    this.debug(`[Player] Added playlist: ${query.playlist.name} (${tracksToAdd.length} tracks)`);
                 }
             }
-            else if (effectiveRequest.query) {
-                tracksToAdd = [effectiveRequest.query];
+            else {
+                // Handle other types (string, Track)
+                const hookOutcome = await this.runBeforePlayHooks(effectiveRequest);
+                effectiveRequest = hookOutcome.request;
+                hookResponse = hookOutcome.response;
+                if (effectiveRequest.requestedBy === undefined) {
+                    effectiveRequest.requestedBy = requestedBy;
+                }
+                const hookTracks = Array.isArray(hookResponse.tracks) ? hookResponse.tracks : undefined;
+                if (hookResponse.handled && (!hookTracks || hookTracks.length === 0)) {
+                    const handledPayload = {
+                        success: hookResponse.success ?? true,
+                        query: effectiveRequest.query,
+                        requestedBy: effectiveRequest.requestedBy,
+                        tracks: [],
+                        isPlaylist: hookResponse.isPlaylist ?? false,
+                        error: hookResponse.error,
+                    };
+                    await this.runAfterPlayHooks(handledPayload);
+                    if (hookResponse.error) {
+                        this.emit("playerError", hookResponse.error);
+                    }
+                    return hookResponse.success ?? true;
+                }
+                if (hookTracks && hookTracks.length > 0) {
+                    tracksToAdd = hookTracks;
+                    isPlaylist = hookResponse.isPlaylist ?? hookTracks.length > 1;
+                }
+                else if (typeof effectiveRequest.query === "string") {
+                    const searchResult = await this.search(effectiveRequest.query, effectiveRequest.requestedBy || "Unknown");
+                    tracksToAdd = searchResult.tracks;
+                    if (searchResult.playlist) {
+                        isPlaylist = true;
+                        this.debug(`[Player] Added playlist: ${searchResult.playlist.name} (${tracksToAdd.length} tracks)`);
+                    }
+                }
+                else if (effectiveRequest.query) {
+                    tracksToAdd = [effectiveRequest.query];
+                }
             }
             if (tracksToAdd.length === 0) {
                 this.debug(`[Player] No tracks found for play`);
@@ -690,49 +736,39 @@ class Player extends events_1.EventEmitter {
      * await player.interruptWithTTSTrack(track);
      */
     async interruptWithTTSTrack(track) {
-        this.ttsQueue.push(track);
-        if (!this.ttsActive) {
-            void this.playNextTTS();
-        }
-    }
-    /**
-     * Play queued TTS items sequentially
-     *
-     * @returns {Promise<void>}
-     * @example
-     * await player.playNextTTS();
-     */
-    async playNextTTS() {
-        const next = this.ttsQueue.shift();
-        if (!next)
-            return;
-        this.ttsActive = true;
+        const wasPlaying = this.audioPlayer.state.status === voice_1.AudioPlayerStatus.Playing ||
+            this.audioPlayer.state.status === voice_1.AudioPlayerStatus.Buffering;
         try {
             if (!this.connection)
                 throw new Error("No voice connection for TTS");
             const ttsPlayer = this.ensureTTSPlayer();
             // Build resource from plugin stream
-            const resource = await this.resourceFromTrack(next);
+            const streamInfo = await this.getStreamFromPlugin(track);
+            if (!streamInfo) {
+                throw new Error("No stream available for track: ${track.title}");
+            }
+            const resource = await this.Audioresource(streamInfo, track);
+            if (!resource) {
+                throw new Error("No resource available for track: ${track.title}");
+            }
             if (resource.volume) {
                 resource.volume.setVolume((this.options?.tts?.volume ?? this?.volume ?? 100) / 100);
             }
-            const wasPlaying = this.audioPlayer.state.status === voice_1.AudioPlayerStatus.Playing ||
-                this.audioPlayer.state.status === voice_1.AudioPlayerStatus.Buffering;
             // Pause current music if any
             try {
-                this.audioPlayer.pause(true);
+                this.pause();
             }
             catch { }
             // Swap subscription and play TTS
             this.connection.subscribe(ttsPlayer);
-            this.emit("ttsStart", { track: next });
+            this.emit("ttsStart", { track });
             ttsPlayer.play(resource);
             // Wait until TTS starts then finishes
             await (0, voice_1.entersState)(ttsPlayer, voice_1.AudioPlayerStatus.Playing, 5000).catch(() => null);
-            // Derive timeout from resource/track duration when available, with a sensible cap
+            // Derive timeoutMs from resource/track duration when available, with a sensible cap
             const md = resource?.metadata ?? {};
             const declared = typeof md.duration === "number" ? md.duration
-                : typeof next?.duration === "number" ? next.duration
+                : typeof track?.duration === "number" ? track.duration
                     : undefined;
             const declaredMs = declared ?
                 declared > 1000 ?
@@ -744,97 +780,20 @@ class Player extends events_1.EventEmitter {
             await (0, voice_1.entersState)(ttsPlayer, voice_1.AudioPlayerStatus.Idle, idleTimeout).catch(() => null);
             // Swap back and resume if needed
             this.connection.subscribe(this.audioPlayer);
-            if (wasPlaying) {
-                try {
-                    this.audioPlayer.unpause();
-                }
-                catch { }
-            }
-            this.emit("ttsEnd");
         }
         catch (err) {
             this.debug("[TTS] error while playing:", err);
             this.emit("playerError", err);
         }
         finally {
-            this.ttsActive = false;
-            if (this.ttsQueue.length > 0) {
-                await this.playNextTTS();
-            }
-        }
-    }
-    /**
-     * Get cached plugin or find and cache a new one
-     * @param track The track to find plugin for
-     * @returns The matching plugin or null if not found
-     */
-    getCachedPlugin(track) {
-        const cacheKey = `${track.source}:${track.url}`;
-        const now = Date.now();
-        // Check if cache is still valid
-        const cachedTimestamp = this.pluginCacheTimestamps.get(cacheKey);
-        if (cachedTimestamp && now - cachedTimestamp < this.PLUGIN_CACHE_TTL) {
-            const cachedPlugin = this.pluginCache.get(cacheKey);
-            if (cachedPlugin) {
-                this.debug(`[PluginCache] Using cached plugin for ${track.source}: ${cachedPlugin.name}`);
-                return cachedPlugin;
-            }
-        }
-        // Find new plugin and cache it
-        this.debug(`[PluginCache] Finding plugin for track: ${track.title} (${track.source})`);
-        const plugin = this.pluginManager.findPlugin(track.url) || this.pluginManager.get(track.source);
-        if (plugin) {
-            this.pluginCache.set(cacheKey, plugin);
-            this.pluginCacheTimestamps.set(cacheKey, now);
-            this.debug(`[PluginCache] Cached plugin: ${plugin.name} for ${track.source}`);
-            return plugin;
-        }
-        return null;
-    }
-    /**
-     * Clear expired cache entries
-     */
-    clearExpiredCache() {
-        const now = Date.now();
-        for (const [key, timestamp] of this.pluginCacheTimestamps.entries()) {
-            if (now - timestamp >= this.PLUGIN_CACHE_TTL) {
-                this.pluginCache.delete(key);
-                this.pluginCacheTimestamps.delete(key);
-                this.debug(`[PluginCache] Cleared expired cache entry: ${key}`);
-            }
-        }
-    }
-    /**
-     * Clear all plugin cache entries
-     * @example
-     * player.clearPluginCache();
-     */
-    clearPluginCache() {
-        const cacheSize = this.pluginCache.size;
-        this.pluginCache.clear();
-        this.pluginCacheTimestamps.clear();
-        this.debug(`[PluginCache] Cleared all ${cacheSize} cache entries`);
-    }
-    /**
-     * Get plugin cache statistics
-     * @returns Cache statistics
-     * @example
-     * const stats = player.getPluginCacheStats();
-     * console.log(`Cache size: ${stats.size}, Hit rate: ${stats.hitRate}%`);
-     */
-    getPluginCacheStats() {
-        const now = Date.now();
-        let expiredEntries = 0;
-        for (const timestamp of this.pluginCacheTimestamps.values()) {
-            if (now - timestamp >= this.PLUGIN_CACHE_TTL) {
-                expiredEntries++;
+            if (wasPlaying) {
+                try {
+                    this.resume();
+                }
+                catch { }
             }
+            this.emit("ttsEnd");
         }
-        return {
-            size: this.pluginCache.size,
-            hitRate: 0, // Would need to track hits/misses to calculate this
-            expiredEntries,
-        };
     }
     /**
      * Get cached search result or null if not found/expired
@@ -890,31 +849,6 @@ class Player extends events_1.EventEmitter {
         this.searchCacheTimestamps.clear();
         this.debug(`[SearchCache] Cleared all ${cacheSize} search cache entries`);
     }
-    /**
-     * Get search cache statistics
-     * @returns Search cache statistics
-     * @example
-     * const stats = player.getSearchCacheStats();
-     * console.log(`Search cache size: ${stats.size}, Expired: ${stats.expiredEntries}`);
-     */
-    getSearchCacheStats() {
-        const now = Date.now();
-        let expiredEntries = 0;
-        const queries = [];
-        for (const [key, timestamp] of this.searchCacheTimestamps.entries()) {
-            if (now - timestamp >= this.SEARCH_CACHE_TTL) {
-                expiredEntries++;
-            }
-            else {
-                queries.push(key);
-            }
-        }
-        return {
-            size: this.searchCache.size,
-            expiredEntries,
-            queries,
-        };
-    }
     /**
      * Debug method to check for duplicate search calls
      * @param query The search query to check
@@ -939,114 +873,6 @@ class Player extends events_1.EventEmitter {
             ttsFiltered: allPlugins.length > plugins.length,
         };
     }
-    /** Build AudioResource for a given track using the plugin pipeline */
-    async resourceFromTrack(track) {
-        this.debug(`[ResourceFromTrack] Starting resource creation for track: ${track.title} (${track.source})`);
-        // Clear expired cache entries periodically
-        if (Math.random() < 0.1) {
-            // 10% chance to clean cache
-            this.clearExpiredCache();
-        }
-        // Resolve plugin using cache
-        const plugin = this.getCachedPlugin(track);
-        if (!plugin) {
-            this.debug(`[ResourceFromTrack] No plugin found for track: ${track.title} (${track.source})`);
-            throw new Error(`No plugin found for track: ${track.title}`);
-        }
-        this.debug(`[ResourceFromTrack] Using plugin: ${plugin.name} for track: ${track.title}`);
-        let streamInfo = null;
-        const timeoutMs = this.options.extractorTimeout ?? 15000;
-        try {
-            this.debug(`[ResourceFromTrack] Attempting getStream with ${plugin.name}, timeout: ${timeoutMs}ms`);
-            const startTime = Date.now();
-            streamInfo = await (0, timeout_1.withTimeout)(plugin.getStream(track), timeoutMs, "getStream timed out");
-            const duration = Date.now() - startTime;
-            this.debug(`[ResourceFromTrack] getStream successful with ${plugin.name} in ${duration}ms`);
-            if (!streamInfo?.stream) {
-                this.debug(`[ResourceFromTrack] getStream returned no stream from ${plugin.name}`);
-                throw new Error(`No stream returned from ${plugin.name}`);
-            }
-        }
-        catch (streamError) {
-            const errorMessage = streamError instanceof Error ? streamError.message : String(streamError);
-            this.debug(`[ResourceFromTrack] getStream failed with ${plugin.name}: ${errorMessage}`);
-            // Log more details for debugging
-            if (streamError instanceof Error && streamError.stack) {
-                this.debug(`[ResourceFromTrack] getStream error stack:`, streamError.stack);
-            }
-            // try fallbacks
-            this.debug(`[ResourceFromTrack] Attempting fallback plugins for track: ${track.title}`);
-            const allplugs = this.pluginManager.getAll();
-            let fallbackAttempts = 0;
-            for (const p of allplugs) {
-                if (typeof p.getFallback !== "function" && typeof p.getStream !== "function") {
-                    this.debug(`[ResourceFromTrack] Skipping plugin ${p.name} - no getFallback or getStream method`);
-                    continue;
-                }
-                fallbackAttempts++;
-                this.debug(`[ResourceFromTrack] Trying fallback plugin ${p.name} (attempt ${fallbackAttempts})`);
-                try {
-                    // Try getStream first
-                    const startTime = Date.now();
-                    streamInfo = await (0, timeout_1.withTimeout)(p.getStream(track), timeoutMs, "getStream timed out");
-                    const duration = Date.now() - startTime;
-                    if (streamInfo?.stream) {
-                        this.debug(`[ResourceFromTrack] Fallback getStream successful with ${p.name} in ${duration}ms`);
-                        break;
-                    }
-                    // Try getFallback if getStream didn't work
-                    this.debug(`[ResourceFromTrack] Trying getFallback with ${p.name}`);
-                    const fallbackStartTime = Date.now();
-                    streamInfo = await (0, timeout_1.withTimeout)(p.getFallback(track), timeoutMs, `getFallback timed out for plugin ${p.name}`);
-                    const fallbackDuration = Date.now() - fallbackStartTime;
-                    if (streamInfo?.stream) {
-                        this.debug(`[ResourceFromTrack] Fallback getFallback successful with ${p.name} in ${fallbackDuration}ms`);
-                        break;
-                    }
-                    this.debug(`[ResourceFromTrack] Fallback plugin ${p.name} returned no stream`);
-                }
-                catch (fallbackError) {
-                    const errorMessage = fallbackError instanceof Error ? fallbackError.message : String(fallbackError);
-                    this.debug(`[ResourceFromTrack] Fallback plugin ${p.name} failed: ${errorMessage}`);
-                    // Log more details for debugging
-                    if (fallbackError instanceof Error && fallbackError.stack) {
-                        this.debug(`[ResourceFromTrack] Fallback error stack:`, fallbackError.stack);
-                    }
-                }
-            }
-            if (!streamInfo?.stream) {
-                this.debug(`[ResourceFromTrack] All ${fallbackAttempts} fallback attempts failed for track: ${track.title}`);
-                throw new Error(`All getFallback attempts failed for track: ${track.title}`);
-            }
-        }
-        this.debug(`[ResourceFromTrack] Stream obtained, type: ${streamInfo.type}, metadata keys: ${Object.keys(streamInfo.metadata || {}).join(", ")}`);
-        const mapToStreamType = (type) => {
-            switch (type) {
-                case "webm/opus":
-                    return voice_1.StreamType.WebmOpus;
-                case "ogg/opus":
-                    return voice_1.StreamType.OggOpus;
-                case "arbitrary":
-                default:
-                    return voice_1.StreamType.Arbitrary;
-            }
-        };
-        const inputType = mapToStreamType(streamInfo.type);
-        this.debug(`[ResourceFromTrack] Creating AudioResource with inputType: ${inputType}`);
-        // Merge metadata safely
-        const mergedMetadata = {
-            ...track,
-            ...(streamInfo.metadata || {}),
-        };
-        const audioResource = (0, voice_1.createAudioResource)(streamInfo.stream, {
-            // Prefer plugin-provided metadata (e.g., precise duration), fallback to track fields
-            metadata: mergedMetadata,
-            inputType,
-            inlineVolume: true,
-        });
-        this.debug(`[ResourceFromTrack] AudioResource created successfully for track: ${track.title}`);
-        return audioResource;
-    }
     async generateWillNext() {
         const lastTrack = this.queue.previousTracks[this.queue.previousTracks.length - 1] ?? this.queue.currentTrack;
         if (!lastTrack)
@@ -1168,20 +994,46 @@ class Player extends events_1.EventEmitter {
         return result;
     }
     /**
-     * Skip to the next track
+     * Skip to the next track or skip to a specific index
      *
+     * @param {number} index - Optional index to skip to (0 = next track)
      * @returns {boolean} True if skipped successfully
      * @example
-     * const skipped = player.skip();
+     * const skipped = player.skip(); // Skip to next track
+     * const skippedToIndex = player.skip(2); // Skip to track at index 2
      * console.log(`Skipped: ${skipped}`);
      */
-    skip() {
-        this.debug(`[Player] skip called`);
-        if (this.isPlaying || this.isPaused) {
-            this.skipLoop = true;
-            return this.audioPlayer.stop();
+    skip(index) {
+        this.debug(`[Player] skip called with index: ${index}`);
+        try {
+            if (typeof index === "number" && index >= 0) {
+                // Skip to specific index
+                const targetTrack = this.queue.getTrack(index);
+                if (!targetTrack) {
+                    this.debug(`[Player] No track found at index ${index}`);
+                    return false;
+                }
+                // Remove tracks from 0 to index-1
+                for (let i = 0; i < index; i++) {
+                    this.queue.remove(0);
+                }
+                this.debug(`[Player] Skipped to track at index ${index}: ${targetTrack.title}`);
+                if (this.isPlaying || this.isPaused) {
+                    this.skipLoop = true;
+                    return this.audioPlayer.stop();
+                }
+                return true;
+            }
+            if (this.isPlaying || this.isPaused) {
+                this.skipLoop = true;
+                return this.audioPlayer.stop();
+            }
+            return true;
+        }
+        catch (error) {
+            this.debug(`[Player] skip error:`, error);
+            return false;
         }
-        return !!this.playNext();
     }
     /**
      * Go back to the previous track in history and play it.
@@ -1202,15 +1054,35 @@ class Player extends events_1.EventEmitter {
         return this.startTrack(track);
     }
     /**
-     * Loop the current track
+     * Loop the current track or queue
      *
-     * @param {LoopMode} mode - The loop mode to set
+     * @param {LoopMode | number} mode - The loop mode to set ("off", "track", "queue") or number (0=off, 1=track, 2=queue)
      * @returns {LoopMode} The loop mode
      * @example
-     * const loopMode = player.loop("track");
+     * const loopMode = player.loop("track"); // Loop current track
+     * const loopQueue = player.loop("queue"); // Loop entire queue
+     * const loopTrack = player.loop(1); // Loop current track (same as "track")
+     * const loopQueueNum = player.loop(2); // Loop entire queue (same as "queue")
+     * const noLoop = player.loop("off"); // No loop
+     * const noLoopNum = player.loop(0); // No loop (same as "off")
      * console.log(`Loop mode: ${loopMode}`);
      */
     loop(mode) {
+        this.debug(`[Player] loop called with mode: ${mode}`);
+        if (typeof mode === "number") {
+            // Number mode: convert to text mode
+            switch (mode) {
+                case 0:
+                    return this.queue.loop("off");
+                case 1:
+                    return this.queue.loop("track");
+                case 2:
+                    return this.queue.loop("queue");
+                default:
+                    this.debug(`[Player] Invalid loop number: ${mode}, using "off"`);
+                    return this.queue.loop("off");
+            }
+        }
         return this.queue.loop(mode);
     }
     /**
@@ -1429,7 +1301,7 @@ class Player extends events_1.EventEmitter {
         }
         if (this.options.leaveOnEmpty && this.options.leaveTimeout) {
             this.leaveTimeout = setTimeout(() => {
-                this.debug(`[Player] Leaving voice channel after timeout`);
+                this.debug(`[Player] Leaving voice channel after timeoutMs`);
                 this.destroy();
             }, this.options.leaveTimeout);
         }
@@ -1550,6 +1422,111 @@ class Player extends events_1.EventEmitter {
     get relatedTracks() {
         return this.queue.relatedTracks();
     }
+    /**
+     * Save a track's stream to a file and return a Readable stream
+     *
+     * @param {Track} track - The track to save
+     * @param {SaveOptions | string} options - Save options or filename string (for backward compatibility)
+     * @returns {Promise<Readable>} A Readable stream containing the audio data
+     * @example
+     * // Save current track to file
+     * const track = player.currentTrack;
+     * if (track) {
+     *   const stream = await player.save(track);
+     *
+     *   // Use fs to write the stream to file
+     *   const fs = require('fs');
+     *   const writeStream = fs.createWriteStream('saved-song.mp3');
+     *   stream.pipe(writeStream);
+     *
+     *   writeStream.on('finish', () => {
+     *     console.log('File saved successfully!');
+     *   });
+     * }
+     *
+     * // Save any track by URL
+     * const searchResult = await player.search("Never Gonna Give You Up", userId);
+     * if (searchResult.tracks.length > 0) {
+     *   const stream = await player.save(searchResult.tracks[0]);
+     *   // Handle the stream...
+     * }
+     *
+     * // Backward compatibility - filename as string
+     * const stream = await player.save(track, "my-song.mp3");
+     */
+    async save(track, options) {
+        this.debug(`[Player] save called for track: ${track.title}`);
+        // Parse options - support both SaveOptions object and filename string (backward compatibility)
+        let saveOptions = {};
+        if (typeof options === "string") {
+            saveOptions = { filename: options };
+        }
+        else if (options) {
+            saveOptions = options;
+        }
+        // Use timeout from options or fallback to player's extractorTimeout
+        const timeout = saveOptions.timeout ?? this.options.extractorTimeout ?? 15000;
+        try {
+            // Try extensions first
+            let streamInfo = await this.extensionsProvideStream(track);
+            let plugin;
+            if (!streamInfo) {
+                plugin = this.pluginManager.findPlugin(track.url) || this.pluginManager.get(track.source);
+                if (!plugin) {
+                    this.debug(`[Player] No plugin found for track: ${track.title}`);
+                    throw new Error(`No plugin found for track: ${track.title}`);
+                }
+                this.debug(`[Player] Getting save stream for track: ${track.title}`);
+                this.debug(`[Player] Using save plugin: ${plugin.name}`);
+                try {
+                    streamInfo = await (0, timeout_1.withTimeout)(plugin.getStream(track), timeout, "getSaveStream timed out");
+                }
+                catch (streamError) {
+                    this.debug(`[Player] getSaveStream failed, trying getFallback:`, streamError);
+                    const allplugs = this.pluginManager.getAll();
+                    for (const p of allplugs) {
+                        if (typeof p.getFallback !== "function" && typeof p.getStream !== "function") {
+                            continue;
+                        }
+                        try {
+                            streamInfo = await (0, timeout_1.withTimeout)(p.getStream(track), timeout, `getSaveStream timed out for plugin ${p.name}`);
+                            if (streamInfo?.stream) {
+                                this.debug(`[Player] getSaveStream succeeded with plugin ${p.name} for track: ${track.title}`);
+                                break;
+                            }
+                            streamInfo = await (0, timeout_1.withTimeout)(p.getFallback(track), timeout, `getSaveFallback timed out for plugin ${p.name}`);
+                            if (!streamInfo?.stream)
+                                continue;
+                            break;
+                        }
+                        catch (fallbackError) {
+                            this.debug(`[Player] getSaveFallback failed with plugin ${p.name}:`, fallbackError);
+                        }
+                    }
+                    if (!streamInfo?.stream) {
+                        throw new Error(`All getSaveFallback attempts failed for track: ${track.title}`);
+                    }
+                }
+            }
+            else {
+                this.debug(`[Player] Using extension-provided save stream for track: ${track.title}`);
+            }
+            if (!streamInfo || !streamInfo.stream) {
+                throw new Error(`No save stream available for track: ${track.title}`);
+            }
+            this.debug(`[Player] Save stream obtained for track: ${track.title}`);
+            if (saveOptions.filename) {
+                this.debug(`[Player] Save options - filename: ${saveOptions.filename}, quality: ${saveOptions.quality || "default"}`);
+            }
+            // Return the stream directly - caller can pipe it to fs.createWriteStream()
+            return streamInfo.stream;
+        }
+        catch (error) {
+            this.debug(`[Player] save error:`, error);
+            this.emit("playerError", error, track);
+            throw error;
+        }
+    }
 }
 exports.Player = Player;
 //# sourceMappingURL=Player.js.map