ziplayer 0.3.6 → 0.3.8

package/dist/structures/Player.js

@@ -64,6 +64,7 @@ class Player extends events_1.EventEmitter {
         this.stuckTimer = null;
         this.skipLoop = false;
         this.refreshLock = false;
+        this.seekInProgress = false;
         this.currentSlot = {
             resource: null,
             track: null,
@@ -110,6 +111,7 @@ class Player extends events_1.EventEmitter {
         this.SEARCH_CACHE_TTL = 2 * 60 * 1000; // 2 minutes
         this.ttsPlayer = null;
         this.lastDuration = 0;
+        this.seekOffset = 0;
         this.debug(`[Player] Constructor called for guildId: ${guildId}`);
         this.guildId = guildId;
         this.queue = new Queue_1.Queue();
@@ -191,7 +193,7 @@ class Player extends events_1.EventEmitter {
             extractorTimeout: this.options.extractorTimeout,
         });
         this.streamManager = new StreamManager_1.StreamManager({
-            maxConcurrentStreams: 2,
+            maxConcurrentStreams: 4,
             streamTimeout: 5 * 60 * 1000,
             maxListenersPerStream: 15,
             enableMetrics: true,
@@ -200,7 +202,12 @@ class Player extends events_1.EventEmitter {
         this.preloadManager = new PreloadManager_1.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,
@@ -743,42 +750,27 @@ class Player extends events_1.EventEmitter {
      */
     async createResource(streamInfo, track, position = 0) {
         const filterString = this.filter.getFilterString();
-        this.debug(`[Player] Creating AudioResource with filters: ${filterString || "none"}, seek: ${position}ms`);
-        try {
-            let stream = streamInfo.stream;
-            // Apply filters and seek if needed
-            if (filterString || position > 0) {
-                stream = await this.filter.applyFiltersAndSeek(streamInfo.stream, position);
-                streamInfo.type = voice_1.StreamType.Arbitrary;
-            }
-            // Create AudioResource with better error handling
-            const resource = (0, voice_1.createAudioResource)(stream, {
+        this.debug(`[Player] Creating AudioResource — filters: ${filterString || "none"}, seek: ${position}ms`);
+        this.filter.setSourceStreamType(streamInfo.type);
+        const seekArg = position > 0 ? position : -1;
+        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 = (0, voice_1.createAudioResource)(processedStream, {
                 metadata: track,
-                inputType: streamInfo.type === "webm/opus" ? voice_1.StreamType.WebmOpus
-                    : streamInfo.type === "ogg/opus" ? voice_1.StreamType.OggOpus
-                        : voice_1.StreamType.Arbitrary,
+                inputType: voice_1.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 = (0, voice_1.createAudioResource)(streamInfo.stream, {
-                    metadata: track,
-                    inputType: streamInfo.type === "webm/opus" ? voice_1.StreamType.WebmOpus
-                        : streamInfo.type === "ogg/opus" ? voice_1.StreamType.OggOpus
-                            : voice_1.StreamType.Arbitrary,
-                    inlineVolume: true,
-                });
-                return resource;
-            }
-            catch (fallbackError) {
-                this.debug(`[Player] Fallback AudioResource creation failed:`, fallbackError);
-                throw fallbackError;
-            }
-        }
+            return { resource, processedStream };
+        }
+        const resource = (0, voice_1.createAudioResource)(streamInfo.stream, {
+            metadata: track,
+            inputType: streamInfo.type === "webm/opus" ? voice_1.StreamType.WebmOpus
+                : streamInfo.type === "ogg/opus" ? voice_1.StreamType.OggOpus
+                    : voice_1.StreamType.Arbitrary,
+            inlineVolume: true,
+        });
+        return { resource, processedStream: null };
     }
     mergeTrackPreserveRef(target, source) {
         if (source === target)
@@ -879,7 +871,14 @@ class Player extends events_1.EventEmitter {
     async startTrack(track) {
         if (this.destroyed)
             return false;
-        // First, get stream info (this will handle remote detection)
+        // 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 = null;
         try {
             streamInfo = await this.getStream(track);
@@ -888,99 +887,114 @@ class Player extends events_1.EventEmitter {
             this.debug(`[Player] Failed to get stream for track: ${track.title}`, error);
             throw error;
         }
-        // Handle remote playback
+        // Remote playback
         if (streamInfo?.remote && streamInfo.handle) {
             return await this.playRemote(track, streamInfo);
         }
-        // Handle native playback
+        // Native playback — pass the already-fetched streamInfo to avoid a second fetch
+        return await this.loadFreshStream(track, streamInfo);
+    }
+    async startFromPreload(track) {
+        if (this.destroyed)
+            return false;
+        this.debug(`[Player] Using preloaded stream for: ${track.title}`);
+        const oldStreamId = this.currentSlot.streamId;
+        this.promotePreloadToCurrent(track);
+        if (oldStreamId && oldStreamId !== this.currentSlot.streamId) {
+            this.streamManager.unregisterStream(oldStreamId, true);
+            this.debug(`[Player] Released old stream ${oldStreamId} after preload promotion`);
+        }
+        const currentResource = this.currentSlot.resource;
+        if (!currentResource)
+            return false;
+        this.seekOffset = 0;
+        const targetVolume = this.getTrackTargetVolume(track);
+        if (currentResource.volume) {
+            currentResource.volume.setVolume(this.crossfadeEnabled ? 0 : targetVolume);
+        }
+        await this.maybeAlignToBeatBoundary();
+        this.refreshLock = true;
         try {
-            // Try to use preloaded resource
-            if (this.preloadManager.hasValidPreload(track)) {
-                this.debug(`[Player] Using preloaded stream for: ${track.title}`);
-                this.audioPlayer.stop(true);
-                const oldStreamId = this.currentSlot.streamId;
-                if (oldStreamId && this.streamManager) {
-                    setTimeout(() => {
-                        if (this.currentSlot.streamId === oldStreamId) {
-                            this.streamManager.unregisterStream(oldStreamId, true);
-                        }
-                    }, 3000);
-                }
-                this.promotePreloadToCurrent(track);
-                const currentResource = this.currentSlot.resource;
-                if (!currentResource) {
-                    return false;
-                }
-                const targetVolume = this.getTrackTargetVolume(track);
-                if (currentResource.volume) {
-                    currentResource.volume.setVolume(this.crossfadeEnabled ? 0 : targetVolume);
-                }
-                await this.maybeAlignToBeatBoundary();
-                this.audioPlayer.play(currentResource);
-                await (0, voice_1.entersState)(this.audioPlayer, voice_1.AudioPlayerStatus.Playing, 10_000);
-                await this.applyCrossfadeIn(currentResource, track);
-                this.preloadNextTrack().catch((err) => {
-                    this.debug(`[Player] Preload error:`, err);
-                });
-                return true;
-            }
-            this.debug(`[Player] No preload available, loading fresh: ${track.title}`);
-            return await this.loadFreshStream(track);
+            this.audioPlayer.stop(true);
+            this.audioPlayer.play(currentResource);
+            await (0, voice_1.entersState)(this.audioPlayer, voice_1.AudioPlayerStatus.Playing, 10_000);
         }
-        catch (error) {
-            this.debug(`[Player] startTrack error:`, error);
-            this.emit("playerError", error, track);
-            return false;
+        finally {
+            this.refreshLock = false;
         }
+        await this.applyCrossfadeIn(currentResource, track);
+        this.preloadNextTrack().catch((err) => {
+            this.debug(`[Player] Preload error:`, err);
+        });
+        return true;
     }
     /**
      * Load fresh stream when no preload available
      */
-    async loadFreshStream(track) {
+    async loadFreshStream(track, preloadedStreamInfo) {
         if (this.destroyed)
             return false;
-        // Cancel preload to free resources
         await this.safeCancelPreload();
         try {
-            const streamInfo = await this.getStream(track);
-            // Handle remote playback
+            // 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));
             if (streamInfo?.remote && streamInfo.handle) {
                 return await this.playRemote(track, streamInfo);
             }
             if (!streamInfo?.stream) {
                 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);
             }
-            // Set current slot
+            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 = streamId;
+            this.currentSlot.streamId = rawStreamId;
+            this.currentSlot.processedStreamId = processedStream ? playStreamId : null;
             this.currentSlot.isValid = true;
             this.currentResource = resource;
-            // Apply volume
+            this.seekOffset = 0;
             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 (0, voice_1.entersState)(this.audioPlayer, voice_1.AudioPlayerStatus.Playing, 10_000);
+            this.refreshLock = true;
+            try {
+                this.audioPlayer.stop(true);
+                this.audioPlayer.play(resource);
+                await (0, voice_1.entersState)(this.audioPlayer, voice_1.AudioPlayerStatus.Playing, 10_000);
+            }
+            finally {
+                this.refreshLock = false;
+            }
             await this.applyCrossfadeIn(resource, track);
-            // Preload next (async)
             if (!this.destroyed) {
                 this.preloadNextTrack().catch((err) => {
                     this.debug(`[Player] Preload error:`, err);
@@ -1053,6 +1067,10 @@ class Player extends events_1.EventEmitter {
                         await new Promise((resolve) => setTimeout(resolve, this.antiStuckRetryDelayMs));
                     }
                 }
+                else {
+                    this.antiStuckConsecutiveFailures = 0;
+                    this.skipLoop = true;
+                }
             }
             catch (err) {
                 this.debug(`[Player] playNext error:`, err);
@@ -1076,6 +1094,10 @@ class Player extends events_1.EventEmitter {
                         await new Promise((resolve) => setTimeout(resolve, this.antiStuckRetryDelayMs));
                     }
                 }
+                else {
+                    this.antiStuckConsecutiveFailures = 0;
+                    this.skipLoop = true;
+                }
                 continue;
             }
         }
@@ -1140,7 +1162,7 @@ class Player extends events_1.EventEmitter {
                 throw new Error(`No stream available for track: ${track.title}`);
             }
             ttsStream = streamInfo.stream;
-            const resource = await this.createResource(streamInfo, track);
+            const { resource, processedStream } = await this.createResource(streamInfo, track);
             if (!resource) {
                 throw new Error(`No resource available for track: ${track.title}`);
             }
@@ -1208,15 +1230,17 @@ class Player extends events_1.EventEmitter {
      * @example
      * await player.connect(voiceChannel);
      */
-    async connect(channel) {
+    async connect(channel, options) {
         try {
             this.debug(`[Player] Connecting to voice channel: ${channel.id}`);
             const connection = (0, voice_1.joinVoiceChannel)({
+                ...options,
                 channelId: channel.id,
                 guildId: channel.guildId,
                 adapterCreator: channel.guild.voiceAdapterCreator,
-                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 (0, voice_1.entersState)(connection, voice_1.VoiceConnectionStatus.Ready, 50_000);
             this.connection = connection;
@@ -1526,7 +1550,11 @@ class Player extends events_1.EventEmitter {
             this.debug(`[Player] Invalid seek position: ${position}ms (track duration: ${totalDuration}ms)`);
             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;
     }
     /**
@@ -1697,9 +1725,9 @@ class Player extends events_1.EventEmitter {
      * console.log(`Loop mode: ${loopMode}`);
      */
     loop(mode) {
-        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");
@@ -1909,8 +1937,8 @@ class Player extends events_1.EventEmitter {
         }
         const total = track.duration > 1000 ? track.duration : track.duration * 1000;
         if (!total)
-            return this.formatTimeCompact(resource.playbackDuration);
-        const current = resource.playbackDuration;
+            return this.formatTimeCompact(resource.playbackDuration + this.seekOffset);
+        const current = resource.playbackDuration + this.seekOffset;
         const ratio = Math.min(Math.max(current / total, 0), 1);
         const progress = Math.round(ratio * size);
         // Build progress bar
@@ -2012,7 +2040,7 @@ class Player extends events_1.EventEmitter {
             };
         }
         const total = track.duration > 1000 ? track.duration : track.duration * 1000;
-        const current = resource.playbackDuration;
+        const current = resource.playbackDuration + this.seekOffset;
         return {
             current: current,
             total: total,
@@ -2111,57 +2139,112 @@ class Player extends events_1.EventEmitter {
         if (!applyToCurrent || !this.queue.currentTrack || !(this.isPlaying || this.isPaused)) {
             return false;
         }
-        if (this.refreshLock)
+        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 streaminfo = await this.getStream(track);
-            if (!streaminfo?.stream) {
-                this.debug(`[Player] No stream to refresh`);
-                return false;
-            }
-            // Create AudioResource with filters and seek to current position
-            const resource = await this.createResource(streaminfo, track, currentPosition);
-            // Stop current playback and destroy old resource/stream
-            const wasPlaying = this.isPlaying;
+            const currentPosition = position >= 0 ? position : (this.currentResource?.playbackDuration ?? 0);
+            this.seekOffset = currentPosition;
             const wasPaused = this.isPaused;
-            this.audioPlayer.stop();
-            // Properly destroy the old resource and stream
-            try {
-                if (this.currentResource) {
-                    const oldStream = this.currentResource._readableState?.stream || this.currentResource.stream;
-                    if (oldStream && typeof oldStream.destroy === "function") {
-                        oldStream.destroy();
-                    }
+            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 = null;
+            if (isForwardSeek && currentStreamId) {
+                reuseStream = this.streamManager.getRawStream(currentStreamId);
+                if (reuseStream) {
+                    this.debug(`[Player] Will reuse source stream for seek (pos: ${currentPosition}ms)`);
                 }
             }
-            catch (error) {
-                this.debug(`[Player] Error destroying old stream in refreshPlayerResource:`, error);
+            if (reuseStream) {
+                reuseStream.unpipe();
             }
-            finally {
-                this.refreshLock = false;
+            // Clean up processedStream first (it's what AudioResource reads)
+            const processedStreamId = this.currentSlot.processedStreamId;
+            if (processedStreamId && processedStreamId !== currentStreamId) {
+                this.streamManager.unregisterStream(processedStreamId, true);
+                this.currentSlot.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((resolve) => setImmediate(resolve));
+            if (reuseStream) {
+                if (reuseStream.destroyed || reuseStream.readable === false) {
+                    this.debug(`[Player] Source stream did not survive stop — falling back to fresh stream`);
+                    reuseStream = null;
+                }
             }
+            let streaminfo = 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);
+            }
+            if (!streaminfo?.stream) {
+                this.debug(`[Player] No stream available for refresh`);
+                return false;
+            }
+            const createPosition = reuseStream ? -1 : currentPosition;
+            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,
+            });
+            let newProcessedStreamId = 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.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);
             }
-            // Restore playing state
-            if (wasPaused) {
+            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, this.queue.currentTrack ?? undefined);
+            return false;
+        }
+        finally {
+            this.refreshLock = false;
         }
     }
     /**
@@ -2212,7 +2295,12 @@ class Player extends events_1.EventEmitter {
             if (this.destroyed)
                 return;
             this.debug(`[Player] AudioPlayer stateChange from ${oldState.status} to ${newState.status}`);
+            // ── Idle: track ended naturally ───────────────────────────────────────
             if (newState.status === voice_1.AudioPlayerStatus.Idle && oldState.status !== voice_1.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) {
@@ -2223,11 +2311,16 @@ class Player extends events_1.EventEmitter {
                     }
                 }
                 void this.playNext();
+                // ── Playing: started or resumed ───────────────────────────────────────
             }
             else if (newState.status === voice_1.AudioPlayerStatus.Playing &&
                 (oldState.status === voice_1.AudioPlayerStatus.Idle || oldState.status === voice_1.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}`);
@@ -2244,6 +2337,7 @@ class Player extends events_1.EventEmitter {
                         }
                     }
                 }
+                // ── Paused ────────────────────────────────────────────────────────────
             }
             else if (newState.status === voice_1.AudioPlayerStatus.Paused && oldState.status !== voice_1.AudioPlayerStatus.Paused) {
                 const track = this.queue.currentTrack;
@@ -2254,6 +2348,7 @@ class Player extends events_1.EventEmitter {
                         fp.emit("playerPause", track);
                     }
                 }
+                // ── Resumed from pause ────────────────────────────────────────────────
             }
             else if (newState.status !== voice_1.AudioPlayerStatus.Paused && oldState.status === voice_1.AudioPlayerStatus.Paused) {
                 const track = this.queue.currentTrack;
@@ -2267,9 +2362,14 @@ class Player extends events_1.EventEmitter {
             }
             else if (newState.status === voice_1.AudioPlayerStatus.AutoPaused) {
                 this.debug(`[Player] AudioPlayerStatus.AutoPaused`);
+                // ── Buffering: start stuck detector ───────────────────────────────────
             }
             else if (newState.status === voice_1.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) {