ziplayer 0.3.3 → 0.3.4

package/src/extensions/index.ts

@@ -61,8 +61,13 @@ export class ExtensionManager {
 		this.streamCache = new Map();
 		this.pendingSearches = new Map();
 		this.pendingStreams = new Map();
-		this.extensionContext = Object.freeze({ player, manager });
-
+		this.extensionContext = Object.freeze({
+			player,
+			manager,
+			playNext: () => (player as any).playNext?.(),
+			skip: () => (player as any).skip?.(),
+			emit: (event: string, ...args: any[]) => player.emit(event as any, ...args),
+		});
 		// Auto-cleanup caches periodically
 		setInterval(() => this.cleanupCaches(), 5 * 60 * 1000);
 	}
@@ -314,7 +319,10 @@ export class ExtensionManager {
 
 		// Check cache first
 		const cached = this.getCachedStream(track);
-		if (cached) return cached;
+		if (cached) {
+			this.debug(`[Cache] Stream hit for: ${track.title}`);
+			return cached;
+		}
 
 		// Deduplicate concurrent requests
 		const cacheKey = this.getCacheKey("stream", track.url || track.id || track.title);
@@ -333,16 +341,31 @@ export class ExtensionManager {
 				if (typeof hook !== "function") continue;
 
 				try {
+					this.debug(`Trying extension ${extension.name} for stream: ${track.title}`);
 					const result = await Promise.resolve(hook.call(extension, this.extensionContext, request));
-					if (result && (result as StreamInfo).stream) {
-						this.debug(`Extension ${extension.name} provided stream for: ${track.title}`);
-						this.setCachedStream(track, result as StreamInfo);
-						return result as StreamInfo;
+
+					if (result) {
+						const isRemote = (result as StreamInfo).remote;
+						const hasStream = !!(result as StreamInfo).stream;
+						const hasHandle = !!(result as StreamInfo).handle;
+
+						this.debug(
+							`Extension ${extension.name} returned stream for ${track.title}: remote=${isRemote}, hasStream=${hasStream}, hasHandle=${hasHandle}`,
+						);
+
+						if (hasStream || hasHandle) {
+							// Only cache if it's a reusable stream (not remote with handle)
+							if (!isRemote) {
+								this.setCachedStream(track, result as StreamInfo);
+							}
+							return result as StreamInfo;
+						}
 					}
 				} catch (err) {
 					this.debug(`Extension ${extension.name} provideStream error:`, err);
 				}
 			}
+			this.debug(`No extension provided stream for: ${track.title}`);
 			return null;
 		})();
 

package/src/plugins/index.ts

@@ -704,43 +704,123 @@ export class PluginManager {
 	}
 
 	private async getStreamInternal(track: Track, primary: BasePlugin): Promise<StreamInfo | null> {
+		// Reuse existing stream from StreamManager
 		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" };
+
+				return {
+					stream: existingStream,
+					type: "arbitrary",
+				};
 			}
 		}
 
 		const timeoutMs = this.options.extractorTimeout ?? 50000;
 
+		// Cache
 		const cached = this.getCachedStream(track);
-		if (cached) return cached;
 
