ziplayer 0.3.5 → 0.3.7

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();
@@ -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,26 @@ 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`);
+        // -1 = sentinel "no seek requested"
+        const seekArg = position > 0 ? position : -1;
+        if (filterString || position > 0) {
+            // throws on failure — do NOT fall back to the already-piped stream
+            const processedStream = await this.filter.applyFiltersAndSeek(streamInfo.stream, seekArg);
+            streamInfo.type = voice_1.StreamType.Arbitrary;
+            return (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 (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,
+        });
     }
     mergeTrackPreserveRef(target, source) {
         if (source === target)
@@ -897,7 +888,6 @@ class Player extends events_1.EventEmitter {
             // 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(() => {
@@ -911,13 +901,21 @@ class Player extends events_1.EventEmitter {
                 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.audioPlayer.play(currentResource);
-                await (0, voice_1.entersState)(this.audioPlayer, voice_1.AudioPlayerStatus.Playing, 10_000);
+                this.refreshLock = true;
+                try {
+                    this.audioPlayer.stop(true);
+                    this.audioPlayer.play(currentResource);
+                    await (0, voice_1.entersState)(this.audioPlayer, voice_1.AudioPlayerStatus.Playing, 10_000);
+                }
+                finally {
+                    this.refreshLock = false;
+                }
                 await this.applyCrossfadeIn(currentResource, track);
                 this.preloadNextTrack().catch((err) => {
                     this.debug(`[Player] Preload error:`, err);
@@ -969,16 +967,23 @@ class Player extends events_1.EventEmitter {
             this.currentSlot.streamId = streamId;
             this.currentSlot.isValid = true;
             this.currentResource = resource;
+            this.seekOffset = 0; // new track — reset seek baseline
             // Apply volume
             const targetVolume = this.getTrackTargetVolume(track);
             if (resource.volume) {
                 resource.volume.setVolume(this.crossfadeEnabled ? 0 : targetVolume);
             }
-            // Play
+            // Play — lock refresh so Idle event doesn't spawn duplicate playNext
             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) {
@@ -1053,6 +1058,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 +1085,10 @@ class Player extends events_1.EventEmitter {
                         await new Promise((resolve) => setTimeout(resolve, this.antiStuckRetryDelayMs));
                     }
                 }
+                else {
+                    this.antiStuckConsecutiveFailures = 0;
+                    this.skipLoop = true;
+                }
                 continue;
             }
         }
@@ -1208,15 +1221,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 +1541,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 +1716,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 +1928,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 +2031,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 +2130,113 @@ 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;
+        }
+        // Lock before anything so stateChange idle sees it when stop() fires.
         this.refreshLock = true;
+        // Clear any existing stuckTimer from the previous playback cycle so it
+        // cannot fire while we are mid-refresh.
+        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;
+            // Reuse is only viable for forward seeks (stream is sequential).
+            const isForwardSeek = position < 0 || position >= playbackDuration;
+            const currentStreamId = this.currentSlot.streamId;
+            // Try to grab the live source stream for reuse.
+            // getRawStream accepts "paused" streams (discordjs/voice pauses source streams on NoSubscriberBehavior); getStream would reject them.
+            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);
+            // ── CRITICAL: unpipe BEFORE stop ──────────────────────────────────────
+            // stop() kills discordjs/voice internal FFmpeg → EPIPE on source stream.
+            // unpipe() first disconnects our stream cleanly before that happens.
+            if (reuseStream) {
+                reuseStream.unpipe();
             }
-            finally {
-                this.refreshLock = false;
+            // Remove StreamManager listeners.
+            // forceDestroy=false when reusing so the Readable object stays alive.
+            if (currentStreamId) {
+                this.streamManager.unregisterStream(currentStreamId, !reuseStream);
+                this.currentSlot.streamId = null;
+            }
+            // Stop the AudioPlayer.
+            // stateChange (playing→idle) fires; refreshLock=true guards it (v4 fix).
+            this.audioPlayer.stop(true);
+            this.currentResource = null;
+            this.currentSlot.resource = null;
+            this.currentSlot.isValid = false;
+            // One event-loop tick: lets deferred stream events settle.
+            await new Promise((resolve) => setImmediate(resolve));
+            // Verify the reuse stream survived stop().
+            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 {
+                // Clear caches so we don't get the dead Readable back.
+                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;
             }
+            // Build AudioResource (input-side FFmpeg seek via FilterManager).
+            const resource = await this.createResource(streaminfo, track, currentPosition);
+            // Register the source stream.
+            const newStreamId = this.streamManager.registerStream(streaminfo.stream, track, {
+                source: track.source || "stream",
+                isPreload: false,
+                priority: 10,
+            });
+            this.currentSlot.resource = resource;
+            this.currentSlot.track = track;
+            this.currentSlot.streamId = newStreamId;
+            this.currentSlot.isValid = true;
             this.currentResource = resource;
-            // Subscribe to new resource
+            // ── Set seek flag BEFORE play so the Buffering handler sees it ────────
+            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; // ensure flag is cleared on failure
+            this.emit("playerError", error, this.queue.currentTrack ?? undefined);
+            return false;
+        }
+        finally {
+            this.refreshLock = false; // always released
         }
     }
     /**
@@ -2212,7 +2287,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 +2303,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 +2329,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 +2340,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 +2354,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) {