react-native-nitro-player 1.5.0 → 1.6.0-alpha.0

package/ios/core/TrackPlayerQueue.swift

@@ -18,11 +18,13 @@ extension TrackPlayerCore {
     await withPlayerQueueNoThrow { self.getActualQueueInternal() }
   }
 
+  @discardableResult
+  func skipToIndexOnQueue(index: Int) -> Bool {
+    isCasting ? skipToIndexCastInternal(index: index) : skipToIndexInternal(index: index)
+  }
+
   func skipToIndex(index: Int) async -> Bool {
-    if isCasting {
-      return await withPlayerQueueNoThrow { self.skipToIndexCastInternal(index: index) }
-    }
-    return await withPlayerQueueNoThrow { self.skipToIndexInternal(index: index) }
+    await withPlayerQueueNoThrow { self.skipToIndexOnQueue(index: index) }
   }
 
   func playFromIndex(index: Int) async {
@@ -144,6 +146,28 @@ extension TrackPlayerCore {
     return queue
   }
 
+  /// Length of the logical queue and the current track's position in it, derived
+  /// arithmetically. `getActualQueueInternal()` copies every TrackItem to answer the
+  /// same two questions — too expensive to run on every playback-state change.
+  func actualQueueMetrics() -> (count: Int, position: Int) {
+    let before: Int
+    if currentTemporaryType != .none {
+      before = min(currentTrackIndex + 1, currentTracks.count)
+    } else {
+      before = max(0, currentTrackIndex)
+    }
+    let hasCurrent = getCurrentTrack() != nil
+    let playNextCount =
+      currentTemporaryType == .playNext ? max(0, playNextStack.count - 1) : playNextStack.count
+    let upNextCount =
+      currentTemporaryType == .upNext ? max(0, upNextQueue.count - 1) : upNextQueue.count
+    let after =
+      currentTrackIndex + 1 < currentTracks.count ? currentTracks.count - (currentTrackIndex + 1) : 0
+
+    let count = before + (hasCurrent ? 1 : 0) + playNextCount + upNextCount + after
+    return (count, hasCurrent ? before : -1)
+  }
+
   func getCurrentTrack() -> TrackItem? {
     if currentTemporaryType != .none, let trackId = activeCurrentTrackId {
       if currentTemporaryType == .playNext { return playNextStack.first(where: { $0.id == trackId }) }

package/ios/core/TrackPlayerQueueBuild.swift

@@ -11,6 +11,34 @@ import Foundation
 
 extension TrackPlayerCore {
 
+  /// Cancels an item's outstanding asset loading before it is released.
+  ///
+  /// `AVURLAsset.dealloc` blocks the deallocating thread inside `URLAssetFinalize`
+  /// until any in-flight `loadValuesAsynchronously` / resource-loader work finishes —
+  /// and AVPlayer tears removed items down on the MAIN thread. Dropping items without
+  /// cancelling first therefore stalls the main run loop (and with it RCTTiming, so
+  /// JS timers stop firing) for as long as the pending loads take.
+  /// `cancelLoading()` itself waits for in-flight work to unwind, so it is only worth
+  /// paying on a full teardown (playlist switch / jump), never on the incremental
+  /// window rebuild that runs on every playNext / addToUpNext.
+  ///
+  /// A cancelled asset must never be handed back out: `createGaplessPlayerItem` reuses
+  /// `preloadedAssets`, and reusing a cancelled one yields an item that fails and then
+  /// burns the failed-item retry budget. Evict it instead.
+  func cancelLoading(of item: AVPlayerItem) {
+    guard let asset = item.asset as? AVURLAsset else { return }
+    if let trackId = item.trackId, preloadedAssets[trackId] === asset {
+      preloadedAssets.removeValue(forKey: trackId)
+    }
+    asset.cancelLoading()
+  }
+
+  /// Removes every item from the player, cancelling their asset loads first.
+  func removeAllItemsCancellingLoads(_ player: AVQueuePlayer) {
+    for item in player.items() { cancelLoading(of: item) }
+    player.removeAllItems()
+  }
+
   func updatePlayerQueue(tracks: [TrackItem]) {
     // While casting, mirror the new queue to the Cast device instead of building
     // the local AVQueuePlayer (which would start local audio).
@@ -55,6 +83,7 @@ extension TrackPlayerCore {
     player?.automaticallyWaitsToMinimizeStalling = true
 
     // Clear old preloaded assets when loading new queue
+    for asset in preloadedAssets.values { asset.cancelLoading() }
     preloadedAssets.removeAll()
 
     guard let existingPlayer = self.player else {
@@ -63,7 +92,7 @@ extension TrackPlayerCore {
     }
 
     NitroPlayerLogger.log("TrackPlayerCore", "🔄 Removing \(existingPlayer.items().count) old items from player")
-    existingPlayer.removeAllItems()
+    removeAllItemsCancellingLoads(existingPlayer)
 
     // Lazy-load mode if the first track needs a URL. Tracks further in the queue with
     // empty URLs are dropped safely by compactMap below and resolved via onTracksNeedUpdate.
@@ -75,7 +104,9 @@ extension TrackPlayerCore {
       return
     }
 
-    let items = tracks.enumerated().compactMap { (index, track) -> AVPlayerItem? in
+    // Only materialize a window of items — the rest are added as playback advances.
+    let windowed = tracks.prefix(1 + Constants.queueWindowSize)
+    let items = windowed.enumerated().compactMap { (index, track) -> AVPlayerItem? in
       let isPreload = index < Constants.gaplessPreloadCount
       return createGaplessPlayerItem(for: track, isPreload: isPreload)
     }
@@ -182,7 +213,7 @@ extension TrackPlayerCore {
         player?.removeTimeObserver(boundaryObserver)
         self.boundaryTimeObserver = nil
       }
-      player?.removeAllItems()
+      if let p = player { removeAllItemsCancellingLoads(p) }
       self.currentTracks = fullPlaylist
       if let track = self.currentTracks[safe: index] {
         notifyTrackChange(track, .skip)
@@ -190,7 +221,8 @@ extension TrackPlayerCore {
       return true
     }
 
-    let tracksToPlay = Array(fullPlaylist[index...])
+    let windowEnd = min(index + 1 + Constants.queueWindowSize, fullPlaylist.count)
+    let tracksToPlay = Array(fullPlaylist[index..<windowEnd])
     NitroPlayerLogger.log("TrackPlayerCore", "   🔄 Creating gapless queue with \(tracksToPlay.count) tracks starting from index \(index)")
 
     let items = tracksToPlay.enumerated().compactMap { (offset, track) -> AVPlayerItem? in
@@ -212,7 +244,7 @@ extension TrackPlayerCore {
     // Re-enable stall waiting for the new first track
     player.automaticallyWaitsToMinimizeStalling = true
 
-    player.removeAllItems()
+    removeAllItemsCancellingLoads(player)
     var lastItem: AVPlayerItem? = nil
     for item in items {
       player.insert(item, after: lastItem)
@@ -308,6 +340,11 @@ extension TrackPlayerCore {
       newQueueTracks.append(contentsOf: currentTracks[(currentTrackIndex + 1)...])
     }
 
+    // Window the materialized queue — currentItemDidChange tops it up on every transition.
+    if newQueueTracks.count > Constants.queueWindowSize {
+      newQueueTracks.removeSubrange(Constants.queueWindowSize...)
+    }
+
     // Collect existing upcoming AVPlayerItems
     let upcomingItems: [AVPlayerItem]
     if let ci = currentItem, let ciIndex = playingItems.firstIndex(of: ci) {
@@ -370,19 +407,47 @@ extension TrackPlayerCore {
       return
     }
 
-    // Full rebuild path (no changedTrackIds — skip, reorder, etc.)
-    for item in playingItems where item != currentItem {
+    // Incremental path (no changedTrackIds — skip, reorder, window top-up).
+    // Keep the longest matching prefix of already-buffered items and only rebuild
+    // from the first divergence. A pure append (the common window top-up) therefore
+    // touches nothing that is already buffered, preserving gapless transitions.
+    var commonPrefix = 0
+    while commonPrefix < upcomingItems.count,
+      commonPrefix < newQueueTracks.count,
+      upcomingItems[commonPrefix].trackId == newQueueTracks[commonPrefix].id
+    {
+      commonPrefix += 1
+    }
+
+    for item in upcomingItems[commonPrefix...] {
       player.remove(item)
     }
 
-    var lastItem = currentItem
-    for (offset, track) in newQueueTracks.enumerated() {
+    var lastItem: AVPlayerItem? = commonPrefix > 0 ? upcomingItems[commonPrefix - 1] : currentItem
+    for offset in commonPrefix..<newQueueTracks.count {
       let isPreload = offset < Constants.gaplessPreloadCount
-      if let item = createGaplessPlayerItem(for: track, isPreload: isPreload) {
+      if let item = createGaplessPlayerItem(for: newQueueTracks[offset], isPreload: isPreload) {
         player.insert(item, after: lastItem)
         lastItem = item
       }
     }
+
+    let created = newQueueTracks.count - commonPrefix
+    NitroPlayerLogger.log(
+      "TrackPlayerCore",
+      "🔄 Incremental rebuild: kept \(commonPrefix) buffered items, created \(created)")
+  }
+
+  /// True when the logical queue has a track after the current one, regardless of
+  /// how much of it is currently materialized into the AVQueuePlayer.
+  func hasUpcomingTrack() -> Bool {
+    let pendingPlayNext =
+      currentTemporaryType == .playNext ? max(0, playNextStack.count - 1) : playNextStack.count
+    if pendingPlayNext > 0 { return true }
+    let pendingUpNext =
+      currentTemporaryType == .upNext ? max(0, upNextQueue.count - 1) : upNextQueue.count
+    if pendingUpNext > 0 { return true }
+    return currentTrackIndex + 1 < currentTracks.count
   }
 
   /// Extracts custom HTTP headers (e.g. `Authorization`) from `extraPayload.headers`.
@@ -479,46 +544,40 @@ extension TrackPlayerCore {
     item.canUseNetworkResourcesForLiveStreamingWhilePaused = true
     item.trackId = track.id
 
-    if isPreload {
-      asset.loadValuesAsynchronously(forKeys: Constants.preloadAssetKeys) {
-        var allKeysLoaded = true
-        for key in Constants.preloadAssetKeys {
-          var error: NSError?
-          let status = asset.statusOfValue(forKey: key, error: &error)
-          if status == .failed {
-            NitroPlayerLogger.log("TrackPlayerCore", "⚠️ Failed to load key '\(key)' for \(track.title): \(error?.localizedDescription ?? "unknown")")
-            allKeysLoaded = false
-          }
-        }
-        if allKeysLoaded {
-          NitroPlayerLogger.log("TrackPlayerCore", "✅ All asset keys preloaded for \(track.title)")
-        }
-        // "tracks" key is now loaded — EQ tap attaches synchronously
-        EqualizerCore.shared.applyAudioMix(to: item)
-      }
-    } else {
-      EqualizerCore.shared.applyAudioMix(to: item)
-    }
+    // Deliberately NOT calling loadValuesAsynchronously here.
+    //
+    // AVURLAsset.dealloc blocks its thread inside URLAssetFinalize until any in-flight
+    // key load finishes — and AVPlayer tears removed items down on the MAIN thread, so
+    // an item discarded mid-load stalls the main run loop (and RCTTiming with it, which
+    // stops JS timers). Asset warm-up still happens in preloadUpcomingTracks, which only
+    // publishes assets into `preloadedAssets` once every key has finished loading, so a
+    // reused preloaded asset has nothing in flight either.
+    //
+    // Caveat: with the equalizer ENABLED, applyAudioMix still loads the "tracks" key
+    // asynchronously for assets that don't have it yet, so a small window remains. That
+    // is unchanged from before (it was already the non-preload path) and is strictly
+    // less in-flight work than the previous 4-key preload on every queued item.
+    EqualizerCore.shared.applyAudioMix(to: item)
 
     return item
   }
 
   /// Preloads assets for upcoming tracks to enable gapless playback
   func preloadUpcomingTracks(from startIndex: Int) {
-    // Capture the set of track IDs that already have AVPlayerItems in the queue.
+    // Snapshot every piece of playerQueue-owned state HERE (we are on playerQueue).
+    // `preloadQueue` must never touch currentTracks / preloadedAssets directly —
+    // Swift Array/Dictionary are not safe for concurrent access.
     let queuedTrackIds = Set(player?.items().compactMap { $0.trackId } ?? [])
+    let alreadyPreloaded = Set(preloadedAssets.keys)
+    let endIndex = min(startIndex + Constants.gaplessPreloadCount, currentTracks.count)
+    guard startIndex >= 0, startIndex < endIndex else { return }
+    let candidates = Array(currentTracks[startIndex..<endIndex])
 
     preloadQueue.async { [weak self] in
       guard let self else { return }
 
-      let tracks = self.currentTracks
-      let endIndex = min(startIndex + Constants.gaplessPreloadCount, tracks.count)
-
-      for i in startIndex..<endIndex {
-        guard i < tracks.count else { break }
-        let track = tracks[i]
-
-        if self.preloadedAssets[track.id] != nil || queuedTrackIds.contains(track.id) {
+      for track in candidates {
+        if alreadyPreloaded.contains(track.id) || queuedTrackIds.contains(track.id) {
           continue
         }
 
@@ -567,7 +626,8 @@ extension TrackPlayerCore {
 
     let assetsToRemove = self.preloadedAssets.keys.filter { !keepIds.contains($0) }
     for id in assetsToRemove {
-      self.preloadedAssets.removeValue(forKey: id)
+      // Cancel before dropping the last reference — see cancelLoading(of:).
+      self.preloadedAssets.removeValue(forKey: id)?.cancelLoading()
     }
 
     if !assetsToRemove.isEmpty {

package/ios/core/TrackPlayerRecovery.swift

@@ -64,7 +64,7 @@ extension TrackPlayerCore {
     notifyTracksNeedUpdate(tracks: [track], lookahead: lookaheadCount)
 
     // A preloaded asset for this track shares the same dead connection state.
-    preloadedAssets.removeValue(forKey: trackId)
+    preloadedAssets.removeValue(forKey: trackId)?.cancelLoading()
     // Surface a buffering state while the retry is pending.
     isRecoveringFromStall = true
     emitStateChange()

package/ios/core/TrackPlayerTempQueue.swift

@@ -9,159 +9,166 @@ import Foundation
 extension TrackPlayerCore {
 
   func loadPlaylist(playlistId: String, startIndex: Int? = nil) async {
-    await withPlayerQueueNoThrow {
-      self.playNextStack.removeAll()
-      self.upNextQueue.removeAll()
-      self.currentTemporaryType = .none
-
-      NitroPlayerLogger.log("TrackPlayerCore", "\n" + String(repeating: "🎼", count: Constants.playlistSeparatorLength))
-      NitroPlayerLogger.log("TrackPlayerCore", "📂 LOAD PLAYLIST REQUEST")
-      NitroPlayerLogger.log("TrackPlayerCore", "   Playlist ID: \(playlistId)")
-      NitroPlayerLogger.log("TrackPlayerCore", "   🧹 Cleared temporary tracks")
-
-      guard let playlist = self.playlistManager.getPlaylist(playlistId: playlistId) else {
-        NitroPlayerLogger.log("TrackPlayerCore", "   ❌ Playlist NOT FOUND")
-        NitroPlayerLogger.log("TrackPlayerCore", String(repeating: "🎼", count: Constants.playlistSeparatorLength) + "\n")
-        return
-      }
+    await withPlayerQueueNoThrow { self.loadPlaylistOnQueue(playlistId: playlistId, startIndex: startIndex) }
+  }
 
-      NitroPlayerLogger.log("TrackPlayerCore", "   ✅ Found playlist: \(playlist.name)")
-      NitroPlayerLogger.log("TrackPlayerCore", "   📋 Contains \(playlist.tracks.count) tracks:")
-      for (index, track) in playlist.tracks.enumerated() {
-        NitroPlayerLogger.log("TrackPlayerCore", "      [\(index + 1)] \(track.title) - \(track.artist)")
-      }
+  func loadPlaylistOnQueue(playlistId: String, startIndex: Int? = nil) {
+    self.playNextStack.removeAll()
+    self.upNextQueue.removeAll()
+    self.currentTemporaryType = .none
+
+    NitroPlayerLogger.log("TrackPlayerCore", "\n" + String(repeating: "🎼", count: Constants.playlistSeparatorLength))
+    NitroPlayerLogger.log("TrackPlayerCore", "📂 LOAD PLAYLIST REQUEST")
+    NitroPlayerLogger.log("TrackPlayerCore", "   Playlist ID: \(playlistId)")
+    NitroPlayerLogger.log("TrackPlayerCore", "   🧹 Cleared temporary tracks")
+
+    guard let playlist = self.playlistManager.getPlaylist(playlistId: playlistId) else {
+      NitroPlayerLogger.log("TrackPlayerCore", "   ❌ Playlist NOT FOUND")
       NitroPlayerLogger.log("TrackPlayerCore", String(repeating: "🎼", count: Constants.playlistSeparatorLength) + "\n")
+      return
+    }
 
-      let targetIndex: Int
-      if let startIndex {
-        guard startIndex >= 0 && startIndex < playlist.tracks.count else {
-          NitroPlayerLogger.log("TrackPlayerCore", "   ❌ Invalid start index: \(startIndex) (track count: \(playlist.tracks.count))")
-          return
-        }
-        targetIndex = startIndex
-      } else {
-        targetIndex = 0
-      }
+    NitroPlayerLogger.log("TrackPlayerCore", "   ✅ Found playlist: \(playlist.name)")
+    NitroPlayerLogger.log("TrackPlayerCore", "   📋 Contains \(playlist.tracks.count) tracks:")
+    for (index, track) in playlist.tracks.enumerated() {
+      NitroPlayerLogger.log("TrackPlayerCore", "      [\(index + 1)] \(track.title) - \(track.artist)")
+    }
+    NitroPlayerLogger.log("TrackPlayerCore", String(repeating: "🎼", count: Constants.playlistSeparatorLength) + "\n")
 
-      self.currentPlaylistId = playlistId
-      if targetIndex == 0 {
-        self.updatePlayerQueue(tracks: playlist.tracks)
-      } else {
-        // Bypass updatePlayerQueue to avoid emitting a spurious onTrackChange for index 0.
-        // Set currentTracks directly so rebuildQueueFromPlaylistIndex can use them.
-        self.currentTracks = playlist.tracks
-        self.preloadedAssets.removeAll()
-        _ = self.rebuildQueueFromPlaylistIndex(index: targetIndex)
+    let targetIndex: Int
+    if let startIndex {
+      guard startIndex >= 0 && startIndex < playlist.tracks.count else {
+        NitroPlayerLogger.log("TrackPlayerCore", "   ❌ Invalid start index: \(startIndex) (track count: \(playlist.tracks.count))")
+        return
       }
-      self.emitStateChange()
-      self.checkUpcomingTracksForUrls(lookahead: self.lookaheadCount)
-      self.notifyTemporaryQueueChange()
+      targetIndex = startIndex
+    } else {
+      targetIndex = 0
+    }
+
+    self.currentPlaylistId = playlistId
+    if targetIndex == 0 {
+      self.updatePlayerQueue(tracks: playlist.tracks)
+    } else {
+      // Bypass updatePlayerQueue to avoid emitting a spurious onTrackChange for index 0.
+      // Set currentTracks directly so rebuildQueueFromPlaylistIndex can use them.
+      self.currentTracks = playlist.tracks
+      for asset in self.preloadedAssets.values { asset.cancelLoading() }
+      self.preloadedAssets.removeAll()
+      _ = self.rebuildQueueFromPlaylistIndex(index: targetIndex)
     }
+    self.emitStateChange()
+    self.checkUpcomingTracksForUrls(lookahead: self.lookaheadCount)
+    self.notifyTemporaryQueueChange()
   }
 
+  /// Callable from any thread (PlaylistManager runs on its own queue) — all state
+  /// access happens on playerQueue.
   func updatePlaylist(playlistId: String) {
-    guard currentPlaylistId == playlistId else { return }
-
-    // Cancel any pending rebuild so back-to-back calls collapse into a single rebuild.
-    pendingPlaylistUpdateWorkItem?.cancel()
-
-    let workItem = DispatchWorkItem { [weak self] in
-      guard let self, self.currentPlaylistId == playlistId,
-        let playlist = self.playlistManager.getPlaylist(playlistId: playlistId) else { return }
+    playerQueue.async { [weak self] in
+      guard let self, self.currentPlaylistId == playlistId else { return }
+
+      self.playlistUpdateGeneration &+= 1
+      let generation = self.playlistUpdateGeneration
+
+      // Run at the tail of the current burst; stale generations drop out.
+      self.playerQueue.async { [weak self] in
+        guard let self, generation == self.playlistUpdateGeneration,
+          self.currentPlaylistId == playlistId,
+          let playlist = self.playlistManager.getPlaylist(playlistId: playlistId) else { return }
+
+        // If nothing is playing yet, do a full load
+        guard self.player?.currentItem != nil else {
+          self.updatePlayerQueue(tracks: playlist.tracks)
+          self.checkUpcomingTracksForUrls(lookahead: self.lookaheadCount)
+          return
+        }
 
-      // If nothing is playing yet, do a full load
-      guard self.player?.currentItem != nil else {
-        self.updatePlayerQueue(tracks: playlist.tracks)
+        // Update tracks list without interrupting playback
+        self.currentTracks = playlist.tracks
+        self.rebuildAVQueueFromCurrentPosition()
         self.checkUpcomingTracksForUrls(lookahead: self.lookaheadCount)
-        return
       }
-
-      // Update tracks list without interrupting playback
-      self.currentTracks = playlist.tracks
-      self.rebuildAVQueueFromCurrentPosition()
-      self.checkUpcomingTracksForUrls(lookahead: self.lookaheadCount)
     }
-
-    pendingPlaylistUpdateWorkItem = workItem
-    playerQueue.async(execute: workItem)
   }
 
-  func playNext(trackId: String) async throws {
-    try await withPlayerQueue {
-      guard let track = self.findTrackById(trackId) else {
-        throw NSError(domain: "NitroPlayer", code: 404, userInfo: [NSLocalizedDescriptionKey: "Track \(trackId) not found"])
-      }
-      NitroPlayerLogger.log("TrackPlayerCore", "⏭️ playNext(\(trackId))")
-      self.playNextStack.insert(track, at: 0)
-      NitroPlayerLogger.log("TrackPlayerCore", "   ✅ Added '\(track.title)' to playNext stack (position: 1)")
-      if self.player?.currentItem != nil { self.rebuildAVQueueFromCurrentPosition() }
-      self.notifyTemporaryQueueChange()
+  func playNextOnQueue(trackId: String) throws {
+    guard let track = findTrackById(trackId) else {
+      throw NSError(domain: "NitroPlayer", code: 404, userInfo: [NSLocalizedDescriptionKey: "Track \(trackId) not found"])
     }
+    NitroPlayerLogger.log("TrackPlayerCore", "⏭️ playNext(\(trackId))")
+    playNextStack.insert(track, at: 0)
+    if player?.currentItem != nil { rebuildAVQueueFromCurrentPosition() }
+    notifyTemporaryQueueChange()
+  }
+  func playNext(trackId: String) async throws {
+    try await withPlayerQueue { try self.playNextOnQueue(trackId: trackId) }
   }
 
-  func addToUpNext(trackId: String) async throws {
-    try await withPlayerQueue {
-      guard let track = self.findTrackById(trackId) else {
-        throw NSError(domain: "NitroPlayer", code: 404, userInfo: [NSLocalizedDescriptionKey: "Track \(trackId) not found"])
-      }
-      NitroPlayerLogger.log("TrackPlayerCore", "📋 addToUpNext(\(trackId))")
-      self.upNextQueue.append(track)
-      NitroPlayerLogger.log("TrackPlayerCore", "   ✅ Added '\(track.title)' to upNext queue (position: \(self.upNextQueue.count))")
-      if self.player?.currentItem != nil { self.rebuildAVQueueFromCurrentPosition() }
-      self.notifyTemporaryQueueChange()
+  func addToUpNextOnQueue(trackId: String) throws {
+    guard let track = findTrackById(trackId) else {
+      throw NSError(domain: "NitroPlayer", code: 404, userInfo: [NSLocalizedDescriptionKey: "Track \(trackId) not found"])
     }
+    NitroPlayerLogger.log("TrackPlayerCore", "📋 addToUpNext(\(trackId))")
+    upNextQueue.append(track)
+    if player?.currentItem != nil { rebuildAVQueueFromCurrentPosition() }
+    notifyTemporaryQueueChange()
+  }
+  func addToUpNext(trackId: String) async throws {
+    try await withPlayerQueue { try self.addToUpNextOnQueue(trackId: trackId) }
   }
 
+  func removeFromPlayNextOnQueue(trackId: String) -> Bool {
+    guard let idx = playNextStack.firstIndex(where: { $0.id == trackId }) else { return false }
+    playNextStack.remove(at: idx)
+    if player?.currentItem != nil { rebuildAVQueueFromCurrentPosition() }
+    notifyTemporaryQueueChange()
+    return true
+  }
   func removeFromPlayNext(trackId: String) async -> Bool {
-    await withPlayerQueueNoThrow {
-      guard let idx = self.playNextStack.firstIndex(where: { $0.id == trackId }) else { return false }
-      self.playNextStack.remove(at: idx)
-      if self.player?.currentItem != nil { self.rebuildAVQueueFromCurrentPosition() }
-      self.notifyTemporaryQueueChange()
-      return true
-    }
+    await withPlayerQueueNoThrow { self.removeFromPlayNextOnQueue(trackId: trackId) }
   }
 
+  func removeFromUpNextOnQueue(trackId: String) -> Bool {
+    guard let idx = upNextQueue.firstIndex(where: { $0.id == trackId }) else { return false }
+    upNextQueue.remove(at: idx)
+    if player?.currentItem != nil { rebuildAVQueueFromCurrentPosition() }
+    notifyTemporaryQueueChange()
+    return true
+  }
   func removeFromUpNext(trackId: String) async -> Bool {
-    await withPlayerQueueNoThrow {
-      guard let idx = self.upNextQueue.firstIndex(where: { $0.id == trackId }) else { return false }
-      self.upNextQueue.remove(at: idx)
-      if self.player?.currentItem != nil { self.rebuildAVQueueFromCurrentPosition() }
-      self.notifyTemporaryQueueChange()
-      return true
-    }
+    await withPlayerQueueNoThrow { self.removeFromUpNextOnQueue(trackId: trackId) }
   }
 
-  func clearPlayNext() async {
-    await withPlayerQueueNoThrow {
-      self.playNextStack.removeAll()
-      if self.player?.currentItem != nil { self.rebuildAVQueueFromCurrentPosition() }
-      self.notifyTemporaryQueueChange()
-    }
+  func clearPlayNextOnQueue() {
+    playNextStack.removeAll()
+    if player?.currentItem != nil { rebuildAVQueueFromCurrentPosition() }
+    notifyTemporaryQueueChange()
   }
+  func clearPlayNext() async { await withPlayerQueueNoThrow { self.clearPlayNextOnQueue() } }
 
-  func clearUpNext() async {
-    await withPlayerQueueNoThrow {
-      self.upNextQueue.removeAll()
-      if self.player?.currentItem != nil { self.rebuildAVQueueFromCurrentPosition() }
-      self.notifyTemporaryQueueChange()
-    }
+  func clearUpNextOnQueue() {
+    upNextQueue.removeAll()
+    if player?.currentItem != nil { rebuildAVQueueFromCurrentPosition() }
+    notifyTemporaryQueueChange()
+  }
+  func clearUpNext() async { await withPlayerQueueNoThrow { self.clearUpNextOnQueue() } }
+
+  func reorderTemporaryTrackOnQueue(trackId: String, newIndex: Int) -> Bool {
+    var combined = playNextStack + upNextQueue
+    guard let fromIdx = combined.firstIndex(where: { $0.id == trackId }) else { return false }
+    let track = combined.remove(at: fromIdx)
+    let clamped = newIndex.clamped(to: 0...combined.count)
+    combined.insert(track, at: clamped)
+    let pnSize = playNextStack.count
+    playNextStack = Array(combined.prefix(pnSize))
+    upNextQueue = Array(combined.dropFirst(pnSize))
+    if player?.currentItem != nil { rebuildAVQueueFromCurrentPosition() }
+    notifyTemporaryQueueChange()
+    return true
   }
-
   func reorderTemporaryTrack(trackId: String, newIndex: Int) async -> Bool {
-    await withPlayerQueueNoThrow {
-      var combined = self.playNextStack + self.upNextQueue
-      guard let fromIdx = combined.firstIndex(where: { $0.id == trackId }) else { return false }
-      let track = combined.remove(at: fromIdx)
-      let clamped = newIndex.clamped(to: 0...combined.count)
-      combined.insert(track, at: clamped)
-      let pnSize = self.playNextStack.count
-      self.playNextStack = Array(combined.prefix(pnSize))
-      self.upNextQueue = Array(combined.dropFirst(pnSize))
-      if self.player?.currentItem != nil { self.rebuildAVQueueFromCurrentPosition() }
-      self.notifyTemporaryQueueChange()
-      return true
-    }
+    await withPlayerQueueNoThrow { self.reorderTemporaryTrackOnQueue(trackId: trackId, newIndex: newIndex) }
   }
 
   func getPlayNextQueue() async -> [TrackItem] {

package/ios/core/TrackPlayerUrlLoader.swift

@@ -71,7 +71,7 @@ extension TrackPlayerCore {
     for trackId in updatedTrackIds {
       if self.preloadedAssets[trackId] != nil {
         NitroPlayerLogger.log("TrackPlayerCore", "🗑️ Invalidating preloaded asset for track: \(trackId)")
-        self.preloadedAssets.removeValue(forKey: trackId)
+        self.preloadedAssets.removeValue(forKey: trackId)?.cancelLoading()
       }
     }
 
@@ -129,7 +129,7 @@ extension TrackPlayerCore {
         // No AVPlayerItem exists yet — lazy-load mode: URLs were empty when the queue first loaded.
         NitroPlayerLogger.log("TrackPlayerCore",
           "🔄 No current item — full queue rebuild from currentTrackIndex \(self.currentTrackIndex)")
-        player.removeAllItems()
+        self.removeAllItemsCancellingLoads(player)
         var lastItem: AVPlayerItem? = nil
         for (offset, track) in self.currentTracks[max(0, self.currentTrackIndex)...].enumerated() {
           let isPreload = offset < Constants.gaplessPreloadCount
@@ -164,17 +164,41 @@ extension TrackPlayerCore {
     }
   }
 
+  /// Walks the queue structure directly instead of materializing the whole queue —
+  /// this runs on every skip and on the periodic boundary observer, so it must not
+  /// be O(playlist) just to read the next few tracks.
   func getNextTracksInternal(count: Int) -> [TrackItem] {
-    let actualQueue = getActualQueueInternal()
-    guard !actualQueue.isEmpty else { return [] }
+    guard count > 0 else { return [] }
+    var out: [TrackItem] = []
+    out.reserveCapacity(count)
+    let currentId = activeCurrentTrackId
+
+    var skippedPlayNext = currentTemporaryType != .playNext
+    for track in playNextStack {
+      if !skippedPlayNext && track.id == currentId {
+        skippedPlayNext = true
+        continue
+      }
+      out.append(track)
+      if out.count == count { return out }
+    }
 
-    guard let currentTrack = getCurrentTrack(),
-      let currentIndex = actualQueue.firstIndex(where: { $0.id == currentTrack.id })
-    else { return [] }
+    var skippedUpNext = currentTemporaryType != .upNext
+    for track in upNextQueue {
+      if !skippedUpNext && track.id == currentId {
+        skippedUpNext = true
+        continue
+      }
+      out.append(track)
+      if out.count == count { return out }
+    }
 
-    let startIndex = currentIndex + 1
-    let endIndex = min(startIndex + count, actualQueue.count)
-    return startIndex < actualQueue.count ? Array(actualQueue[startIndex..<endIndex]) : []
+    var index = currentTrackIndex + 1
+    while index < currentTracks.count && out.count < count {
+      out.append(currentTracks[index])
+      index += 1
+    }
+    return out
   }
 
   func checkUpcomingTracksForUrls(lookahead: Int = 5) {