-		try {
-			this.debug(`[Stream] Trying ${primary.name} for track: ${track.title}`);
+		if (cached) {
+			this.debug(`[Stream] Using cached stream for: ${track.title}`);
+			return cached;
+		}
+
+		/**
+		 * Try resolve stream from plugin
+		 * Flow:
+		 *   1. plugin.getStream()
+		 *   2. validate stream
+		 *   3. if failed -> plugin.getFallback()
+		 */
+		const tryPlugin = async (
+			plugin: BasePlugin,
+			isPrimary: boolean = false,
+		): Promise<{ result: StreamInfo | null; similarity: number }> => {
 			const controller = new AbortController();
-			const result = await 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;
+			let result: StreamInfo | null = null;
+
+			// =========================================================
+			// 1. TRY DIRECT STREAM
+			// =========================================================
+			if (plugin.getStream) {
+				try {
+					this.debug(`[Stream] ${plugin.name} trying direct stream`);
+
+					result = await withTimeout(plugin.getStream(track, controller.signal), timeoutMs, `${plugin.name} getStream timeout`);
+
+					if (result?.stream) {
+						const valid = await this.validateStreamMatchesTrack(result, track);
+
+						if (valid) {
+							this.debug(`[Stream] ${plugin.name} direct stream success`);
+
+							return {
+								result,
+								similarity: 1,
+							};
+						}
+
+						this.debug(`[Stream] ${plugin.name} returned invalid stream`);
+					} else {
+						this.debug(`[Stream] ${plugin.name} no direct stream returned`);
+					}
+				} catch (error) {
+					this.debug(`[Stream] ${plugin.name} getStream failed:`, error instanceof Error ? error.message : error);
 				}
-				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);
+
+			// =========================================================
+			// 2. TRY FALLBACK SEARCH
+			// =========================================================
+			if (plugin.getFallback) {
+				try {
+					this.debug(`[Stream] ${plugin.name} trying fallback resolver`);
+
+					result = await withTimeout(plugin.getFallback(track, controller.signal), timeoutMs, `${plugin.name} fallback timeout`);
+
+					if (result?.stream) {
+						const similarity = this.calculateTrackSimilarity(track, {
+							title: result.metadata?.title || result.metadata?.originalTitle || track.title,
+						});
+
+						this.debug(`[Stream] ${plugin.name} fallback success (${similarity})`);
+
+						return {
+							result,
+							similarity,
+						};
+					}
+
+					this.debug(`[Stream] ${plugin.name} fallback returned no stream`);
+				} catch (error) {
+					this.debug(`[Stream] ${plugin.name} fallback failed:`, error instanceof Error ? error.message : error);
+				}
+			}
+
+			return {
+				result: null,
+				similarity: 0,
+			};
+		};
+
+		// =========================================================
+		// PRIMARY PLUGIN
+		// =========================================================
+		const primaryResult = await tryPlugin(primary, true);
+
+		if (primaryResult.result?.stream) {
+			this.setCachedStream(track, primaryResult.result);
+
+			return primaryResult.result;
 		}
 
-		// Fallback logic...
+		// =========================================================
+		// FALLBACK PLUGINS
+		// =========================================================
 		const fallbackPlugins = this.getAll()
 			.filter((p) => p !== primary && p.name !== primary.name)
 			.sort((a, b) => (b.priority ?? 0) - (a.priority ?? 0));
@@ -752,61 +832,64 @@ export class PluginManager {
 
 		this.debug(`[Stream] Trying ${fallbackPlugins.length} fallback plugins`);
 
-		const validResults: Array<{ plugin: string; streamInfo: StreamInfo; score: number }> = [];
+		const validResults: Array<{
+			plugin: string;
+			streamInfo: StreamInfo;
+			score: number;
+		}> = [];
 
 		let attempt = 0;
+
 		for (const plugin of fallbackPlugins) {
 			attempt++;
+
 			if (attempt > (this.options.maxFallbackAttempts ?? 3)) {
-				this.debug(`[Stream] Max attempts reached`);
+				this.debug(`[Stream] Max fallback attempts reached`);
 				break;
 			}
 
-			try {
-				this.debug(`[Stream] Fallback ${attempt}: ${plugin.name}`);
-				const controller = new AbortController();
-
-				let result: StreamInfo | null = null;
+			const { result, similarity } = await tryPlugin(plugin);
 
-				if (plugin.getStream) {
-					result = await withTimeout(plugin.getStream(track, controller.signal), timeoutMs, `Timeout: ${plugin.name}`);
-				}
+			if (!result?.stream) {
+				continue;
+			}
 
-				if (!result?.stream && plugin.getFallback) {
-					result = await withTimeout(plugin.getFallback(track, controller.signal), timeoutMs, `Fallback timeout: ${plugin.name}`);
-				}
+			// Perfect / good match
+			if (similarity >= 0.7) {
+				this.debug(`[Stream] Success via fallback ${plugin.name} (score: ${similarity})`);
 
-				if (result?.stream) {
-					const similarityScore = this.calculateTrackSimilarity(track, result);
+				this.setCachedStream(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);
+				return result;
 			}
+
+			// Keep low similarity result as backup
+			validResults.push({
+				plugin: plugin.name,
+				streamInfo: result,
+				score: similarity,
+			});
+
+			this.debug(`[Stream] ${plugin.name} low similarity match (${similarity})`);
 		}
 
+		// =========================================================
+		// BEST AVAILABLE MATCH
+		// =========================================================
 		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})`);
+
+			this.debug(`[Stream] Using best available match from ${bestMatch.plugin} (${bestMatch.score})`);
+
+			this.setCachedStream(track, bestMatch.streamInfo);
+
 			return bestMatch.streamInfo;
 		}
 
-		this.debug(`[Stream] All plugins failed for track: ${track.title}`);
+		this.debug(`[Stream] All plugins failed for: ${track.title}`);
+
 		return null;
 	}
-
 	async getStream(track: Track): Promise<StreamInfo | null> {
 		if (!track) {
 			this.debug(`[getStream] No track provided`);