ziplayer 0.3.11 → 0.3.12-dev.0

package/src/structures/FilterManager.ts

@@ -244,8 +244,7 @@ export class FilterManager {
 			wasRecreated = true;
 
 			position = -1;
-			streamInfo.type = "arbitrary";
-			if (!filterString) return { ...streamInfo, stream: sourceStream, wasRecreated };
+			if (!filterString) return { ...streamInfo, type: "arbitrary", stream: sourceStream, wasRecreated };
 		}
 
 		this.debug(`Applying filters and seek — filters: ${filterString || "none"}, seek: ${position}ms`);
@@ -259,7 +258,12 @@ export class FilterManager {
 		this.ffmpegAbortController = abortController;
 
 		// Nếu có vị trí seek, ưu tiên dùng spawnFFmpegInputSeek
-		if (position >= 0 && ffmpegPath) {
+		if (position >= 0) {
+			if (!ffmpegPath) {
+				this.debug("[FilterManager] ffmpeg-static path not found, seeking may fail");
+				// Fallback or throw based on preference, here we try to proceed or throw
+				throw new Error("FFmpeg binary not found. Seeking is unavailable.");
+			}
 			const stream = await this.spawnFFmpegInputSeek(sourceStream, position, filterString, abortController.signal, generation);
 			return { ...streamInfo, stream };
 		}
@@ -370,7 +374,7 @@ export class FilterManager {
 			// Already aborted before we even spawned
 			onAbort();
 		} else {
-			signal.addEventListener("abort", onAbort);
+			signal.addEventListener("abort", onAbort, { once: true });
 		}
 
 		// Pipe source → ffmpeg stdin

package/src/structures/Player.ts

@@ -125,6 +125,7 @@ export class Player extends EventEmitter {
 		resource: null,
 		track: null,
 		streamId: null,
+		processedStreamId: null,
 		abortController: null,
 		isValid: false,
 		isLoading: false,
@@ -331,7 +332,11 @@ export class Player extends EventEmitter {
 		const stream = (this.currentResource as any)?.metadata?.stream ?? (this.currentResource as any)?.stream;
 
 		if (stream && typeof stream.destroy === "function") {
-			stream.destroy().catch((e: any) => this.debug("Stream destroy error:", e));
+			try {
+				stream.destroy();
+			} catch (e: any) {
+				this.debug("Stream destroy error:", e);
+			}
 		}
 
 		this.currentResource = null;
@@ -464,13 +469,22 @@ export class Player extends EventEmitter {
 	private async generateWillNext(): Promise<void> {
 		const lastTrack = this.queue.previousTracks[this.queue.previousTracks.length - 1] ?? this.queue.currentTrack;
 		if (!lastTrack) return;
-		const related = await this.pluginManager.getRelatedTracks(lastTrack);
+		let related = await this.pluginManager.getRelatedTracks(lastTrack);
 		if (!related || related.length === 0) return;
-		const randomchoice = Math.floor(Math.random() * related.length);
+
+		// Lọc bỏ các bài đã có trong hàng đợi sắp tới
+		const upcomingUrls = new Set(this.queue.getTracks().map((t) => t.url));
+		related = related.filter((t) => !upcomingUrls.has(t.url));
+
+		if (related.length === 0) return;
+
+		// Ưu tiên chọn trong top 5 để đảm bảo chất lượng cao nhất
+		const poolSize = Math.min(5, related.length);
+		const randomchoice = Math.floor(Math.random() * poolSize);
 		const nextTrack = this.queue.nextTrack ? this.queue.nextTrack : related[randomchoice];
 		this.queue.willNextTrack(nextTrack);
 		this.queue.relatedTracks(related);
-		this.debug(`[Player] Will next track if autoplay: ${nextTrack?.title}]`);
+		this.debug(`[Player] Will next track if autoplay: ${nextTrack?.title}`);
 		this.emit("willPlay", nextTrack, related);
 	}
 	//#endregion
@@ -1128,17 +1142,20 @@ export class Player extends EventEmitter {
 				return await this.playRemote(track, streamInfo);
 			}
 
-			if (!streamInfo?.stream) {
+			if (!streamInfo?.stream && !streamInfo?.url) {
 				throw new Error(`No stream available`);
 			}
 
 			// Register the RAW source stream — this is what we can reuse on seek
-			const rawStreamId = this.streamManager.registerStream(streamInfo.stream, track, {
-				source: track.source || "stream",
-				isPreload: false,
-				isRemote: !!streamInfo?.remote,
-				priority: 10,
-			});
+			const rawStreamId =
+				streamInfo.stream ?
+					this.streamManager.registerStream(streamInfo.stream, track, {
+						source: track.source || "stream",
+						isPreload: false,
+						isRemote: !!streamInfo?.remote,
+						priority: 10,
+					})
+				:	null;
 
 			// createResource now returns both the AudioResource
 			// AND the processedStream (ffmpeg stdout) when filters/seek are involved.
@@ -1159,14 +1176,14 @@ export class Player extends EventEmitter {
 			if (this.currentSlot.streamId && this.currentSlot.streamId !== rawStreamId) {
 				this.streamManager.unregisterStream(this.currentSlot.streamId, true);
 			}
-			if ((this.currentSlot as any).processedStreamId && (this.currentSlot as any).processedStreamId !== playStreamId) {
-				this.streamManager.unregisterStream((this.currentSlot as any).processedStreamId, true);
+			if (this.currentSlot.processedStreamId && this.currentSlot.processedStreamId !== playStreamId) {
+				this.streamManager.unregisterStream(this.currentSlot.processedStreamId, true);
 			}
 
 			this.currentSlot.resource = resource;
 			this.currentSlot.track = track;
 			this.currentSlot.streamId = rawStreamId;
-			(this.currentSlot as any).processedStreamId = processedStream ? playStreamId : null;
+			this.currentSlot.processedStreamId = processedStream ? playStreamId : null;
 			this.currentSlot.isValid = true;
 			this.currentResource = resource;
 			this.seekOffset = 0;
@@ -1449,7 +1466,7 @@ export class Player extends EventEmitter {
 	 */
 	async connect(
 		channel: VoiceChannel,
-		options: { group: string; selfDeaf: boolean; selfMute: boolean },
+		options: { group: string; selfDeaf: boolean; selfMute: boolean } = {} as any,
 	): Promise<VoiceConnection> {
 		try {
 			this.debug(`[Player] Connecting to voice channel: ${channel.id}`);
@@ -2508,10 +2525,10 @@ export class Player extends EventEmitter {
 			}
 
 			// Clean up processedStream first (it's what AudioResource reads)
-			const processedStreamId = (this.currentSlot as any).processedStreamId;
+			const processedStreamId = this.currentSlot.processedStreamId;
 			if (processedStreamId && processedStreamId !== currentStreamId) {
 				this.streamManager.unregisterStream(processedStreamId, true);
-				(this.currentSlot as any).processedStreamId = null;
+				this.currentSlot.processedStreamId = null;
 			}
 
 			if (currentStreamId) {
@@ -2542,9 +2559,19 @@ export class Player extends EventEmitter {
 				this.extensionManager.clearCache("stream");
 				this.debug(`[Player] Fetching fresh stream${!isForwardSeek ? " (backward seek)" : " (reuse failed)"}`);
 				streaminfo = await this.getStream(track);
+			
+			if (this.destroyed) {
+				this.debug(`[Player] refreshPlayerResource: Player destroyed during stream fetch`);
+				return false;
+			}
+			
+			if (!applyToCurrent || !this.queue.currentTrack || !(this.isPlaying || this.isPaused)) {
+				this.debug(`[Player] refreshPlayerResource: Player state changed during stream fetch, aborting`);
+				return false;
+			}
 			}
 
-			if (!streaminfo?.stream) {
+			if (!streaminfo?.stream && !streaminfo?.url) {
 				this.debug(`[Player] No stream available for refresh`);
 				return false;
 			}
@@ -2554,11 +2581,14 @@ export class Player extends EventEmitter {
 			const { resource, processedStream } = await this.createResource(streaminfo, track, createPosition);
 
 			// Register raw source stream
-			const newStreamId = this.streamManager.registerStream(streaminfo.stream, track, {
-				source: track.source || "stream",
-				isPreload: false,
-				priority: 10,
-			});
+			const newStreamId =
+				streaminfo.stream ?
+					this.streamManager.registerStream(streaminfo.stream, track, {
+						source: track.source || "stream",
+						isPreload: false,
+						priority: 10,
+					})
+				:	null;
 
 			let newProcessedStreamId: string | null = null;
 			if (processedStream && processedStream !== streaminfo.stream) {
@@ -2572,7 +2602,7 @@ export class Player extends EventEmitter {
 			this.currentSlot.resource = resource;
 			this.currentSlot.track = track;
 			this.currentSlot.streamId = newStreamId;
-			(this.currentSlot as any).processedStreamId = newProcessedStreamId;
+			this.currentSlot.processedStreamId = newProcessedStreamId;
 			this.currentSlot.isValid = true;
 			this.currentResource = resource;
 

package/src/structures/PlayerManager.ts

@@ -15,9 +15,10 @@ import {
 } from "../types";
 import type { BaseExtension } from "../extensions";
 import { withTimeout } from "../utils/timeout";
-import { PluginManager } from "../plugins";
 
 const GLOBAL_MANAGER_KEY: symbol = Symbol.for("ziplayer.PlayerManager.instance");
+/** Guild id for the internal search-only player (never stored in {@link PlayerManager.players}). */
+const SEARCH_PLAYER_GUILD_ID = "__ziplayer_search__";
 
 export const getGlobalManager = (): PlayerManager | null => {
 	try {
@@ -90,6 +91,7 @@ interface ManagerCacheEntry<T> {
 export class PlayerManager extends EventEmitter {
 	private static instance: PlayerManager | null = null;
 	private players: Map<string, Player> = new Map();
+	private pendingPlayers: Map<string, Promise<Player>> = new Map();
 	private searchCache: Map<string, ManagerCacheEntry<SearchResult>>;
 	private readonly SEARCH_CACHE_TTL = 60 * 1000; // 1 minute
 	private readonly MAX_CACHE_SIZE = 100;
@@ -105,7 +107,8 @@ export class PlayerManager extends EventEmitter {
 	}
 
 	private plugins: SourcePlugin[];
-	private pluginManager: PluginManager;
+	/** Reused player for {@link search}; not registered in {@link players}. */
+	private searchPlayer: Player | null = null;
 	private extensions: any[];
 	private B_debug: boolean = false;
 	private extractorTimeout: number = 10000;
@@ -126,9 +129,6 @@ export class PlayerManager extends EventEmitter {
 	constructor(options: PlayerManagerOptions = {}) {
 		super();
 		this.plugins = [];
-		this.pluginManager = new PluginManager(null as any, this, {
-			extractorTimeout: this.extractorTimeout,
-		});
 		this.searchCache = new Map();
 
 		// Initialize plugins
@@ -145,7 +145,6 @@ export class PlayerManager extends EventEmitter {
 
 				if (instance) {
 					this.plugins.push(instance);
-					this.pluginManager.register(instance);
 				}
 				this.debug(`Registered plugin: ${p.name || "unnamed"}`);
 			} catch (e) {
@@ -249,6 +248,25 @@ export class PlayerManager extends EventEmitter {
 		this.debug(`Auto-cleanup started with interval: ${this.cleanupTimeout}ms`);
 	}
 
+	/**
+	 * Lazy internal player used only for {@link search}.
+	 * Not added to {@link players} and does not forward manager events.
+	 */
+	private getSearchPlayer(): Player {
+		if (this.searchPlayer && !this.searchPlayer.destroyed) {
+			return this.searchPlayer;
+		}
+
+		const player = new Player(SEARCH_PLAYER_GUILD_ID, { extractorTimeout: this.extractorTimeout }, this);
+		for (const plugin of this.plugins) {
+			player.addPlugin(plugin);
+		}
+
+		this.searchPlayer = player;
+		this.debug(`Created internal search player (not stored in players map)`);
+		return player;
+	}
+
 	private startStatsCollection(): void {
 		if (this.statsInterval) {
 			clearInterval(this.statsInterval);
@@ -291,85 +309,104 @@ export class PlayerManager extends EventEmitter {
 	async create(guildOrId: string | { id: string }, options?: PlayerOptions): Promise<Player> {
 		const guildId = this.resolveGuildId(guildOrId);
 
+		if (guildId === SEARCH_PLAYER_GUILD_ID) {
+			throw new Error(`Guild id "${SEARCH_PLAYER_GUILD_ID}" is reserved for internal search.`);
+		}
+
 		if (this.players.has(guildId)) {
 			this.debug(`Player already exists for guildId: ${guildId}, returning existing`);
 			return this.players.get(guildId)!;
 		}
 
-		this.debug(`Creating player for guildId: ${guildId}`);
-		const player = new Player(guildId, options, this);
-
-		// Add all registered plugins
-		this.plugins.forEach((plugin) => player.addPlugin(plugin));
-
-		// Activate extensions
-		let extsToActivate: any[] = [];
-		const optExts = (options as any)?.extensions as any[] | string[] | undefined;
-
-		if (Array.isArray(optExts)) {
-			if (optExts.length === 0) {
-				extsToActivate = [];
-			} else if (typeof optExts[0] === "string") {
-				const wanted = new Set(optExts as string[]);
-				extsToActivate = this.extensions.filter((ext) => {
-					const name = typeof ext === "function" ? ext.name : ext?.name;
-					return !!name && wanted.has(name);
-				});
-			} else {
-				extsToActivate = optExts;
-			}
-		} else {
-			// Use all extensions by default
-			extsToActivate = this.extensions;
+		// Check if a player is already being created for this guild
+		if (this.pendingPlayers.has(guildId)) {
+			this.debug(`Player creation already in progress for guildId: ${guildId}, awaiting...`);
+			return this.pendingPlayers.get(guildId)!;
 		}
 
-		for (const ext of extsToActivate) {
-			let instance = ext;
-			if (typeof ext === "function") {
-				try {
-					instance = new ext(player);
-				} catch (e) {
-					this.debug(`Extension constructor error for ${ext.name}:`, e);
-					continue;
+		const creationPromise = (async () => {
+			try {
+				this.debug(`Creating player for guildId: ${guildId}`);
+				const player = new Player(guildId, options, this);
+
+				// Add all registered plugins
+				this.plugins.forEach((plugin) => player.addPlugin(plugin));
+
+				// Activate extensions
+				let extsToActivate: any[] = [];
+				const optExts = (options as any)?.extensions as any[] | string[] | undefined;
+
+				if (Array.isArray(optExts)) {
+					if (optExts.length === 0) {
+						extsToActivate = [];
+					} else if (typeof optExts[0] === "string") {
+						const wanted = new Set(optExts as string[]);
+						extsToActivate = this.extensions.filter((ext) => {
+							const name = typeof ext === "function" ? ext.name : ext?.name;
+							return !!name && wanted.has(name);
+						});
+					} else {
+						extsToActivate = optExts;
+					}
+				} else {
+					// Use all extensions by default
+					extsToActivate = this.extensions;
 				}
-			}
 
-			if (instance && typeof instance === "object") {
-				const extInstance = instance as BaseExtension;
-				if ("player" in extInstance && !extInstance.player) extInstance.player = player;
-				player.attachExtension(extInstance);
-
-				if (typeof extInstance.active === "function") {
-					let activated: boolean | void = true;
-					try {
-						activated = await withTimeout(
-							Promise.resolve(extInstance.active({ manager: this, player })),
-							player.options.extractorTimeout ?? 15000,
-							`Extension ${extInstance?.name} activation timed out`,
-						);
-						this.debug(`Extension ${extInstance?.name} active check returned: ${activated}`);
-					} catch (e) {
-						activated = false;
-						this.debug(`Extension activation error for ${extInstance?.name}:`, e);
+				for (const ext of extsToActivate) {
+					let instance = ext;
+					if (typeof ext === "function") {
+						try {
+							instance = new ext(player);
+						} catch (e) {
+							this.debug(`Extension constructor error for ${ext.name}:`, e);
+							continue;
+						}
 					}
 
-					if (activated === false) {
-						player.detachExtension(extInstance);
-						continue;
+					if (instance && typeof instance === "object") {
+						const extInstance = instance as BaseExtension;
+						if ("player" in extInstance && !extInstance.player) extInstance.player = player;
+						player.attachExtension(extInstance);
+
+						if (typeof extInstance.active === "function") {
+							let activated: boolean | void = true;
+							try {
+								activated = await withTimeout(
+									Promise.resolve(extInstance.active({ manager: this, player })),
+									player.options.extractorTimeout ?? 15000,
+									`Extension ${extInstance?.name} activation timed out`,
+								);
+								this.debug(`Extension ${extInstance?.name} active check returned: ${activated}`);
+							} catch (e) {
+								activated = false;
+								this.debug(`Extension activation error for ${extInstance?.name}:`, e);
+							}
+
+							if (activated === false) {
+								player.detachExtension(extInstance);
+								continue;
+							}
+						}
 					}
 				}
-			}
-		}
 
-		// Forward all player events to manager
-		this.setupEventForwarding(player, guildId);
+				// Forward all player events to manager
+				this.setupEventForwarding(player, guildId);
 
-		// Mark last activity
-		(player as any)._lastActivity = Date.now();
+				// Mark last activity
+				(player as any)._lastActivity = Date.now();
 
-		this.players.set(guildId, player);
-		this.debug(`Player created for guildId: ${guildId}`);
-		return player;
+				this.players.set(guildId, player);
+				this.debug(`Player created for guildId: ${guildId}`);
+				return player;
+			} finally {
+				this.pendingPlayers.delete(guildId);
+			}
+		})();
+
+		this.pendingPlayers.set(guildId, creationPromise);
+		return creationPromise;
 	}
 
 	private setupEventForwarding(player: Player, guildId: string): void {
@@ -770,6 +807,11 @@ export class PlayerManager extends EventEmitter {
 			player.destroy();
 		}
 
+		if (this.searchPlayer && !this.searchPlayer.destroyed) {
+			this.searchPlayer.destroy();
+		}
+		this.searchPlayer = null;
+
 		this.players.clear();
 		this.searchCache.clear();
 		this.removeAllListeners();
@@ -777,13 +819,11 @@ export class PlayerManager extends EventEmitter {
 	}
 
 	/**
-	 * Search using PluginManager without creating a Player.
+	 * Search via an internal Player instance (all registered plugins) without
+	 * storing it in {@link players}.
 	 *
-	 * Uses the same search pipeline as Player.search():
-	 * - cache
-	 * - plugin deduplication
-	 * - plugin scoring/evaluation
-	 * - fallback handling
+	 * Uses the same search pipeline as {@link Player.search}:
+	 * extension hooks, plugin deduplication, scoring, and fallback handling.
 	 *
 	 * @param {string} query
 	 * @param {string} requestedBy
@@ -792,20 +832,15 @@ export class PlayerManager extends EventEmitter {
 	async search(query: string, requestedBy: string): Promise<SearchResult> {
 		this.debug(`Search called with query: ${query}, requestedBy: ${requestedBy}`);
 
-		// Cache
 		const cached = this.getCachedSearch(query);
 		if (cached) {
 			return cached;
 		}
 
 		try {
-			const result = await this.pluginManager.search(query, requestedBy);
-
-			if (!result || !Array.isArray(result.tracks) || result.tracks.length === 0) {
-				throw new Error(`No results found for: ${query}`);
-			}
+			const result = await this.getSearchPlayer().search(query, requestedBy);
 
-			this.debug(`Plugin search returned ${result.tracks.length} tracks (score: ${result.score?.score ?? "unknown"}%)`);
+			this.debug(`Search returned ${result.tracks.length} tracks (score: ${result.score?.score ?? "unknown"}%)`);
 
 			if (result.score) {
 				this.debug(`Search evaluation - ${result.score.reason}`);
@@ -836,10 +871,13 @@ export class PlayerManager extends EventEmitter {
 	 */
 	registerPlugin(plugin: SourcePlugin): void {
 		this.plugins.push(plugin);
-		this.pluginManager.register(plugin);
 
 		this.debug(`Registered plugin: ${plugin.name}`);
 
+		if (this.searchPlayer && !this.searchPlayer.destroyed) {
+			this.searchPlayer.addPlugin(plugin);
+		}
+
 		for (const player of this.players.values()) {
 			player.addPlugin(plugin);
 		}
@@ -856,7 +894,10 @@ export class PlayerManager extends EventEmitter {
 		if (index === -1) return false;
 
 		this.plugins.splice(index, 1);
-		this.pluginManager.unregister(name);
+
+		if (this.searchPlayer && !this.searchPlayer.destroyed) {
+			this.searchPlayer.removePlugin(name);
+		}
 
 		this.debug(`Unregistered plugin: ${name}`);
 

package/src/structures/PreloadManager.ts

@@ -24,6 +24,7 @@ export class PreloadManager {
 		resource: null,
 		track: null,
 		streamId: null,
+		processedStreamId: null,
 		abortController: null,
 		isValid: false,
 		isLoading: false,
@@ -239,17 +240,20 @@ export class PreloadManager {
 			this.debugLog(`[Preload] Track changed after stream fetch`);
 			throw new Error("PRELOAD_CANCELLED");
 		}
-		if (!streamInfo?.stream) {
+		if (!streamInfo?.stream && !streamInfo?.url) {
 			throw new Error(`No stream available`);
 		}
 
-		const streamId = this.streamManager.registerStream(streamInfo.stream, track, {
-			source: track.source || "preload",
-			isPreload: true,
-			priority: 5,
-		});
+		const streamId =
+			streamInfo.stream ?
+				this.streamManager.registerStream(streamInfo.stream, track, {
+					source: track.source || "preload",
+					isPreload: true,
+					priority: 5,
+				})
+			:	null;
 
-		const resource = createAudioResource(streamInfo.stream, {
+		const resource = createAudioResource(streamInfo.stream || streamInfo.url!, {
 			inlineVolume: true,
 			metadata: { ...track, preloaded: true },
 		});
@@ -277,7 +281,7 @@ export class PreloadManager {
 				signal.removeEventListener("abort", handler);
 				reject(new Error("PRELOAD_CANCELLED"));
 			};
-			signal.addEventListener("abort", handler);
+			signal.addEventListener("abort", handler, { once: true });
 		});
 
 		const existingStream = this.streamManager.getStreamByTrack(track.id || track.title);

package/src/structures/Queue.ts

@@ -231,9 +231,9 @@ export class Queue {
 			this.current = this.tracks.shift() || null;
 		}
 
-		// Skip bypassed track loop but no other track exists → restore current from history
+		// Skip bypassed track loop but no other track exists → trigger queue end
 		if (!this.current && this._loop === "track" && ignoreLoop && this.history.length > 0) {
-			this.current = this.history.pop() || null;
+			return null;
 		}
 
 		return this.current;

package/src/types/index.ts

@@ -420,6 +420,7 @@ export interface SaveOptions {
 	/** Seek position in milliseconds to start saving from */
 	seek?: number;
 }
+
 export interface PlayerSession {
 	guildId: string;
 	queue: Track[];
@@ -471,6 +472,7 @@ export interface StreamSlot {
 	resource: AudioResource | null;
 	track: Track | null;
 	streamId: string | null;
+	processedStreamId: string | null;
 	abortController: AbortController | null;
 	isValid: boolean;
 	isLoading: boolean;

package/src/utils/timeout.ts

@@ -6,5 +6,12 @@
  * @returns Promise that rejects if timeout is reached
  */
 export function withTimeout<T>(promise: Promise<T>, timeoutMs: number, message: string): Promise<T> {
-	return Promise.race([promise, new Promise<never>((_, reject) => setTimeout(() => reject(new Error(message)), timeoutMs))]);
+	let timeoutId: NodeJS.Timeout;
+	const timeoutPromise = new Promise<never>((_, reject) => {
+		timeoutId = setTimeout(() => reject(new Error(message)), timeoutMs);
+	});
+
+	return Promise.race([promise, timeoutPromise]).finally(() => {
+		if (timeoutId) clearTimeout(timeoutId);
+	});
 }