ziplayer 0.3.6 → 0.3.8

package/src/structures/Player.ts

@@ -118,6 +118,7 @@ export class Player extends EventEmitter {
 
 	private skipLoop = false;
 	private refreshLock = false;
+	private seekInProgress = false;
 	private remoteHandle: StreamInfo["handle"];
 
 	private currentSlot: StreamSlot = {
@@ -171,6 +172,7 @@ export class Player extends EventEmitter {
 	private readonly SEARCH_CACHE_TTL = 2 * 60 * 1000; // 2 minutes
 	private ttsPlayer: DiscordAudioPlayer | null = null;
 	private lastDuration: number = 0;
+	private seekOffset: number = 0;
 
 	constructor(guildId: string, options: PlayerOptions = {}, manager: PlayerManager) {
 		super();
@@ -267,7 +269,7 @@ export class Player extends EventEmitter {
 			extractorTimeout: this.options.extractorTimeout,
 		});
 		this.streamManager = new StreamManager({
-			maxConcurrentStreams: 2,
+			maxConcurrentStreams: 4,
 			streamTimeout: 5 * 60 * 1000,
 			maxListenersPerStream: 15,
 			enableMetrics: true,
@@ -276,7 +278,12 @@ export class Player extends EventEmitter {
 		this.preloadManager = new PreloadManager({
 			streamManager: this.streamManager,
 			debug: this.debug.bind(this),
-			getNextTrack: () => this.queue.nextTrack,
+			getNextTrack: () => {
+				if (this.queue.loop() === "track") {
+					return this.queue.currentTrack;
+				}
+				return this.queue.nextTrack;
+			},
 			getStream: (track) => this.getStream(track),
 			isDestroyed: () => this.destroyed,
 			isEnabled: () => this.preloadEnabled,
@@ -880,48 +887,41 @@ export class Player extends EventEmitter {
 	 * @param {number} position - Position in milliseconds to seek to (0 = no seek)
 	 * @returns {Promise<AudioResource>} The AudioResource with filters and seek applied
 	 */
-	private async createResource(streamInfo: StreamInfo, track: Track, position: number = 0): Promise<AudioResource> {
+	private async createResource(
+		streamInfo: StreamInfo,
+		track: Track,
+		position: number = 0,
+	): Promise<{ resource: AudioResource; processedStream: import("stream").Readable | null }> {
 		const filterString = this.filter.getFilterString();
+		this.debug(`[Player] Creating AudioResource — filters: ${filterString || "none"}, seek: ${position}ms`);
 
-		this.debug(`[Player] Creating AudioResource with filters: ${filterString || "none"}, seek: ${position}ms`);
+		this.filter.setSourceStreamType(streamInfo.type);
 
-		try {
-			let stream: Readable = streamInfo.stream;
-			// Apply filters and seek if needed
-			if (filterString || position > 0) {
-				stream = await this.filter.applyFiltersAndSeek(streamInfo.stream, position);
-				streamInfo.type = StreamType.Arbitrary;
-			}
+		const seekArg = position > 0 ? position : -1;
 
-			// Create AudioResource with better error handling
-			const resource = createAudioResource(stream, {
+		if (filterString || position > 0) {
+			const processedStream = await this.filter.applyFiltersAndSeek(streamInfo.stream, seekArg);
+
+			// rawStream. Always use Arbitrary so discordjs/voice doesn't re-encode.
+			const resource = createAudioResource(processedStream, {
 				metadata: track,
-				inputType:
-					streamInfo.type === "webm/opus" ? StreamType.WebmOpus
-					: streamInfo.type === "ogg/opus" ? StreamType.OggOpus
-					: StreamType.Arbitrary,
+				inputType: StreamType.Arbitrary,
 				inlineVolume: true,
 			});
 
-			return resource;
-		} catch (error) {
-			this.debug(`[Player] Error creating AudioResource with filters+seek:`, error);
-			// Fallback to basic AudioResource
-			try {
-				const resource = createAudioResource(streamInfo.stream, {
-					metadata: track,
-					inputType:
-						streamInfo.type === "webm/opus" ? StreamType.WebmOpus
-						: streamInfo.type === "ogg/opus" ? StreamType.OggOpus
-						: StreamType.Arbitrary,
-					inlineVolume: true,
-				});
-				return resource;
-			} catch (fallbackError) {
-				this.debug(`[Player] Fallback AudioResource creation failed:`, fallbackError);
-				throw fallbackError;
-			}
+			return { resource, processedStream };
 		}
+
+		const resource = createAudioResource(streamInfo.stream, {
+			metadata: track,
+			inputType:
+				streamInfo.type === "webm/opus" ? StreamType.WebmOpus
+				: streamInfo.type === "ogg/opus" ? StreamType.OggOpus
+				: StreamType.Arbitrary,
+			inlineVolume: true,
+		});
+
+		return { resource, processedStream: null };
 	}
 
 	private mergeTrackPreserveRef(target: Track, source: Track): void {
@@ -1035,9 +1035,16 @@ export class Player extends EventEmitter {
 	private async startTrack(track: Track): Promise<boolean> {
 		if (this.destroyed) return false;
 
-		// First, get stream info (this will handle remote detection)
-		let streamInfo: StreamInfo | null = null;
+		// Check preload BEFORE calling getStream so we never fetch a
+		// stream we're about to throw away. The original code called getStream()
+		// unconditionally at the top, then used the preload if available — leaking
+		// the just-fetched stream and running middleware twice.
+		if (this.preloadManager.hasValidPreload(track)) {
+			return await this.startFromPreload(track);
+		}
 
+		// Only fetch a stream when there is no usable preload.
+		let streamInfo: StreamInfo | null = null;
 		try {
 			streamInfo = await this.getStream(track);
 		} catch (error) {
@@ -1045,73 +1052,70 @@ export class Player extends EventEmitter {
 			throw error;
 		}
 
-		// Handle remote playback
+		// Remote playback
 		if (streamInfo?.remote && streamInfo.handle) {
 			return await this.playRemote(track, streamInfo);
 		}
 
-		// Handle native playback
-		try {
-			// Try to use preloaded resource
-			if (this.preloadManager.hasValidPreload(track)) {
-				this.debug(`[Player] Using preloaded stream for: ${track.title}`);
+		// Native playback — pass the already-fetched streamInfo to avoid a second fetch
+		return await this.loadFreshStream(track, streamInfo);
+	}
+	private async startFromPreload(track: Track): Promise<boolean> {
+		if (this.destroyed) return false;
 
-				this.audioPlayer.stop(true);
+		this.debug(`[Player] Using preloaded stream for: ${track.title}`);
 
-				const oldStreamId = this.currentSlot.streamId;
-				if (oldStreamId && this.streamManager) {
-					setTimeout(() => {
-						if (this.currentSlot.streamId === oldStreamId) {
-							this.streamManager.unregisterStream(oldStreamId, true);
-						}
-					}, 3000);
-				}
+		const oldStreamId = this.currentSlot.streamId;
 
-				this.promotePreloadToCurrent(track);
-				const currentResource = this.currentSlot.resource;
-				if (!currentResource) {
-					return false;
-				}
-				const targetVolume = this.getTrackTargetVolume(track);
+		this.promotePreloadToCurrent(track);
 
-				if (currentResource.volume) {
-					currentResource.volume.setVolume(this.crossfadeEnabled ? 0 : targetVolume);
-				}
+		if (oldStreamId && oldStreamId !== this.currentSlot.streamId) {
+			this.streamManager.unregisterStream(oldStreamId, true);
+			this.debug(`[Player] Released old stream ${oldStreamId} after preload promotion`);
+		}
 
-				await this.maybeAlignToBeatBoundary();
-				this.audioPlayer.play(currentResource);
-				await entersState(this.audioPlayer, AudioPlayerStatus.Playing, 10_000);
-				await this.applyCrossfadeIn(currentResource, track);
+		const currentResource = this.currentSlot.resource;
+		if (!currentResource) return false;
 
-				this.preloadNextTrack().catch((err) => {
-					this.debug(`[Player] Preload error:`, err);
-				});
+		this.seekOffset = 0;
+		const targetVolume = this.getTrackTargetVolume(track);
 
-				return true;
-			}
+		if (currentResource.volume) {
+			currentResource.volume.setVolume(this.crossfadeEnabled ? 0 : targetVolume);
+		}
 
-			this.debug(`[Player] No preload available, loading fresh: ${track.title}`);
-			return await this.loadFreshStream(track);
-		} catch (error) {
-			this.debug(`[Player] startTrack error:`, error);
-			this.emit("playerError", error as Error, track);
-			return false;
+		await this.maybeAlignToBeatBoundary();
+		this.refreshLock = true;
+		try {
+			this.audioPlayer.stop(true);
+			this.audioPlayer.play(currentResource);
+			await entersState(this.audioPlayer, AudioPlayerStatus.Playing, 10_000);
+		} finally {
+			this.refreshLock = false;
 		}
+
+		await this.applyCrossfadeIn(currentResource, track);
+
+		this.preloadNextTrack().catch((err: any) => {
+			this.debug(`[Player] Preload error:`, err);
+		});
+
+		return true;
 	}
 
 	/**
 	 * Load fresh stream when no preload available
 	 */
-	private async loadFreshStream(track: Track): Promise<boolean> {
+	private async loadFreshStream(track: Track, preloadedStreamInfo?: StreamInfo | null): Promise<boolean> {
 		if (this.destroyed) return false;
 
-		// Cancel preload to free resources
 		await this.safeCancelPreload();
 
 		try {
-			const streamInfo = await this.getStream(track);
+			// use caller-supplied streamInfo when available so we don't
+			// call getStream() a second time and run middleware twice.
+			const streamInfo = preloadedStreamInfo ?? (await this.getStream(track));
 
-			// Handle remote playback
 			if (streamInfo?.remote && streamInfo.handle) {
 				return await this.playRemote(track, streamInfo);
 			}
@@ -1120,45 +1124,64 @@ export class Player extends EventEmitter {
 				throw new Error(`No stream available`);
 			}
 
-			// Register with StreamManager
-			const streamId = this.streamManager.registerStream(streamInfo.stream, track, {
+			// 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,
 			});
 
-			// Create resource
-			const resource = await this.createResource(streamInfo, track, 0);
-
-			// Clean up old current
-			if (this.currentSlot.streamId && this.currentSlot.streamId !== streamId) {
+			// createResource now returns both the AudioResource
+			// AND the processedStream (ffmpeg stdout) when filters/seek are involved.
+			const { resource, processedStream } = await this.createResource(streamInfo, track, 0);
+
+			// when a processedStream exists, register it too so its
+			// lifecycle is tracked. Store its id separately in currentSlot so
+			// destroyCurrentStream() and refreshPlayerResource() clean the right object.
+			let playStreamId = rawStreamId;
+			if (processedStream && processedStream !== streamInfo.stream) {
+				playStreamId = this.streamManager.registerStream(processedStream, track, {
+					source: track.source || "stream-processed",
+					isPreload: false,
+					priority: 10,
+				});
+				this.debug(`[Player] Registered processedStream ${playStreamId} (rawStream: ${rawStreamId})`);
+			}
+			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);
+			}
 
-			// Set current slot
 			this.currentSlot.resource = resource;
 			this.currentSlot.track = track;
-			this.currentSlot.streamId = streamId;
+			this.currentSlot.streamId = rawStreamId;
+			(this.currentSlot as any).processedStreamId = processedStream ? playStreamId : null;
 			this.currentSlot.isValid = true;
 			this.currentResource = resource;
+			this.seekOffset = 0;
 
-			// Apply volume
 			const targetVolume = this.getTrackTargetVolume(track);
 			if (resource.volume) {
 				resource.volume.setVolume(this.crossfadeEnabled ? 0 : targetVolume);
 			}
 
-			// Play
 			await this.maybeAlignToBeatBoundary();
-			this.audioPlayer.stop(true);
-			this.audioPlayer.play(resource);
-			await entersState(this.audioPlayer, AudioPlayerStatus.Playing, 10_000);
+			this.refreshLock = true;
+			try {
+				this.audioPlayer.stop(true);
+				this.audioPlayer.play(resource);
+				await entersState(this.audioPlayer, AudioPlayerStatus.Playing, 10_000);
+			} finally {
+				this.refreshLock = false;
+			}
+
 			await this.applyCrossfadeIn(resource, track);
 
-			// Preload next (async)
 			if (!this.destroyed) {
-				this.preloadNextTrack().catch((err) => {
+				this.preloadNextTrack().catch((err: any) => {
 					this.debug(`[Player] Preload error:`, err);
 				});
 			}
@@ -1239,6 +1262,9 @@ export class Player extends EventEmitter {
 					if (this.antiStuckRetryDelayMs > 0) {
 						await new Promise((resolve) => setTimeout(resolve, this.antiStuckRetryDelayMs));
 					}
+				} else {
+					this.antiStuckConsecutiveFailures = 0;
+					this.skipLoop = true;
 				}
 			} catch (err) {
 				this.debug(`[Player] playNext error:`, err);
@@ -1263,6 +1289,9 @@ export class Player extends EventEmitter {
 					if (this.antiStuckRetryDelayMs > 0) {
 						await new Promise((resolve) => setTimeout(resolve, this.antiStuckRetryDelayMs));
 					}
+				} else {
+					this.antiStuckConsecutiveFailures = 0;
+					this.skipLoop = true;
 				}
 				continue;
 			}
@@ -1338,7 +1367,7 @@ export class Player extends EventEmitter {
 				throw new Error(`No stream available for track: ${track.title}`);
 			}
 			ttsStream = streamInfo.stream;
-			const resource = await this.createResource(streamInfo as StreamInfo, track);
+			const { resource, processedStream } = await this.createResource(streamInfo as StreamInfo, track);
 			if (!resource) {
 				throw new Error(`No resource available for track: ${track.title}`);
 			}
@@ -1410,15 +1439,21 @@ export class Player extends EventEmitter {
 	 * @example
 	 * await player.connect(voiceChannel);
 	 */
-	async connect(channel: VoiceChannel): Promise<VoiceConnection> {
+	async connect(
+		channel: VoiceChannel,
+		options: { group: string; selfDeaf: boolean; selfMute: boolean },
+	): Promise<VoiceConnection> {
 		try {
 			this.debug(`[Player] Connecting to voice channel: ${channel.id}`);
+
 			const connection = joinVoiceChannel({
+				...options,
 				channelId: channel.id,
 				guildId: channel.guildId,
 				adapterCreator: channel.guild.voiceAdapterCreator as any,
-				selfDeaf: this.options.selfDeaf ?? true,
-				selfMute: this.options.selfMute ?? false,
+				selfDeaf: options?.selfDeaf ?? this.options?.selfDeaf ?? true,
+				selfMute: options?.selfMute ?? this.options?.selfMute ?? false,
+				group: options?.group ?? this.options?.group ?? "Ziplayer",
 			});
 
 			await entersState(connection, VoiceConnectionStatus.Ready, 50_000);
@@ -1772,8 +1807,11 @@ export class Player extends EventEmitter {
 			return false;
 		}
 
-		await this.refreshPlayerResource(true, position);
-
+		const ok = await this.refreshPlayerResource(true, position);
+		if (!ok) {
+			this.debug(`[Player] Seek failed at position: ${position}ms`);
+			return false;
+		}
 		return true;
 	}
 
@@ -1956,10 +1994,10 @@ export class Player extends EventEmitter {
 	 * console.log(`Loop mode: ${loopMode}`);
 	 */
 	loop(mode?: LoopMode | number): LoopMode {
-		this.debug(`[Player] loop called with mode: ${mode}`);
-
 		if (typeof mode === "number") {
 			// Number mode: convert to text mode
+			this.debug(`[Player] loop called with mode: ${mode}`);
+
 			switch (mode) {
 				case 0:
 					return this.queue.loop("off");
@@ -2186,9 +2224,9 @@ export class Player extends EventEmitter {
 		}
 
 		const total = track.duration > 1000 ? track.duration : track.duration * 1000;
-		if (!total) return this.formatTimeCompact(resource.playbackDuration);
+		if (!total) return this.formatTimeCompact(resource.playbackDuration + this.seekOffset);
 
-		const current = resource.playbackDuration;
+		const current = resource.playbackDuration + this.seekOffset;
 		const ratio = Math.min(Math.max(current / total, 0), 1);
 		const progress = Math.round(ratio * size);
 
@@ -2298,7 +2336,7 @@ export class Player extends EventEmitter {
 		}
 
 		const total = track.duration > 1000 ? track.duration : track.duration * 1000;
-		const current = resource.playbackDuration;
+		const current = resource.playbackDuration + this.seekOffset;
 
 		return {
 			current: current,
@@ -2411,63 +2449,131 @@ export class Player extends EventEmitter {
 		if (!applyToCurrent || !this.queue.currentTrack || !(this.isPlaying || this.isPaused)) {
 			return false;
 		}
-		if (this.refreshLock) return false;
+		if (this.refreshLock) {
+			this.debug(`[Player] refreshPlayerResource skipped — lock held`);
+			return false;
+		}
+
 		this.refreshLock = true;
+
+		if (this.stuckTimer) {
+			clearTimeout(this.stuckTimer);
+			this.stuckTimer = null;
+		}
+
 		try {
 			const track = this.queue.currentTrack;
 			this.debug(`[Player] Refreshing player resource for track: ${track.title}`);
 
-			// Get current position for seeking
-			const currentPosition = position > 0 ? position : this.currentResource?.playbackDuration || 0;
+			const currentPosition = position >= 0 ? position : (this.currentResource?.playbackDuration ?? 0);
+			this.seekOffset = currentPosition;
+			const wasPaused = this.isPaused;
+			const playbackDuration = this.currentResource?.playbackDuration ?? 0;
+
+			const isForwardSeek = position < 0 || position >= playbackDuration;
+			const currentStreamId = this.currentSlot.streamId;
+
+			// Try to grab the raw source stream for reuse (forward seeks only)
+			let reuseStream: import("stream").Readable | null = null;
+			if (isForwardSeek && currentStreamId) {
+				reuseStream = this.streamManager.getRawStream(currentStreamId);
+				if (reuseStream) {
+					this.debug(`[Player] Will reuse source stream for seek (pos: ${currentPosition}ms)`);
+				}
+			}
+
+			if (reuseStream) {
+				reuseStream.unpipe();
+			}
+
+			// Clean up processedStream first (it's what AudioResource reads)
+			const processedStreamId = (this.currentSlot as any).processedStreamId;
+			if (processedStreamId && processedStreamId !== currentStreamId) {
+				this.streamManager.unregisterStream(processedStreamId, true);
+				(this.currentSlot as any).processedStreamId = null;
+			}
+
+			if (currentStreamId) {
+				this.streamManager.unregisterStream(currentStreamId, !reuseStream);
+				this.currentSlot.streamId = null;
+			}
+
+			this.audioPlayer.stop(true);
+			this.currentResource = null;
+			this.currentSlot.resource = null;
+			this.currentSlot.isValid = false;
+
+			await new Promise<void>((resolve) => setImmediate(resolve));
+
+			if (reuseStream) {
+				if (reuseStream.destroyed || (reuseStream as any).readable === false) {
+					this.debug(`[Player] Source stream did not survive stop — falling back to fresh stream`);
+					reuseStream = null;
+				}
+			}
+
+			let streaminfo: StreamInfo | null = null;
+
+			if (reuseStream) {
+				streaminfo = { stream: reuseStream, type: "arbitrary" };
+			} else {
+				this.pluginManager.clearStreamCache();
+				this.extensionManager.clearCache("stream");
+				this.debug(`[Player] Fetching fresh stream${!isForwardSeek ? " (backward seek)" : " (reuse failed)"}`);
+				streaminfo = await this.getStream(track);
+			}
 
-			const streaminfo = await this.getStream(track);
 			if (!streaminfo?.stream) {
-				this.debug(`[Player] No stream to refresh`);
+				this.debug(`[Player] No stream available for refresh`);
 				return false;
 			}
 
-			// Create AudioResource with filters and seek to current position
-			const resource = await this.createResource(streaminfo, track, currentPosition);
+			const createPosition = reuseStream ? -1 : currentPosition;
 
-			// Stop current playback and destroy old resource/stream
-			const wasPlaying = this.isPlaying;
-			const wasPaused = this.isPaused;
+			const { resource, processedStream } = await this.createResource(streaminfo, track, createPosition);
 
-			this.audioPlayer.stop();
+			// Register raw source stream
+			const newStreamId = this.streamManager.registerStream(streaminfo.stream, track, {
+				source: track.source || "stream",
+				isPreload: false,
+				priority: 10,
+			});
 
-			// Properly destroy the old resource and stream
-			try {
-				if (this.currentResource) {
-					const oldStream = (this.currentResource as any)._readableState?.stream || (this.currentResource as any).stream;
-					if (oldStream && typeof oldStream.destroy === "function") {
-						oldStream.destroy();
-					}
-				}
-			} catch (error) {
-				this.debug(`[Player] Error destroying old stream in refreshPlayerResource:`, error);
-			} finally {
-				this.refreshLock = false;
+			let newProcessedStreamId: string | null = null;
+			if (processedStream && processedStream !== streaminfo.stream) {
+				newProcessedStreamId = this.streamManager.registerStream(processedStream, track, {
+					source: track.source || "stream-processed",
+					isPreload: false,
+					priority: 10,
+				});
 			}
 
+			this.currentSlot.resource = resource;
+			this.currentSlot.track = track;
+			this.currentSlot.streamId = newStreamId;
+			(this.currentSlot as any).processedStreamId = newProcessedStreamId;
+			this.currentSlot.isValid = true;
 			this.currentResource = resource;
 
-			// Subscribe to new resource
+			if (position >= 0) {
+				this.seekInProgress = true;
+			}
+
 			if (this.connection) {
 				this.connection.subscribe(this.audioPlayer);
 				this.audioPlayer.play(resource);
 			}
+			if (wasPaused) this.audioPlayer.pause();
 
-			// Restore playing state
-			if (wasPaused) {
-				this.audioPlayer.pause();
-			}
-
-			this.debug(`[Player] Successfully applied filter to current track at position ${currentPosition}ms`);
+			this.debug(`[Player] Resource refreshed at position ${currentPosition}ms`);
 			return true;
 		} catch (error) {
-			this.debug(`[Player] Error applying filter to current track:`, error);
-			// Filter was still added to active filters, so return true
-			return true;
+			this.debug(`[Player] refreshPlayerResource error:`, error);
+			this.seekInProgress = false;
+			this.emit("playerError", error as Error, this.queue.currentTrack ?? undefined);
+			return false;
+		} finally {
+			this.refreshLock = false;
 		}
 	}
 
@@ -2523,7 +2629,13 @@ export class Player extends EventEmitter {
 		this.audioPlayer.on("stateChange", (oldState, newState) => {
 			if (this.destroyed) return;
 			this.debug(`[Player] AudioPlayer stateChange from ${oldState.status} to ${newState.status}`);
+
+			// ── Idle: track ended naturally ───────────────────────────────────────
 			if (newState.status === AudioPlayerStatus.Idle && oldState.status !== AudioPlayerStatus.Idle) {
+				if (this.refreshLock) {
+					this.debug(`[Player] AudioPlayer went idle during resource refresh — skipping trackEnd/playNext`);
+					return;
+				}
 				// Track ended
 				const track = this.queue.currentTrack;
 				if (track) {
@@ -2534,12 +2646,19 @@ export class Player extends EventEmitter {
 					}
 				}
 				void this.playNext();
+				// ── Playing: started or resumed ───────────────────────────────────────
 			} else if (
 				newState.status === AudioPlayerStatus.Playing &&
 				(oldState.status === AudioPlayerStatus.Idle || oldState.status === AudioPlayerStatus.Buffering)
 			) {
 				// Track started
 				this.clearLeaveTimeout();
+
+				if (this.seekInProgress) {
+					this.debug(`[Player] Seek complete — audio output started`);
+					this.seekInProgress = false;
+				}
+
 				const track = this.queue.currentTrack;
 				if (track) {
 					this.debug(`[Player] Track started: ${track.title}`);
@@ -2556,6 +2675,7 @@ export class Player extends EventEmitter {
 						}
 					}
 				}
+				// ── Paused ────────────────────────────────────────────────────────────
 			} else if (newState.status === AudioPlayerStatus.Paused && oldState.status !== AudioPlayerStatus.Paused) {
 				const track = this.queue.currentTrack;
 				if (track) {
@@ -2565,6 +2685,7 @@ export class Player extends EventEmitter {
 						fp.emit("playerPause", track);
 					}
 				}
+				// ── Resumed from pause ────────────────────────────────────────────────
 			} else if (newState.status !== AudioPlayerStatus.Paused && oldState.status === AudioPlayerStatus.Paused) {
 				const track = this.queue.currentTrack;
 				if (track) {
@@ -2576,8 +2697,15 @@ export class Player extends EventEmitter {
 				}
 			} else if (newState.status === AudioPlayerStatus.AutoPaused) {
 				this.debug(`[Player] AudioPlayerStatus.AutoPaused`);
+				// ── Buffering: start stuck detector ───────────────────────────────────
 			} else if (newState.status === AudioPlayerStatus.Buffering) {
 				this.debug(`[Player] AudioPlayerStatus.Buffering`);
+
+				if (this.seekInProgress) {
+					this.debug(`[Player] Buffering during seek — stuckTimer suppressed`);
+					return;
+				}
+
 				this.lastDuration = this.currentResource?.playbackDuration || 0;
 				this.stuckTimer = setTimeout(() => {
 					if (this.currentResource?.playbackDuration === this.lastDuration) {