ziplayer 0.2.7-dev.3 → 0.3.0

package/dist/plugins/index.js

@@ -68,13 +68,17 @@ 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 = {
             maxFallbackAttempts: 3,
             enableCache: true,
+            searchMinScore: 30,
+            searchCacheTTL: 2 * 60 * 1000, // 2 minutes
             ...options,
         };
     }
@@ -104,20 +108,425 @@ class PluginManager {
         return Array.from(this.plugins.values()).sort((a, b) => (b.priority ?? 0) - (a.priority ?? 0));
     }
     findPlugin(query) {
-        // First try exact match by source
         for (const plugin of this.getAll()) {
             if (plugin.name && query.toLowerCase().includes(plugin.name.toLowerCase())) {
                 return plugin;
             }
         }
-        // Then try canHandle
         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();
     }
+    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 result = await searchPromise;
+            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;
+                            }
+                            // Track best result overall
+                            if (bestScore > bestScoreOverall) {
+                                bestScoreOverall = bestScore;
+                                bestResultOverall = pluginResult;
+                            }
+                        }
+                        else {
+                            this.debug(`[Search] Plugin ${plugin.name} returned ${result.tracks.length} tracks but none passed min score ${minScore}`);
+                        }
+                    }
+                    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;
+                }
+            }
+            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;
+        }
+        return null;
+    }
+    /**
+     * 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}`;
     }
@@ -127,11 +536,11 @@ class PluginManager {
         const key = this.getStreamCacheKey(track);
         const cached = this.streamCache.get(key);
         if (cached && Date.now() < cached.expiresAt) {
-            this.debug(`[Cache] Hit for track: ${track.title}`);
+            this.debug(`[StreamCache] Hit for track: ${track.title}`);
             return cached.streamInfo;
         }
         if (cached) {
-            this.debug(`[Cache] Expired for track: ${track.title}`);
+            this.debug(`[StreamCache] Expired for track: ${track.title}`);
             this.streamCache.delete(key);
         }
         return null;
@@ -145,16 +554,14 @@ class PluginManager {
             timestamp: Date.now(),
             expiresAt: Date.now() + this.STREAM_CACHE_TTL,
         });
-        this.debug(`[Cache] Stored for track: ${track.title}`);
+        this.debug(`[StreamCache] Stored for track: ${track.title}`);
     }
     async getStreamWithDedupe(track, primary) {
         const key = this.getStreamCacheKey(track);
-        // Check if there's already an in-flight request
         if (this.pendingStreams.has(key)) {
-            this.debug(`[Dedupe] Waiting for existing request: ${track.title}`);
+            this.debug(`[StreamDedupe] Waiting for existing request: ${track.title}`);
             return this.pendingStreams.get(key);
         }
-        // Create new request
         const promise = this.getStreamInternal(track, primary);
         this.pendingStreams.set(key, promise);
         try {
@@ -166,67 +573,89 @@ class PluginManager {
         }
     }
     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;
-        // Check cache first
         const cached = this.getCachedStream(track);
         if (cached)
             return cached;
-        // Try primary plugin first
         try {
-            this.debug(`[Primary] Trying ${primary.name} for track: ${track.title}`);
+            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) {
-                this.debug(`[Primary] Success via ${primary.name}`);
-                this.setCachedStream(track, result);
-                return result;
+                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");
+            throw new Error("Primary plugin returned no stream or invalid stream");
         }
         catch (error) {
-            this.debug(`[Primary] Failed: ${primary.name}`, error);
+            this.debug(`[Stream] Primary failed: ${primary.name}`, error);
         }
-        // Fallback to other plugins
+        // 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(`[Fallback] No fallback plugins available`);
+            this.debug(`[Stream] No fallback plugins available`);
             return null;
         }
-        this.debug(`[Fallback] Trying ${fallbackPlugins.length} plugins sequentially`);
-        // Try plugins sequentially to avoid overwhelming sources
+        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(`[Fallback] Max attempts (${this.options.maxFallbackAttempts}) reached`);
+                this.debug(`[Stream] Max attempts reached`);
                 break;
             }
             try {
-                this.debug(`[Fallback] Attempt ${attempt}/${fallbackPlugins.length}: ${plugin.name}`);
+                this.debug(`[Stream] Fallback ${attempt}: ${plugin.name}`);
                 const controller = new AbortController();
                 let result = null;
-                // Try getStream first
                 if (plugin.getStream) {
                     result = await (0, timeout_1.withTimeout)(plugin.getStream(track, controller.signal), timeoutMs, `Timeout: ${plugin.name}`);
                 }
-                // Try fallback method if getStream failed
                 if (!result?.stream && plugin.getFallback) {
-                    this.debug(`[Fallback] Trying fallback method for ${plugin.name}`);
                     result = await (0, timeout_1.withTimeout)(plugin.getFallback(track, controller.signal), timeoutMs, `Fallback timeout: ${plugin.name}`);
                 }
                 if (result?.stream) {
-                    this.debug(`[Fallback] Success via ${plugin.name}`);
-                    this.setCachedStream(track, result);
-                    return result;
+                    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(`[Fallback] Failed: ${plugin.name}`, error);
+                this.debug(`[Stream] Fallback failed: ${plugin.name}`, error);
             }
         }
-        this.debug(`[Fallback] All plugins failed for track: ${track.title}`);
+        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) {
@@ -234,51 +663,41 @@ class PluginManager {
             this.debug(`[getStream] No track provided`);
             return null;
         }
-        // Find the most appropriate plugin
         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} (source: ${track.source})`);
+            this.debug(`[getStream] No plugin found for track: ${track.title}`);
             return null;
         }
         return this.getStreamWithDedupe(track, primary);
     }
-    /**
-     * Get related tracks for a given track
-     * @param {Track} track Track to find related tracks for
-     * @returns {Promise<Track[]>} Related tracks or empty array
-     */
     async getRelatedTracks(track) {
         if (!track)
             return [];
         const timeoutMs = this.options.extractorTimeout ?? 15000;
         const limit = 20;
-        const minSimilarityScore = 10; // Minimum score to consider
+        const minSimilarityScore = 10;
         const relatedPlugins = this.getAll()
             .filter((p) => typeof p.getRelatedTracks === "function")
             .sort((a, b) => (b.priority ?? 0) - (a.priority ?? 0));
         if (relatedPlugins.length === 0) {
-            this.debug(`[RelatedTracks] No plugins support related tracks`);
             return [];
         }
         const history = this.player.queue.previousTracks;
         const historyUrls = new Set(history.map((t) => t.url));
         const currentTrackUrl = track.url;
         const results = [];
-        // Try plugins in parallel but with limit
         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 {
-                    this.debug(`[RelatedTracks] Querying ${plugin.name}`);
                     const related = await (0, timeout_1.withTimeout)(plugin.getRelatedTracks(track, { limit, history }), timeoutMs, `Timeout ${plugin.name}`);
                     return Array.isArray(related) ? related : [];
                 }
                 catch (err) {
-                    this.debug(`[RelatedTracks] ${plugin.name} failed`, err);
                     return [];
                 }
             }));
