fix: confirm web queue injection before trusting it

Signed-off-by: Sertac Ozercan <sozercan@gmail.com>

Author: sozercan

Sources/Kaset/Services/Player/PlayerService+PlaybackControls.swift

@@ -84,6 +84,7 @@ extension PlayerService {
         self.logger.debug("play() called with videoId: \(videoId)")
         self.logger.info("Playing video: \(videoId)")
         self.clearRestoredPlaybackSessionState()
+        self.clearWebQueueInjectionState()
         self.currentEpisode = nil
         self.state = .loading
         self.songNearingEnd = false
@@ -132,6 +133,7 @@ extension PlayerService {
         self.logger.info("Playing song: \(song.title)")
         self.logger.debug("Web load strategy: \(String(describing: webLoadStrategy))")
         self.clearRestoredPlaybackSessionState()
+        self.clearWebQueueInjectionState()
         self.currentEpisode = episode
         // Brief `.loading` until the observer reports playback; in-place restarts may flash loading briefly.
         self.state = .loading
@@ -305,8 +307,22 @@ extension PlayerService {
         SingletonPlayerWebView.shared.setAutoplayBlocked(false)
 
         if self.isPendingRestoredLoadDeferred {
-            self.clearRestoredPlaybackSessionState()
+            if let pendingPlayVideoId = self.pendingPlayVideoId,
+               self.shouldLoadPendingVideoBeforePlayback
+            {
+                let strategy: SingletonPlayerWebView.VideoLoadStrategy = self.shouldForcePendingRestoredLoad ? .forceFullPageWhenSameVideoId : .standard
+                self.beginRestoredPlaybackLoad(autoResumeAfterSeek: true)
+                self.showMiniPlayer = false
+                self.state = .loading
+                self.isKasetInitiatedPlayback = true
+                if SingletonPlayerWebView.shared.webView != nil {
+                    SingletonPlayerWebView.shared.loadVideo(videoId: pendingPlayVideoId, strategy: strategy)
+                    self.shouldForcePendingRestoredLoad = false
+                }
+                return
+            }
 
+            self.clearRestoredPlaybackSessionState()
             self.showMiniPlayer = false
             self.state = .loading
             self.isKasetInitiatedPlayback = true
@@ -370,11 +386,18 @@ extension PlayerService {
                 }
             }
 
-            guard let targetIndex else { return }
+            guard let targetIndex, let targetSong = self.queue[safe: targetIndex] else { return }
             self.pushForwardSkipStackIfLeavingIndex(for: targetIndex)
-            self.advanceQueueStateForNativeNavigation(to: targetIndex)
+            if self.injectedWebQueueVideoId == targetSong.videoId {
+                self.advanceQueueStateForNativeNavigation(to: targetIndex)
+                SingletonPlayerWebView.shared.next()
+            } else {
+                self.injectedWebQueueVideoId = nil
+                await self.loadQueueSongForNavigation(at: targetIndex)
+            }
+            await self.fetchMoreMixSongsIfNeeded()
             await self.fillSmartShuffleWindow()
-            SingletonPlayerWebView.shared.next()
+            self.saveQueueForPersistence(syncWebQueue: false)
             return
         }
 
@@ -403,14 +426,12 @@ extension PlayerService {
             }
 
             if let priorIndex = self.popForwardSkipIndex(), self.queue.indices.contains(priorIndex) {
-                self.advanceQueueStateForNativeNavigation(to: priorIndex)
-                SingletonPlayerWebView.shared.previous()
+                await self.loadQueueSongForNavigation(at: priorIndex)
                 return
             }
 
             if self.currentIndex > 0 {
-                self.advanceQueueStateForNativeNavigation(to: self.currentIndex - 1)
-                SingletonPlayerWebView.shared.previous()
+                await self.loadQueueSongForNavigation(at: self.currentIndex - 1)
             } else {
                 await self.seek(to: 0)
             }
@@ -431,6 +452,14 @@ extension PlayerService {
         }
     }
 
+    /// Navigates to a queue song through Kaset's deterministic load path.
+    private func loadQueueSongForNavigation(at index: Int) async {
+        guard let song = self.queue[safe: index] else { return }
+        self.currentIndex = index
+        await self.play(song: song)
+        self.saveQueueForPersistence()
+    }
+
     /// Updates Kaset's local queue pointer for native WebView queue navigation without forcing a page load.
     private func advanceQueueStateForNativeNavigation(to index: Int) {
         guard let song = self.queue[safe: index] else { return }
@@ -440,6 +469,7 @@ extension PlayerService {
         self.currentTrack = song
         self.currentEpisode = nil
         self.pendingPlayVideoId = song.videoId
+        self.state = .loading
         self.isKasetInitiatedPlayback = true
         self.songNearingEnd = false
         self.shouldSuppressAutoplayAfterQueueEnd = false
@@ -458,7 +488,7 @@ extension PlayerService {
             self.currentTrackLikeStatus = song.likeStatus ?? self.currentTrackLikeStatus
         }
 
-        self.saveQueueForPersistence()
+        self.saveQueueForPersistence(syncWebQueue: false)
     }
 
     /// Seeks to a specific time.

Sources/Kaset/Services/Player/PlayerService+Queue.swift

@@ -721,7 +721,7 @@ extension PlayerService {
     private static let savedPlaybackSessionKey = "kaset.saved.playbackSession"
 
     /// Saves the current queue to UserDefaults for restoration on next launch.
-    func saveQueueForPersistence() {
+    func saveQueueForPersistence(syncWebQueue shouldSyncWebQueue: Bool = true) {
         let queue = self.queue
         guard !queue.isEmpty else {
             if self.suppressNextEmptyQueuePersistence {
@@ -784,8 +784,10 @@ extension PlayerService {
             self.restoredPlaybackSessionOwnerScope = ownerScope
             self.logger.info("Saved playback session with \(persistedQueue.count) songs at index \(safeIndex)")
 
-            // Re-sync the web queue in case the queue order or next song changed
-            self.syncWebQueue()
+            if shouldSyncWebQueue {
+                // Re-sync the web queue in case the queue order or next song changed
+                self.syncWebQueue()
+            }
         } catch {
             self.logger.error("Failed to save playback session: \(error.localizedDescription)")
         }

Sources/Kaset/Services/Player/PlayerService+WebQueueSync.swift

@@ -25,6 +25,9 @@ extension PlayerService {
         // Sync the web view's current video ID so Kaset knows the player is already on this track
         SingletonPlayerWebView.shared.currentVideoId = observedVideoId
         if observedVideoId == previousVideoId, !self.queue.isEmpty {
+            Task {
+                await self.fetchSongMetadata(videoId: observedVideoId)
+            }
             return
         }
         self.mixContinuationToken = nil
@@ -140,13 +143,46 @@ extension PlayerService {
         guard let nextIndex = self.expectedQueueIndexAfterCurrentTrack(),
               let nextSong = self.queue[safe: nextIndex] else { return }
 
-        if self.injectedWebQueueVideoId != nextSong.videoId {
-            self.injectedWebQueueVideoId = nextSong.videoId
-            SingletonPlayerWebView.shared.injectNextSong(videoId: nextSong.videoId)
-            self.logger.info("Synced web queue: injected \(nextSong.videoId) to play next natively")
+        guard self.injectedWebQueueVideoId != nextSong.videoId,
+              self.pendingWebQueueInjectionVideoId != nextSong.videoId
+        else { return }
+
+        self.pendingWebQueueInjectionVideoId = nextSong.videoId
+        if SingletonPlayerWebView.shared.injectNextSong(videoId: nextSong.videoId) {
+            self.logger.info("Syncing web queue: requested injection of \(nextSong.videoId) to play next natively")
+        } else {
+            self.pendingWebQueueInjectionVideoId = nil
         }
     }
 
+    /// Records the WebView result for an attempted native queue injection.
+    func handleWebQueueInjectionResult(videoId: String, success: Bool, reason: String?) {
+        if self.pendingWebQueueInjectionVideoId == videoId {
+            self.pendingWebQueueInjectionVideoId = nil
+        }
+
+        guard success else {
+            if self.injectedWebQueueVideoId == videoId {
+                self.injectedWebQueueVideoId = nil
+            }
+            self.logger.warning("Web queue injection failed for \(videoId): \(reason ?? "unknown")")
+            return
+        }
+
+        guard let nextIndex = self.expectedQueueIndexAfterCurrentTrack(),
+              self.queue[safe: nextIndex]?.videoId == videoId
+        else {
+            if self.injectedWebQueueVideoId == videoId {
+                self.injectedWebQueueVideoId = nil
+            }
+            self.logger.debug("Ignoring stale web queue injection confirmation for \(videoId)")
+            return
+        }
+
+        self.injectedWebQueueVideoId = videoId
+        self.logger.info("Synced web queue: confirmed \(videoId) to play next natively")
+    }
+
     private var canAdvanceNativeQueueAfterTrackEnd: Bool {
         self.shuffleEnabled
             || self.repeatMode == .one
@@ -571,14 +607,25 @@ extension PlayerService {
             self.pushForwardSkipStackIfLeavingIndex(for: expectedIndex)
             self.currentIndex = expectedIndex
             self.currentTrack = expectedSong
+            self.pendingPlayVideoId = expectedSong.videoId
+            self.state = .loading
+            self.songNearingEnd = false
+            self.shouldSuppressAutoplayAfterQueueEnd = false
             self.isKasetInitiatedPlayback = true
+            self.currentTrackHasVideo = expectedSong.musicVideoType?.hasVideoContent ?? expectedSong.hasVideo ?? false
             self.resetTrackStatus()
             if let cachedStatus = SongLikeStatusManager.shared.status(for: expectedSong.videoId) {
                 self.currentTrackLikeStatus = cachedStatus
             }
-            self.saveQueueForPersistence()
-            // Pre-inject the *next* next track for the following transition
-            self.syncWebQueue()
+            if let details = expectedSong.feedbackTokens {
+                self.currentTrackFeedbackTokens = details
+                self.currentTrackInLibrary = expectedSong.isInLibrary ?? false
+                self.currentTrackLikeStatus = expectedSong.likeStatus ?? self.currentTrackLikeStatus
+            }
+            self.saveQueueForPersistence(syncWebQueue: false)
+            await self.fetchMoreMixSongsIfNeeded()
+            await self.fillSmartShuffleWindow()
+            self.saveQueueForPersistence(syncWebQueue: false)
             return
         }
 
@@ -590,9 +637,22 @@ extension PlayerService {
     func updateTrackMetadata(title: String, artist: String, thumbnailUrl: String, videoId observedVideoId: String?) {
         self.logger.debug("Track metadata updated: \(title) - \(artist)")
 
-        let isRestoringFromCloud = self.queue.isEmpty && !self.isKasetInitiatedPlayback && observedVideoId != nil
+        let isRestoringFromCloud = self.isAwaitingWebRestoredTrack
+            && !self.isKasetInitiatedPlayback
+            && observedVideoId != nil
+
+        if self.isPendingRestoredLoadDeferred {
+            guard self.isAwaitingWebRestoredTrack else { return }
+            self.applyDeferredRestoredMetadata(
+                title: title,
+                artist: artist,
+                thumbnailUrl: thumbnailUrl,
+                videoId: observedVideoId
+            )
+            return
+        }
 
-        if self.isPendingRestoredLoadDeferred || isRestoringFromCloud {
+        if isRestoringFromCloud {
             self.applyDeferredRestoredMetadata(
                 title: title,
                 artist: artist,
@@ -676,6 +736,7 @@ extension PlayerService {
         )
 
         if trackChanged {
+            self.clearWebQueueInjectionState()
             self.resetTrackStatus()
             // Immediately restore like status from SongLikeStatusManager cache
             if let cachedStatus = SongLikeStatusManager.shared.status(for: resolvedVideoId) {

Sources/Kaset/Services/Player/PlayerService.swift

@@ -490,6 +490,11 @@ final class PlayerService: NSObject, PlayerServiceProtocol {
         self.currentQueueEntryID = self.queueStorage[safe: self.currentIndex]?.id
     }
 
+    func clearWebQueueInjectionState() {
+        self.injectedWebQueueVideoId = nil
+        self.pendingWebQueueInjectionVideoId = nil
+    }
+
     /// Records the current index before `next()` moves to `newIndex` (no-op if unchanged).
     func pushForwardSkipStackIfLeavingIndex(for newIndex: Int) {
         let from = self.currentIndex
@@ -573,11 +578,16 @@ final class PlayerService: NSObject, PlayerServiceProtocol {
     /// Flag to suppress YouTube autoplay after the native queue has finished.
     var shouldSuppressAutoplayAfterQueueEnd: Bool = false
 
-    /// Video ID of the song last injected into YouTube Music's native "Up Next" queue.
+    /// Video ID of the song last confirmed as injected into YouTube Music's native "Up Next" queue.
     /// Used to avoid duplicate injections and to detect when YouTube has auto-advanced
     /// to the injected track (enabling gapless transition without calling `loadVideo`).
     var injectedWebQueueVideoId: String?
 
+    /// Video ID currently being injected into YouTube Music's native "Up Next" queue.
+    /// This is intentionally separate from ``injectedWebQueueVideoId`` so track-end logic
+    /// only trusts injections after the WebView script confirms the queue payload was swapped.
+    var pendingWebQueueInjectionVideoId: String?
+
     /// Grace period instant - don't auto-close video window shortly after opening (uses monotonic clock)
     var videoWindowOpenedAt: ContinuousClock.Instant?
 

Sources/Kaset/Views/MiniPlayerWebView.swift

@@ -299,7 +299,9 @@ final class SingletonPlayerWebView {
         // Dynamic startup state is refreshed before each full page load so the
         // next document gets current volume/autoplay flags at document start.
 
-        let shouldBlockAutoplay = playerService.isRestoringPlaybackSession || playerService.pendingPlayVideoId == nil
+        let shouldBlockAutoplay = playerService.isRestoringPlaybackSession
+            || playerService.isPendingRestoredLoadDeferred
+            || playerService.pendingPlayVideoId == nil
 
         self.installUserScripts(
             on: configuration.userContentController,
@@ -658,6 +660,8 @@ final class SingletonPlayerWebView {
                 self.handleLyricsTimeUpdate(body: body)
             case "PLAYBACK_AUDIO_QUALITY_STATS":
                 Self.logAudioQualityStats(body: body, observedVideoId: observedVideoId)
+            case "QUEUE_INJECTION_RESULT":
+                self.handleQueueInjectionResult(body: body, observedVideoId: observedVideoId)
             case "STATE_UPDATE":
                 self.handleStateUpdate(body: body, observedVideoId: observedVideoId)
             default:
@@ -690,6 +694,20 @@ final class SingletonPlayerWebView {
             }
         }
 
+        private func handleQueueInjectionResult(body: [String: Any], observedVideoId: String?) {
+            guard let observedVideoId else { return }
+            let success = body["success"] as? Bool ?? false
+            let reason = body["reason"] as? String
+
+            Task { @MainActor in
+                self.playerService.handleWebQueueInjectionResult(
+                    videoId: observedVideoId,
+                    success: success,
+                    reason: reason
+                )
+            }
+        }
+
         private func handleStateUpdate(body: [String: Any], observedVideoId: String?) {
             let isPlaying = body["isPlaying"] as? Bool ?? false
             let progress = body["progress"] as? Int ?? 0
@@ -1011,7 +1029,10 @@ final class SingletonPlayerWebView {
                     }
                 })();
             """
-            SingletonPlayerWebView.shared.setAutoplayBlocked(self.playerService.isPendingRestoredLoadDeferred)
+            let shouldBlockAutoplay = self.playerService.isRestoringPlaybackSession
+                || self.playerService.isPendingRestoredLoadDeferred
+                || self.playerService.pendingPlayVideoId == nil
+            SingletonPlayerWebView.shared.setAutoplayBlocked(shouldBlockAutoplay)
 
             webView.evaluateJavaScript(applyVolumeScript) { result, error in
                 if let error {

Sources/Kaset/Views/SingletonPlayerWebView+PlaybackControls.swift

@@ -9,17 +9,30 @@ extension SingletonPlayerWebView {
         let script = """
             (function() {
                 window.__kasetBlockAutoplay = \(blocked ? "true" : "false");
+                if (window.__kasetAutoplayBlockTimer) {
+                    clearInterval(window.__kasetAutoplayBlockTimer);
+                    window.__kasetAutoplayBlockTimer = null;
+                }
                 if (!window.__kasetBlockAutoplay) return 'autoplay-allowed';
                 window.__kasetAutoplayPending = false;
                 let ticks = 0;
                 const timer = setInterval(function() {
+                    if (!window.__kasetBlockAutoplay) {
+                        clearInterval(timer);
+                        if (window.__kasetAutoplayBlockTimer === timer) window.__kasetAutoplayBlockTimer = null;
+                        return;
+                    }
                     const video = document.querySelector('video');
                     if (video && !video.paused) {
                         try { video.pause(); } catch (_) {}
                     }
                     ticks += 1;
-                    if (ticks >= 20) clearInterval(timer);
+                    if (ticks >= 20) {
+                        clearInterval(timer);
+                        if (window.__kasetAutoplayBlockTimer === timer) window.__kasetAutoplayBlockTimer = null;
+                    }
                 }, 150);
+                window.__kasetAutoplayBlockTimer = timer;
                 return 'autoplay-blocked';
             })();
         """
@@ -147,6 +160,11 @@ extension SingletonPlayerWebView {
 
         let script = """
             (function() {
+                window.__kasetBlockAutoplay = false;
+                if (window.__kasetAutoplayBlockTimer) {
+                    clearInterval(window.__kasetAutoplayBlockTimer);
+                    window.__kasetAutoplayBlockTimer = null;
+                }
                 const video = document.querySelector('video');
                 if (video && video.paused) { video.play(); return 'played'; }
                 return 'already-playing';