ziplayer 0.2.7 → 0.3.0

package/dist/plugins/index.js

@@ -23,12 +23,12 @@ function similarity(a, b) {
         return 0;
     const dist = levenshtein(a, b);
     const maxLen = Math.max(a.length, b.length);
-    return 1 - dist / maxLen; // 0 → 1
+    return 1 - dist / maxLen;
 }
 function normalize(str) {
     return str
         .toLowerCase()
-        .replace(/\(.*?\)|\[.*?\]/g, "") // remove (remix), [lyrics]
+        .replace(/\(.*?\)|\[.*?\]/g, "")
         .replace(/[^a-z0-9\s]/g, "")
         .replace(/\s+/g, " ")
         .trim();
@@ -38,46 +38,49 @@ const NON_MUSIC_KEYWORDS = ["reaction", "review", "podcast", "interview", "vlog"
 function detectContentType(title) {
     const t = title.toLowerCase();
     let score = 0;
-    for (const k of MUSIC_KEYWORDS) {
+    for (const k of MUSIC_KEYWORDS)
         if (t.includes(k))
             score += 2;
-    }
-    for (const k of NON_MUSIC_KEYWORDS) {
+    for (const k of NON_MUSIC_KEYWORDS)
         if (t.includes(k))
             score -= 3;
-    }
     return score;
 }
 function tokenOverlap(a, b) {
     const setA = new Set(a.split(" "));
     const setB = new Set(b.split(" "));
     let match = 0;
-    for (const word of setA) {
+    for (const word of setA)
         if (setB.has(word))
             match++;
-    }
     return match / Math.max(setA.size, setB.size);
 }
 function scoreTrack(base, candidate) {
     const titleA = normalize(base.title);
     const titleB = normalize(candidate.title);
     let score = 0;
-    // ===== FUZZY =====
-    const sim = similarity(titleA, titleB); // 0 → 1
-    score += sim * 50;
-    // ===== TOKEN MATCH =====
+    score += similarity(titleA, titleB) * 50;
     score += tokenOverlap(titleA, titleB) * 30;
-    // ===== CONTENT TYPE =====
     score += detectContentType(candidate.title);
     return score;
 }
-// Plugin factory
 class PluginManager {
     constructor(player, manager, options) {
         this.plugins = new Map();
+        this.streamCache = new Map();
+        this.searchCache = new Map();
+        this.STREAM_CACHE_TTL = 5 * 60 * 1000; // 5 minutes
+        this.pendingStreams = new Map(); // Dedupe in-flight requests
+        this.pendingSearches = new Map(); // Dedupe search requests
         this.player = player;
         this.manager = manager;
-        this.options = options;
+        this.options = {
+            maxFallbackAttempts: 3,
+            enableCache: true,
+            searchMinScore: 30,
+            searchCacheTTL: 2 * 60 * 1000, // 2 minutes
+            ...options,
+        };
     }
     debug(message, ...optionalParams) {
         if (this.manager.debugEnabled) {
@@ -85,158 +88,686 @@ class PluginManager {
         }
     }
     register(plugin) {
+        if (this.plugins.has(plugin.name)) {
+            this.debug(`Overwriting existing plugin: ${plugin.name}`);
+        }
+        plugin.priority ??= 0;
         this.plugins.set(plugin.name, plugin);
+        this.debug(`Registered plugin: ${plugin.name} (priority: ${plugin.priority})`);
     }
     unregister(name) {
-        return this.plugins.delete(name);
+        const removed = this.plugins.delete(name);
+        if (removed)
+            this.debug(`Unregistered plugin: ${name}`);
+        return removed;
     }
     get(name) {
         return this.plugins.get(name);
     }
     getAll() {
-        return Array.from(this.plugins.values());
+        return Array.from(this.plugins.values()).sort((a, b) => (b.priority ?? 0) - (a.priority ?? 0));
     }
     findPlugin(query) {
-        return this.getAll().find((plugin) => plugin.canHandle(query));
+        for (const plugin of this.getAll()) {
+            if (plugin.name && query.toLowerCase().includes(plugin.name.toLowerCase())) {
+                return plugin;
+            }
+        }
+        return this.getAll().find((plugin) => plugin.canHandle?.(query) ?? false);
     }
     clear() {
         this.plugins.clear();
+        this.streamCache.clear();
+        this.searchCache.clear();
+        this.pendingStreams.clear();
+        this.pendingSearches.clear();
     }
-    async getStream(track) {
-        const timeoutMs = this.options.extractorTimeout ?? 50000;
-        const primary = this.get(track.source) || this.findPlugin(track.url);
-        if (!primary) {
-            this.debug(`No plugin found for track: ${track.title}`);
+    setStreamManager(manager) {
+        this.streamManager = manager;
+    }
+    //#region Search advanced scoring
+    getSearchCacheKey(query, requestedBy) {
+        return `${query.toLowerCase().trim()}:${requestedBy}`;
+    }
+    getCachedSearch(query, requestedBy) {
+        if (!this.options.enableCache)
             return null;
+        const key = this.getSearchCacheKey(query, requestedBy);
+        const cached = this.searchCache.get(key);
+        if (cached && Date.now() < cached.expiresAt) {
+            this.debug(`[SearchCache] Hit for query: ${query}`);
+            return cached.result;
+        }
+        if (cached) {
+            this.debug(`[SearchCache] Expired for query: ${query}`);
+            this.searchCache.delete(key);
+        }
+        return null;
+    }
+    setCachedSearch(query, requestedBy, result) {
+        if (!this.options.enableCache)
+            return;
+        const key = this.getSearchCacheKey(query, requestedBy);
+        this.searchCache.set(key, {
+            result,
+            timestamp: Date.now(),
+            expiresAt: Date.now() + (this.options.searchCacheTTL ?? 2 * 60 * 1000),
+        });
+        this.debug(`[SearchCache] Stored for query: ${query}, tracks: ${result.tracks.length}`);
+    }
+    /**
+     * Evaluate how well a track matches the search query
+     * @param track Evaluated track
+     * @param query Query default
+     * @returns SearchScore object with score and reason
+     */
+    evaluateTrackMatch(track, query) {
+        const normalizedQuery = normalize(query);
+        const normalizedTitle = normalize(track.title);
+        const queryLower = query.toLowerCase();
+        const urlLower = track.url?.toLowerCase() || "";
+        // 1. Evaluate URL match - 100%
+        if (urlLower === queryLower || (queryLower.includes(urlLower) && urlLower.length > 10)) {
+            return {
+                score: 100,
+                reason: "URL matches exactly",
+                matchedBy: "url",
+                exactMatch: true,
+            };
+        }
+        // 2. Evaluate title match exactly - 100%
+        if (normalizedTitle === normalizedQuery) {
+            return {
+                score: 100,
+                reason: "Title matches exactly",
+                matchedBy: "title",
+                exactMatch: true,
+            };
+        }
+        // 3. Evaluate title contains query or vice versa - 70-90%
+        if (normalizedTitle.includes(normalizedQuery) && normalizedQuery.length > 5) {
+            const ratio = normalizedQuery.length / normalizedTitle.length;
+            const score = 70 + Math.min(20, Math.floor(ratio * 20));
+            return {
+                score,
+                reason: `Title contains the query "${query}" (${Math.floor(ratio * 100)}% coverage)`,
+                matchedBy: "title",
+                exactMatch: false,
+            };
+        }
+        if (normalizedQuery.includes(normalizedTitle) && normalizedTitle.length > 5) {
+            const ratio = normalizedTitle.length / normalizedQuery.length;
+            const score = 70 + Math.min(20, Math.floor(ratio * 20));
+            return {
+                score,
+                reason: `Query contains the title "${query}" (${Math.floor(ratio * 100)}% overlap)`,
+                matchedBy: "title",
+                exactMatch: false,
+            };
+        }
+        // 4. Evaluate similarity algorithm - 0-70%
+        const simScore = similarity(normalizedTitle, normalizedQuery);
+        const tokenScore = tokenOverlap(normalizedTitle, normalizedQuery);
+        const contentTypeBonus = detectContentType(track.title);
+        // Tính điểm tổng hợp: similarity 60%, token overlap 30%, content type 10%
+        let finalScore = simScore * 60 + tokenScore * 30 + (contentTypeBonus / 10) * 10;
+        finalScore = Math.min(70, Math.max(0, Math.floor(finalScore)));
+        if (finalScore >= 20) {
+            let reason = `Similarity ${Math.floor(simScore * 100)}%`;
+            if (contentTypeBonus > 0) {
+                reason += `, recognized as music content`;
+            }
+            return {
+                score: finalScore,
+                reason,
+                matchedBy: "partial",
+                exactMatch: false,
+            };
+        }
+        // 5. Không match
+        return {
+            score: 0,
+            reason: "No matching results found",
+            matchedBy: "none",
+            exactMatch: false,
+        };
+    }
+    /**
+     * Evaluate and rank all search results from a plugin
+     * @param tracks List of tracks to evaluate
+     * @param query Original query
+     * @param isPlaylistResult Whether this is a playlist result (skip per-track evaluation)
+     * @returns List of tracks with scores, sorted by score
+     */
+    evaluateAndRankResults(tracks, query, isPlaylistResult = false) {
+        // 🔥 Nếu là playlist result, giữ nguyên tất cả tracks với điểm 100%
+        if (isPlaylistResult && tracks.length > 0) {
+            this.debug(`[Evaluation] Playlist detected - keeping all ${tracks.length} tracks`);
+            return tracks.map((track) => ({
+                track,
+                score: {
+                    score: 100,
+                    reason: "Part of playlist",
+                    matchedBy: "playlist",
+                    exactMatch: false,
+                },
+            }));
+        }
+        const evaluated = tracks.map((track) => ({
+            track,
+            score: this.evaluateTrackMatch(track, query),
+        }));
+        // Sort by score in descending order (cao xuống thấp)
+        evaluated.sort((a, b) => b.score.score - a.score.score);
+        // Log evaluation results
+        for (const item of evaluated.slice(0, 5)) {
+            this.debug(`[Evaluation] "${item.track.title}" -> ${item.score.score}% (${item.score.reason})`);
+        }
+        return evaluated;
+    }
+    /**
+     * Select the best result from multiple plugins
+     * @param allResults Results from various plugins
+     * @param query Original query
+     * @returns The best result
+     */
+    selectBestResult(allResults, query) {
+        let bestResult = null;
+        let bestScore = -1;
+        for (const [source, result] of allResults) {
+            if (!result.tracks || result.tracks.length === 0)
+                continue;
+            // Evaluate the first (best) track of this result
+            const bestTrackScore = this.evaluateTrackMatch(result.tracks[0], query);
+            if (bestTrackScore.score > bestScore) {
+                bestScore = bestTrackScore.score;
+                bestResult = {
+                    ...result,
+                    source,
+                    score: bestTrackScore,
+                };
+            }
+            this.debug(`[Selection] Plugin ${source} -> best match: ${bestTrackScore.score}%`);
+        }
+        if (bestResult && bestResult.score) {
+            this.debug(`[Selection] Selected result from ${bestResult.source} with score ${bestResult.score.score}%`);
         }
+        return bestResult;
+    }
+    /**
+     * Search with deduplication and evaluation of results
+     * @param query Search query
+     * @param requestedBy User who requested the search
+     * @returns Evaluated search result
+     */
+    async search(query, requestedBy) {
+        if (!query || !query.trim()) {
+            this.debug(`[Search] Empty query provided`);
+            return null;
+        }
+        const trimmedQuery = query.trim();
+        this.debug(`[Search] Called with query: "${trimmedQuery}", requestedBy: ${requestedBy}`);
+        // Check cache
+        const cached = this.getCachedSearch(trimmedQuery, requestedBy);
+        if (cached) {
+            this.debug(`[Search] Returning cached result for: ${trimmedQuery}`);
+            return cached;
+        }
+        // Check in-flight request
+        const dedupeKey = this.getSearchCacheKey(trimmedQuery, requestedBy);
+        if (this.pendingSearches.has(dedupeKey)) {
+            this.debug(`[Search] Waiting for in-flight request: ${trimmedQuery}`);
+            return this.pendingSearches.get(dedupeKey);
+        }
+        // Create new search request
+        const searchPromise = this.searchInternal(trimmedQuery, requestedBy);
+        this.pendingSearches.set(dedupeKey, searchPromise);
         try {
-            const controller = new AbortController();
-            const result = await (0, timeout_1.withTimeout)(primary.getStream(track, controller.signal), timeoutMs, "Primary timeout");
-            if (result?.stream)
-                return result;
-            throw new Error("Primary failed");
-        }
-        catch {
-            this.debug("Primary failed → fallback parallel");
-        }
-        // ===== FALLBACK PARALLEL =====
-        const plugins = this.getAll()
-            .filter((p) => p !== primary)
-            .map((p) => {
-            p.priority ??= 0;
-            return p;
-        })
-            .sort((a, b) => (a.priority ?? 0) - (b.priority ?? 0));
-        // group by priority
-        const groups = new Map();
-        for (const p of plugins) {
-            if (!groups.has(p.priority ?? 0))
-                groups.set(p.priority ?? 0, []);
-            groups.get(p.priority ?? 0).push(p);
+            const result = await searchPromise;
+            return result;
         }
-        for (const [priority, group] of groups) {
-            this.debug(`Running group priority=${priority}`);
-            const controller = new AbortController();
-            try {
-                const promises = group.map((p) => {
-                    const run = async () => {
-                        try {
-                            let result = null;
-                            if (p.getStream) {
-                                try {
-                                    result = await (0, timeout_1.withTimeout)(p.getStream(track, controller.signal), timeoutMs, `Timeout ${p.name}`);
-                                }
-                                catch (err) {
-                                    // getStream thất bại → log rồi thử getFallback
-                                    this.debug(`getStream failed for ${p.name}, trying getFallback`, err);
-                                }
-                                if (result?.stream) {
-                                    this.debug(`Success via ${p.name}`);
-                                    controller.abort();
-                                    return result;
-                                }
+        finally {
+            this.pendingSearches.delete(dedupeKey);
+        }
+    }
+    async searchInternal(query, requestedBy) {
+        const timeoutMs = this.options.extractorTimeout ?? 15000;
+        const minScore = this.options.searchMinScore ?? 30;
+        // Get all plugins that support search
+        const allSearchPlugins = this.getAll()
+            .filter((p) => typeof p.search === "function")
+            .sort((a, b) => (b.priority ?? 0) - (a.priority ?? 0));
+        if (allSearchPlugins.length === 0) {
+            this.debug(`[Search] No plugins support search`);
+            return null;
+        }
+        const priorityGroups = new Map();
+        for (const plugin of allSearchPlugins) {
+            const priority = plugin.priority ?? 0;
+            if (!priorityGroups.has(priority)) {
+                priorityGroups.set(priority, []);
+            }
+            priorityGroups.get(priority).push(plugin);
+        }
+        const sortedPriorities = Array.from(priorityGroups.keys()).sort((a, b) => b - a);
+        this.debug(`[Search] Priority groups: ${sortedPriorities.map((p) => `${p} (${priorityGroups.get(p).length} plugins)`).join(", ")}`);
+        const allResults = new Map();
+        const errors = [];
+        let foundHighQualityResult = false;
+        let bestResultOverall = null;
+        let bestScoreOverall = -1;
+        // 🔥 PROCESS EACH PRIORITY GROUP
+        for (const priority of sortedPriorities) {
+            const groupPlugins = priorityGroups.get(priority);
+            this.debug(`[Search] Processing priority group ${priority} with ${groupPlugins.length} plugins`);
+            const groupResults = new Map();
+            // Process all plugins in current priority group
+            for (const plugin of groupPlugins) {
+                // Skip if we already found a high-quality result (>=90%) from previous group
+                if (foundHighQualityResult) {
+                    this.debug(`[Search] Skipping plugin ${plugin.name} (priority ${priority}) - already have high-quality result`);
+                    break;
+                }
+                try {
+                    this.debug(`[Search] Trying plugin: ${plugin.name} (priority: ${priority})`);
+                    const startTime = Date.now();
+                    const result = await (0, timeout_1.withTimeout)(plugin.search(query, requestedBy), timeoutMs, `Search timeout for ${plugin.name}`);
+                    const duration = Date.now() - startTime;
+                    if (result && Array.isArray(result.tracks) && result.tracks.length > 0) {
+                        // 🔥 KIỂM TRA XEM CÓ PLAYLIST HAY KHÔNG
+                        const hasPlaylist = !!result.playlist;
+                        const isPlaylistResult = hasPlaylist && result.tracks.length > 1;
+                        // Evaluate and rank results from this plugin
+                        const evaluatedTracks = this.evaluateAndRankResults(result.tracks, query, isPlaylistResult);
+                        const bestScore = evaluatedTracks[0]?.score.score || 0;
+                        // Filter tracks below minimum score (chỉ áp dụng cho non-playlist)
+                        let validTracks;
+                        if (isPlaylistResult) {
+                            // 🔥 PLAYLIST: Giữ nguyên tất cả tracks, không lọc theo score
+                            validTracks = evaluatedTracks.map((item) => item.track);
+                            this.debug(`[Search] Plugin ${plugin.name} returned playlist with ${validTracks.length} tracks (keeping all)`);
+                        }
+                        else {
+                            // Single track search: filter by min score
+                            validTracks = evaluatedTracks.filter((item) => item.score.score >= minScore).map((item) => item.track);
+                            this.debug(`[Search] Plugin ${plugin.name} returned ${validTracks.length}/${result.tracks.length} valid tracks in ${duration}ms (best: ${bestScore}%)`);
+                        }
+                        if (validTracks.length > 0) {
+                            const pluginResult = {
+                                tracks: validTracks,
+                                playlist: result.playlist,
+                                query,
+                                score: evaluatedTracks[0].score,
+                                source: plugin.name,
+                            };
+                            groupResults.set(plugin.name, pluginResult);
+                            allResults.set(plugin.name, pluginResult);
+                            // 🔥 Nếu là playlist hoặc kết quả chất lượng cao, dừng search
+                            if (isPlaylistResult || bestScore >= 90) {
+                                foundHighQualityResult = true;
+                                bestResultOverall = pluginResult;
+                                bestScoreOverall = bestScore;
+                                this.debug(`[Search] ${isPlaylistResult ? "Playlist" : "High-quality result"} found, stopping search`);
+                                break;
                             }
-                            if (p.getFallback) {
-                                result = await (0, timeout_1.withTimeout)(p.getFallback(track, controller.signal), timeoutMs, `Fallback timeout ${p.name}`);
-                                if (result?.stream) {
-                                    this.debug(`Fallback via ${p.name}`);
-                                    controller.abort();
-                                    return result;
-                                }
+                            // Track best result overall
+                            if (bestScore > bestScoreOverall) {
+                                bestScoreOverall = bestScore;
+                                bestResultOverall = pluginResult;
                             }
-                            throw new Error("No stream");
                         }
-                        catch (err) {
-                            if (controller.signal.aborted)
-                                throw new Error("Aborted");
-                            this.debug(`Failed ${p.name}`, err);
-                            throw err;
+                        else {
+                            this.debug(`[Search] Plugin ${plugin.name} returned ${result.tracks.length} tracks but none passed min score ${minScore}`);
                         }
-                    };
-                    return run();
-                });
-                const result = await Promise.any(promises);
-                if (result?.stream)
-                    return result;
+                    }
+                    else {
+                        this.debug(`[Search] Plugin ${plugin.name} returned no tracks in ${duration}ms`);
+                    }
+                }
+                catch (error) {
+                    const err = error instanceof Error ? error : new Error(String(error));
+                    this.debug(`[Search] Plugin ${plugin.name} failed:`, err.message);
+                    errors.push({ plugin: plugin.name, error: err });
+                }
+            }
+            // 🔥 AFTER PROCESSING CURRENT GROUP, DECIDE WHETHER TO CONTINUE
+            if (foundHighQualityResult) {
+                this.debug(`[Search] Found high-quality result (>=90%) in priority group ${priority}, stopping search`);
+                break;
+            }
+            // If current group has at least one valid result, check if we should continue to lower priority groups
+            if (groupResults.size > 0) {
+                // Get best score from this group
+                const bestGroupScore = Math.max(...Array.from(groupResults.values()).map((r) => r.score?.score || 0));
+                // If best score in this group is >= 70%, don't try lower priority groups
+                if (bestGroupScore >= 70) {
+                    this.debug(`[Search] Priority group ${priority} has results with score ${bestGroupScore}% (>=70%), stopping search`);
+                    break;
+                }
+                // If best score is between 50-70%, continue to lower groups but log it
+                if (bestGroupScore >= 50) {
+                    this.debug(`[Search] Priority group ${priority} has results with score ${bestGroupScore}% (50-70%), will try lower priority groups for better results`);
+                }
+                else {
+                    this.debug(`[Search] Priority group ${priority} has low quality results (${bestGroupScore}% <50%), trying lower priority groups`);
+                }
+            }
+            else {
+                this.debug(`[Search] Priority group ${priority} produced no valid results, trying lower priority group`);
+            }
+        }
+        // 🔥 SELECT BEST RESULT
+        if (bestResultOverall) {
+            // Cache the result
+            this.setCachedSearch(query, requestedBy, bestResultOverall);
+            // Log summary
+            const allTracksCount = Array.from(allResults.values()).reduce((sum, r) => sum + r.tracks.length, 0);
+            this.debug(`[Search] Complete - Best from ${bestResultOverall.source}: ${bestResultOverall.tracks.length} tracks (${bestResultOverall.score?.score || 0}%), Total candidates: ${allTracksCount}`);
+            return bestResultOverall;
+        }
+        // 🔥 FALLBACK: If we have any results that didn't meet min score, return the best one
+        if (allResults.size === 0 && errors.length > 0) {
+            // Try to get best result from allResults even if below min score
+            let fallbackResult = null;
+            let fallbackScore = -1;
+            for (const [source, result] of allResults) {
+                const score = result.score?.score || 0;
+                if (score > fallbackScore) {
+                    fallbackScore = score;
+                    fallbackResult = result;
+                }
             }
-            catch {
-                this.debug(`Priority group ${priority} failed`);
-                controller.abort();
+            if (fallbackResult) {
+                this.debug(`[Search] Using fallback result with score ${fallbackScore}% (below minimum ${minScore}%)`);
+                return fallbackResult;
             }
+            this.debug(`[Search] All ${allSearchPlugins.length} plugins failed for query: ${query}`);
+            const lastError = errors[errors.length - 1]?.error;
+            if (lastError)
+                throw lastError;
         }
-        throw new Error(`All plugins failed for track: ${track.title}`);
+        return null;
     }
     /**
-     * Get related tracks for a given track
-     * @param {Track} track Track to find related tracks for
-     * @returns {Track[]} Related tracks or empty array
-     * @example
-     * const related = await player.getRelatedTracks(track);
-     * console.log(`Found ${related.length} related tracks`);
+     * Get plugin priority groups info for debugging
      */
+    getPriorityGroupsInfo() {
+        const groups = new Map();
+        for (const plugin of this.getAll()) {
+            const priority = plugin.priority ?? 0;
+            if (!groups.has(priority)) {
+                groups.set(priority, []);
+            }
+            groups.get(priority).push(plugin.name);
+        }
+        return Array.from(groups.entries())
+            .map(([priority, plugins]) => ({
+            priority,
+            plugins,
+            count: plugins.length,
+        }))
+            .sort((a, b) => b.priority - a.priority);
+    }
+    /**
+     * Clear search cache
+     */
+    clearSearchCache() {
+        const size = this.searchCache.size;
+        this.searchCache.clear();
+        this.debug(`[SearchCache] Cleared ${size} entries`);
+    }
+    /**
+     * Get search cache stats
+     */
+    getSearchCacheStats() {
+        return {
+            size: this.searchCache.size,
+            keys: Array.from(this.searchCache.keys()),
+        };
+    }
+    //#endregion
+    //#region Stream methods (giữ nguyên)
+    getStreamCacheKey(track) {
+        return `${track.source}:${track.url}:${track.id || track.title}`;
+    }
+    getCachedStream(track) {
+        if (!this.options.enableCache)
+            return null;
+        const key = this.getStreamCacheKey(track);
+        const cached = this.streamCache.get(key);
+        if (cached && Date.now() < cached.expiresAt) {
+            this.debug(`[StreamCache] Hit for track: ${track.title}`);
+            return cached.streamInfo;
+        }
+        if (cached) {
+            this.debug(`[StreamCache] Expired for track: ${track.title}`);
+            this.streamCache.delete(key);
+        }
+        return null;
+    }
+    setCachedStream(track, streamInfo) {
+        if (!this.options.enableCache)
+            return;
+        const key = this.getStreamCacheKey(track);
+        this.streamCache.set(key, {
+            streamInfo,
+            timestamp: Date.now(),
+            expiresAt: Date.now() + this.STREAM_CACHE_TTL,
+        });
+        this.debug(`[StreamCache] Stored for track: ${track.title}`);
+    }
+    async getStreamWithDedupe(track, primary) {
+        const key = this.getStreamCacheKey(track);
+        if (this.pendingStreams.has(key)) {
+            this.debug(`[StreamDedupe] Waiting for existing request: ${track.title}`);
+            return this.pendingStreams.get(key);
+        }
+        const promise = this.getStreamInternal(track, primary);
+        this.pendingStreams.set(key, promise);
+        try {
+            const result = await promise;
+            return result;
+        }
+        finally {
+            this.pendingStreams.delete(key);
+        }
+    }
+    async getStreamInternal(track, primary) {
+        if (this.streamManager) {
+            const existingStream = this.streamManager.getStreamByTrack(track.id || track.title);
+            if (existingStream) {
+                this.debug(`[Stream] Using existing stream from manager`);
+                return { stream: existingStream, type: "arbitrary" };
+            }
+        }
+        const timeoutMs = this.options.extractorTimeout ?? 50000;
+        const cached = this.getCachedStream(track);
+        if (cached)
+            return cached;
+        try {
+            this.debug(`[Stream] Trying ${primary.name} for track: ${track.title}`);
+            const controller = new AbortController();
+            const result = await (0, timeout_1.withTimeout)(primary.getStream(track, controller.signal), timeoutMs, `Primary timeout: ${primary.name}`);
+            if (result?.stream) {
+                const isValid = await this.validateStreamMatchesTrack(result, track);
+                if (isValid) {
+                    this.debug(`[Stream] Success via ${primary.name}`);
+                    this.setCachedStream(track, result);
+                    return result;
+                }
+                this.debug(`[Stream] Stream validation failed - wrong track returned`);
+            }
+            throw new Error("Primary plugin returned no stream or invalid stream");
+        }
+        catch (error) {
+            this.debug(`[Stream] Primary failed: ${primary.name}`, error);
+        }
+        // Fallback logic...
+        const fallbackPlugins = this.getAll()
+            .filter((p) => p !== primary && p.name !== primary.name)
+            .sort((a, b) => (b.priority ?? 0) - (a.priority ?? 0));
+        if (fallbackPlugins.length === 0) {
+            this.debug(`[Stream] No fallback plugins available`);
+            return null;
+        }
+        this.debug(`[Stream] Trying ${fallbackPlugins.length} fallback plugins`);
+        const validResults = [];
+        let attempt = 0;
+        for (const plugin of fallbackPlugins) {
+            attempt++;
+            if (attempt > (this.options.maxFallbackAttempts ?? 3)) {
+                this.debug(`[Stream] Max attempts reached`);
+                break;
+            }
+            try {
+                this.debug(`[Stream] Fallback ${attempt}: ${plugin.name}`);
+                const controller = new AbortController();
+                let result = null;
+                if (plugin.getStream) {
+                    result = await (0, timeout_1.withTimeout)(plugin.getStream(track, controller.signal), timeoutMs, `Timeout: ${plugin.name}`);
+                }
+                if (!result?.stream && plugin.getFallback) {
+                    result = await (0, timeout_1.withTimeout)(plugin.getFallback(track, controller.signal), timeoutMs, `Fallback timeout: ${plugin.name}`);
+                }
+                if (result?.stream) {
+                    const similarityScore = this.calculateTrackSimilarity(track, result);
+                    if (similarityScore > 0.7) {
+                        this.debug(`[Stream] Fallback success via ${plugin.name} (score: ${similarityScore})`);
+                        this.setCachedStream(track, result);
+                        return result;
+                    }
+                    else {
+                        validResults.push({
+                            plugin: plugin.name,
+                            streamInfo: result,
+                            score: similarityScore,
+                        });
+                        this.debug(`[Stream] Fallback ${plugin.name} returned low similarity (${similarityScore})`);
+                    }
+                }
+            }
+            catch (error) {
+                this.debug(`[Stream] Fallback failed: ${plugin.name}`, error);
+            }
+        }
+        if (validResults.length > 0) {
+            const bestMatch = validResults.sort((a, b) => b.score - a.score)[0];
+            this.debug(`[Stream] Using best available match from ${bestMatch.plugin} (score: ${bestMatch.score})`);
+            return bestMatch.streamInfo;
+        }
+        this.debug(`[Stream] All plugins failed for track: ${track.title}`);
+        return null;
+    }
+    async getStream(track) {
+        if (!track) {
+            this.debug(`[getStream] No track provided`);
+            return null;
+        }
+        let primary = this.get(track.source);
+        if (!primary) {
+            primary = this.findPlugin(track.url);
+        }
+        if (!primary) {
+            this.debug(`[getStream] No plugin found for track: ${track.title}`);
+            return null;
+        }
+        return this.getStreamWithDedupe(track, primary);
+    }
     async getRelatedTracks(track) {
         if (!track)
             return [];
         const timeoutMs = this.options.extractorTimeout ?? 15000;
         const limit = 20;
-        const allPlugins = this.getAll()
+        const minSimilarityScore = 10;
+        const relatedPlugins = this.getAll()
             .filter((p) => typeof p.getRelatedTracks === "function")
-            .sort((a, b) => (a.priority ?? 0) - (b.priority ?? 0));
+            .sort((a, b) => (b.priority ?? 0) - (a.priority ?? 0));
+        if (relatedPlugins.length === 0) {
+            return [];
+        }
         const history = this.player.queue.previousTracks;
+        const historyUrls = new Set(history.map((t) => t.url));
+        const currentTrackUrl = track.url;
         const results = [];
-        // ===== TRY ALL PLUGINS (NOT JUST FIRST SUCCESS) =====
-        await Promise.allSettled(allPlugins.map(async (p) => {
-            try {
-                this.debug(`[RelatedTracks] Querying ${p.name}`);
-                const related = await (0, timeout_1.withTimeout)(p.getRelatedTracks(track, { limit, history }), timeoutMs, `Timeout ${p.name}`);
-                if (Array.isArray(related)) {
-                    results.push(...related);
+        const batchSize = 3;
+        for (let i = 0; i < relatedPlugins.length; i += batchSize) {
+            const batch = relatedPlugins.slice(i, i + batchSize);
+            const batchResults = await Promise.allSettled(batch.map(async (plugin) => {
+                try {
+                    const related = await (0, timeout_1.withTimeout)(plugin.getRelatedTracks(track, { limit, history }), timeoutMs, `Timeout ${plugin.name}`);
+                    return Array.isArray(related) ? related : [];
+                }
+                catch (err) {
+                    return [];
+                }
+            }));
+            for (const result of batchResults) {
+                if (result.status === "fulfilled") {
+                    results.push(...result.value);
                 }
             }
-            catch (err) {
-                this.debug(`[RelatedTracks] ${p.name} failed`, err);
-            }
-        }));
-        if (results.length === 0) {
-            this.debug(`[RelatedTracks] No results`);
-            return [];
         }
-        // ===== DEDUPE =====
+        if (results.length === 0)
+            return [];
         const unique = new Map();
         for (const t of results) {
-            if (!unique.has(t.url)) {
+            if (!unique.has(t.url) && t.url !== currentTrackUrl && !historyUrls.has(t.url)) {
                 unique.set(t.url, t);
             }
         }
-        // ===== SCORE + SORT =====
         const ranked = Array.from(unique.values())
             .map((t) => ({ track: t, score: scoreTrack(track, t) }))
+            .filter((item) => item.score >= minSimilarityScore)
             .sort((a, b) => b.score - a.score)
             .slice(0, limit)
             .map((x) => x.track);
-        this.debug(`[RelatedTracks] Final ${ranked.length} tracks`);
+        this.debug(`[RelatedTracks] Found ${ranked.length} related tracks`);
         return ranked;
     }
+    //#endregion
+    //#region Utility methods
+    clearStreamCache() {
+        const size = this.streamCache.size;
+        this.streamCache.clear();
+        this.debug(`[StreamCache] Cleared ${size} entries`);
+    }
+    getStats() {
+        return {
+            totalPlugins: this.plugins.size,
+            pluginNames: Array.from(this.plugins.keys()),
+            streamCacheSize: this.streamCache.size,
+            searchCacheSize: this.searchCache.size,
+            pendingStreams: this.pendingStreams.size,
+            pendingSearches: this.pendingSearches.size,
+        };
+    }
+    async validateStreamMatchesTrack(streamInfo, expectedTrack) {
+        const actualTitle = streamInfo.metadata?.title || streamInfo.metadata?.originalTitle;
+        if (!actualTitle) {
+            return true;
+        }
+        const similarity = this.calculateTrackSimilarity(expectedTrack, { title: actualTitle });
+        return similarity > 0.6;
+    }
+    calculateTrackSimilarity(track1, track2) {
+        const normalize = (str) => str
+            .toLowerCase()
+            .replace(/\(.*?\)|\[.*?\]/g, "")
+            .replace(/[^a-z0-9\s]/g, "")
+            .replace(/\s+/g, " ")
+            .trim();
+        const title1 = normalize(track1.title);
+        const title2 = normalize(track2.title || "");
+        if (title1 === title2)
+            return 1.0;
+        if (title1.includes(title2) || title2.includes(title1))
+            return 0.8;
+        const words1 = new Set(title1.split(" "));
+        const words2 = new Set(title2.split(" "));
+        const intersection = new Set([...words1].filter((x) => words2.has(x)));
+        const union = new Set([...words1, ...words2]);
+        return intersection.size / union.size;
+    }
 }
 exports.PluginManager = PluginManager;
 //# sourceMappingURL=index.js.map