@@ -288,46 +707,67 @@ class PluginManager {
                 }
             }
         }
-        if (results.length === 0) {
-            this.debug(`[RelatedTracks] No results from any plugin`);
+        if (results.length === 0)
             return [];
-        }
-        // Deduplicate by URL
         const unique = new Map();
         for (const t of results) {
             if (!unique.has(t.url) && t.url !== currentTrackUrl && !historyUrls.has(t.url)) {
                 unique.set(t.url, t);
             }
         }
-        // Score and 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] Found ${ranked.length} related tracks (filtered from ${results.length})`);
+        this.debug(`[RelatedTracks] Found ${ranked.length} related tracks`);
         return ranked;
     }
-    /**
-     * Clear stream cache
-     */
+    //#endregion
+    //#region Utility methods
     clearStreamCache() {
         const size = this.streamCache.size;
         this.streamCache.clear();
-        this.debug(`[Cache] Cleared ${size} stream cache entries`);
+        this.debug(`[StreamCache] Cleared ${size} entries`);
     }
-    /**
-     * Get plugin statistics
-     */
     getStats() {
         return {
             totalPlugins: this.plugins.size,
             pluginNames: Array.from(this.plugins.keys()),
-            cacheSize: this.streamCache.size,
-            pendingRequests: this.pendingStreams.size,
+            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