@5stones/react-native-audio-browser 0.1.5 → 0.2.0

package/android/src/main/java/com/audiobrowser/AudioBrowser.kt

@@ -65,6 +65,7 @@ import com.margelo.nitro.audiobrowser.PlayingState
 import com.margelo.nitro.audiobrowser.Progress
 import com.margelo.nitro.audiobrowser.RemoteJumpBackwardEvent
 import com.margelo.nitro.audiobrowser.RemoteJumpForwardEvent
+import com.margelo.nitro.audiobrowser.RemoteLoadEvent
 import com.margelo.nitro.audiobrowser.RemotePlayIdEvent
 import com.margelo.nitro.audiobrowser.RemotePlaySearchEvent
 import com.margelo.nitro.audiobrowser.RemoteSeekEvent
@@ -149,6 +150,7 @@ class AudioBrowser : HybridAudioBrowserSpec(), ServiceConnection {
   override var onRemoteJumpBackward: (RemoteJumpBackwardEvent) -> Unit = {}
   override var onRemoteJumpForward: (RemoteJumpForwardEvent) -> Unit = {}
   override var onRemoteLike: () -> Unit = {}
+  override var onRemoteLoad: (RemoteLoadEvent) -> Unit = {}
   override var onRemoteNext: () -> Unit = {}
   override var onRemotePause: () -> Unit = {}
   override var onChapterMetadata: (chapters: Array<ChapterMetadata>) -> Unit = {}
@@ -190,6 +192,7 @@ class AudioBrowser : HybridAudioBrowserSpec(), ServiceConnection {
   override var handleRemoteJumpBackward: ((RemoteJumpBackwardEvent) -> Unit)? = null
   override var handleRemoteJumpForward: ((RemoteJumpForwardEvent) -> Unit)? = null
   override var handleRemoteLike: (() -> Unit)? = null
+  override var handleRemoteLoad: ((RemoteLoadEvent) -> Unit)? = null
   override var handleRemoteNext: (() -> Unit)? = null
   override var handleRemotePause: (() -> Unit)? = null
   override var handleRemotePlay: (() -> Unit)? = null
@@ -504,6 +507,24 @@ class AudioBrowser : HybridAudioBrowserSpec(), ServiceConnection {
       }
   }
 
+  /**
+   * Centralizes handleRemoteLoad interception logic.
+   * If handleRemoteLoad is set, calls it (intercepted). Otherwise runs defaultBehavior.
+   * Always fires onRemoteLoad afterward.
+   *
+   * @return true if the handler intercepted, false if defaultBehavior ran
+   */
+  private fun handleLoad(
+    track: Track, queue: Array<Track>, startIndex: Double,
+    defaultBehavior: () -> Unit,
+  ): Boolean {
+    val event = RemoteLoadEvent(track, queue, startIndex)
+    val handled = handleRemoteLoad?.let { it.invoke(event); true } ?: false
+    if (!handled) defaultBehavior()
+    onRemoteLoad(event)
+    return handled
+  }
+
   override fun navigateTrack(track: Track) {
     clearNavigationError()
 
@@ -527,8 +548,10 @@ class AudioBrowser : HybridAudioBrowserSpec(), ServiceConnection {
                 val index = player.tracks.indexOfFirst { it.src == trackId }
                 if (index >= 0) {
                   Timber.d("Queue already from $parentPath, skipping to index $index")
-                  player.skipTo(index)
-                  player.play()
+                  handleLoad(track, player.tracks, index.toDouble()) {
+                    player.skipTo(index)
+                    player.play()
+                  }
                   return@launch
                 }
               }
@@ -541,15 +564,17 @@ class AudioBrowser : HybridAudioBrowserSpec(), ServiceConnection {
                 Timber.d(
                   "Loading expanded queue: ${tracks.size} tracks, starting at index $startIndex"
                 )
-
-                // Replace queue and seek to selected track
-                // Use internal player methods directly to avoid blocking on main thread
-                player.setQueue(tracks, startIndex, sourcePath = parentPath)
-                player.play()
+                handleLoad(track, tracks, startIndex.toDouble()) {
+                  // Replace queue and seek to selected track
+                  // Use internal player methods directly to avoid blocking on main thread
+                  player.setQueue(tracks, startIndex, sourcePath = parentPath)
+                  player.play()
+                }
+                return@launch
               } else {
                 // Fallback: just load the single track
                 Timber.w("Queue expansion failed, loading single track")
-                player.load(track)
+                handleLoad(track, arrayOf(track), 0.0) { player.load(track) }
               }
             }
             // Navigate to browsable track to show browsing UI
@@ -560,7 +585,7 @@ class AudioBrowser : HybridAudioBrowserSpec(), ServiceConnection {
             // If track is playable (has src), load it into player
             track.src != null -> {
               Timber.d("Loading playable track into player: ${track.title}")
-              player.load(track)
+              handleLoad(track, arrayOf(track), 0.0) { player.load(track) }
             }
             else -> {
               throw IllegalArgumentException("Track must have either an 'url' or an 'src' property")

package/android/src/main/java/com/audiobrowser/player/MediaSessionCallback.kt

@@ -12,10 +12,13 @@ import androidx.media3.session.MediaConstants
 import androidx.media3.session.SessionCommand
 import androidx.media3.session.SessionError
 import androidx.media3.session.SessionResult
+import com.audiobrowser.AudioBrowser
 import com.audiobrowser.util.BrowserPathHelper
 import com.audiobrowser.util.RatingFactory
 import com.audiobrowser.util.ResolvedTrackFactory
 import com.audiobrowser.util.TrackFactory
+import com.margelo.nitro.audiobrowser.RemoteLoadEvent
+import com.margelo.nitro.audiobrowser.Track
 import com.google.common.collect.ImmutableList
 import com.google.common.util.concurrent.Futures
 import com.google.common.util.concurrent.ListenableFuture
@@ -451,6 +454,24 @@ class MediaSessionCallback(private val player: Player) :
     }
   }
 
+  /**
+   * Centralizes handleRemoteLoad interception logic for onSetMediaItems.
+   * If handleRemoteLoad is set, calls it and returns interceptedResult().
+   * Otherwise runs defaultBehavior(). Always fires onRemoteLoad afterward.
+   */
+  private suspend fun handleLoad(
+    audioBrowser: AudioBrowser,
+    track: Track, queue: Array<Track>, startIndex: Double,
+    interceptedResult: () -> MediaSession.MediaItemsWithStartPosition,
+    defaultBehavior: suspend () -> MediaSession.MediaItemsWithStartPosition,
+  ): MediaSession.MediaItemsWithStartPosition {
+    val event = RemoteLoadEvent(track, queue, startIndex)
+    val handler = audioBrowser.handleRemoteLoad
+    val result = if (handler != null) { handler(event); interceptedResult() } else defaultBehavior()
+    audioBrowser.onRemoteLoad(event)
+    return result
+  }
+
   override fun onSetMediaItems(
     mediaSession: MediaSession,
     controller: MediaSession.ControllerInfo,
@@ -463,6 +484,19 @@ class MediaSessionCallback(private val player: Player) :
     )
 
     return scope.future {
+      val audioBrowser = player.awaitBrowser()
+
+      // Helper: returns the current player state unchanged so Media3 doesn't modify playback
+      fun currentPlayerState(): MediaSession.MediaItemsWithStartPosition {
+        val currentItems = player.tracks.map { TrackFactory.toMedia3(it) }
+        val currentIndex = player.currentIndex ?: 0
+        return MediaSession.MediaItemsWithStartPosition(
+          currentItems,
+          currentIndex,
+          startPositionMs,
+        )
+      }
+
       // Check if this is a single contextual URL that matches the current queue source
       if (mediaItems.size == 1) {
         val mediaId = mediaItems[0].mediaId
@@ -475,33 +509,39 @@ class MediaSessionCallback(private val player: Player) :
             val index = player.tracks.indexOfFirst { it.src == trackId }
             if (index >= 0) {
               Timber.d("Queue already from $parentPath, skipping to index $index")
-              // Return the existing queue items with the new start index
-              val existingItems = player.tracks.map { TrackFactory.toMedia3(it) }
-              return@future MediaSession.MediaItemsWithStartPosition(
-                existingItems,
-                index,
-                startPositionMs,
-              )
+              val track = player.tracks[index]
+              return@future handleLoad(audioBrowser, track, player.tracks, index.toDouble(), ::currentPlayerState) {
+                // Return the existing queue items with the new start index
+                val existingItems = player.tracks.map { TrackFactory.toMedia3(it) }
+                MediaSession.MediaItemsWithStartPosition(
+                  existingItems,
+                  index,
+                  startPositionMs,
+                )
+              }
             }
           }
         }
       }
 
-      // Wait for browser to be registered if it's not available yet
-      val browserManager = player.awaitBrowser().browserManager
+      val browserManager = audioBrowser.browserManager
       val result =
         browserManager.resolveMediaItemsForPlayback(mediaItems, startIndex, startPositionMs)
 
-      // If this was a contextual URL expansion, track the source path
-      if (mediaItems.size == 1) {
-        val mediaId = mediaItems[0].mediaId
-        if (BrowserPathHelper.isContextual(mediaId)) {
-          val parentPath = BrowserPathHelper.stripTrackId(mediaId)
-          withContext(Dispatchers.Main) { player.queueSourcePath = parentPath }
+      val tracks = result.mediaItems.map { TrackFactory.fromMedia3(it) }.toTypedArray()
+      val selectedTrack = tracks.getOrElse(result.startIndex) { tracks.first() }
+
+      handleLoad(audioBrowser, selectedTrack, tracks, result.startIndex.toDouble(), ::currentPlayerState) {
+        // If this was a contextual URL expansion, track the source path (only for default behavior)
+        if (mediaItems.size == 1) {
+          val mediaId = mediaItems[0].mediaId
+          if (BrowserPathHelper.isContextual(mediaId)) {
+            val parentPath = BrowserPathHelper.stripTrackId(mediaId)
+            withContext(Dispatchers.Main) { player.queueSourcePath = parentPath }
+          }
         }
+        result
       }
-
-      result
     }
   }
 

package/android/src/main/java/com/audiobrowser/player/TransformingDataSource.kt

@@ -17,10 +17,14 @@ import timber.log.Timber
  * needs to fetch data. By deferring URL transformation (which may invoke a JS callback
  * via `runBlocking`) to [open], we avoid blocking the main thread and prevent deadlocks
  * when the JS thread is occupied by synchronous Nitro calls (e.g., `seekTo`).
+ *
+ * The transform is resolved once per track on the first [open] call (the manifest/media
+ * URL). The resulting headers and user-agent are cached on the [Factory] and reused for
+ * subsequent requests (segments, encryption keys) without calling the JS transform again.
  */
 class TransformingDataSource(
   private val upstream: DataSource,
-  private val getRequestConfig: (originalUrl: String) -> MediaRequestConfig?,
+  private val factory: Factory,
 ) : DataSource {
 
   companion object {
@@ -32,11 +36,19 @@ class TransformingDataSource(
   override fun open(dataSpec: DataSpec): Long {
     val originalUrl = dataSpec.uri.toString()
 
-    // Resolve the transform on the IO thread — safe to block here since
-    // the main thread and JS thread remain free for other work.
-    val (finalUrl, headers, userAgent) = resolveRequestConfig(originalUrl)
-
-    Timber.d("TransformingDataSource: $originalUrl -> $finalUrl")
+    // Check if the Factory already has a cached transform result.
+    // The first DataSource to open() resolves the transform and caches it.
+    // All subsequent opens (segments, keys, replays) reuse the cached
+    // headers/user-agent but keep their original URLs.
+    val cached = factory.cachedTransform
+    val (finalUrl, headers, userAgent) = if (cached == null) {
+      val resolved = resolveRequestConfig(originalUrl)
+      factory.cachedTransform = resolved
+      Timber.d("TransformingDataSource: resolved $originalUrl -> ${resolved.first}")
+      resolved
+    } else {
+      Triple(originalUrl, cached.second, cached.third)
+    }
 
     // Build merged headers including user-agent override
     val mergedHeaders = buildMap {
@@ -47,7 +59,7 @@ class TransformingDataSource(
       }
     }
 
-    // Build a new DataSpec with the transformed URL and merged headers
+    // Build a new DataSpec with the (possibly transformed) URL and merged headers
     val transformedSpec =
       dataSpec.buildUpon().setUri(finalUrl.toUri()).setHttpRequestHeaders(mergedHeaders).build()
 
@@ -82,7 +94,7 @@ class TransformingDataSource(
     originalUrl: String
   ): Triple<String, Map<String, String>, String> {
     return try {
-      val requestConfig = getRequestConfig(originalUrl)
+      val requestConfig = factory.getRequestConfig(originalUrl)
       if (requestConfig != null) {
         val path = requestConfig.path ?: ""
         val baseUrl = requestConfig.baseUrl
@@ -91,7 +103,7 @@ class TransformingDataSource(
         val finalUrl =
           if (requestConfig.query?.isNotEmpty() == true) {
             val uri = Uri.parse(url).buildUpon()
-            requestConfig.query!!.forEach { (key, value) -> uri.appendQueryParameter(key, value) }
+            requestConfig.query?.forEach { (key, value) -> uri.appendQueryParameter(key, value) }
             uri.build().toString()
           } else {
             url
@@ -113,12 +125,22 @@ class TransformingDataSource(
   /** Factory that creates [TransformingDataSource] instances wrapping an upstream factory. */
   class Factory(
     private val upstreamFactory: DataSource.Factory,
-    private val getRequestConfig: (originalUrl: String) -> MediaRequestConfig?,
+    internal val getRequestConfig: (originalUrl: String) -> MediaRequestConfig?,
   ) : DataSource.Factory {
+
+    /**
+     * Cached transform result (url, headers, userAgent) from the first open() call.
+     * Shared across all DataSource instances created by this factory.
+     * A new Factory is created per [MediaFactory.createMediaSource] call (per track),
+     * so the cache naturally resets on track transitions.
+     */
+    @Volatile
+    internal var cachedTransform: Triple<String, Map<String, String>, String>? = null
+
     override fun createDataSource(): DataSource {
       return TransformingDataSource(
         upstream = upstreamFactory.createDataSource(),
-        getRequestConfig = getRequestConfig,
+        factory = this,
       )
     }
   }

package/ios/Browser/BrowserManager.swift

@@ -744,26 +744,11 @@ final class BrowserManager: @unchecked Sendable {
 
         logger.debug("resolveMediaUrl: calling transform callback...")
         // MediaRequestConfig.transform takes (request, routeParams) - pass nil for routeParams
-        // Call the JS transform outside the task group to avoid sending-parameter
-        // data-race warnings (transform and baseRequest aren't Sendable).
         let outerPromise = transform(baseRequest, nil)
+        logger.debug("resolveMediaUrl: awaiting outer promise...")
         let innerPromise = try await outerPromise.await()
         logger.debug("resolveMediaUrl: awaiting inner promise...")
-        let transformedConfig = try await withThrowingTaskGroup(of: RequestConfig.self) { group in
-          group.addTask { [innerPromise] in
-            return try await innerPromise.await()
-          }
-          group.addTask {
-            // Safety-net timeout: if the JS transform Promise doesn't resolve
-            // within 10s, bail out. This guards against Nitro bridge hangs when
-            // concurrent callbacks race.
-            try await Task.sleep(nanoseconds: 10_000_000_000)
-            throw CancellationError()
-          }
-          let result = try await group.next()!
-          group.cancelAll()
-          return result
-        }
+        let transformedConfig = try await innerPromise.await()
         logger.debug("resolveMediaUrl: transform complete")
 
         // Extract values immediately to Swift native types to avoid

package/ios/CarPlay/CarPlayController.swift

@@ -438,6 +438,55 @@ public final class RNABCarPlayController: NSObject {
 
   // MARK: - Selection Handling
 
+  /// Centralizes handleRemoteLoad interception for synchronous CarPlay selection paths.
+  /// If handleRemoteLoad is set, calls it (intercepted). Otherwise runs defaultBehavior.
+  /// Always fires onRemoteLoad, showNowPlaying, and completion afterward.
+  @discardableResult
+  private func handleLoad(
+    track: Track, queue: [Track], startIndex: Double,
+    audioBrowser: HybridAudioBrowser,
+    completion: @escaping () -> Void,
+    defaultBehavior: () -> Void
+  ) -> Bool {
+    let event = RemoteLoadEvent(track: track, queue: queue, startIndex: startIndex)
+    let handled: Bool
+    if let handler = audioBrowser.handleRemoteLoad {
+      handler(event)
+      handled = true
+    } else {
+      defaultBehavior()
+      handled = false
+    }
+    audioBrowser.onRemoteLoad(event)
+    showNowPlaying()
+    completion()
+    return handled
+  }
+
+  /// Centralizes handleRemoteLoad interception for async CarPlay selection paths (queue expansion).
+  /// If handleRemoteLoad is set, calls it (intercepted). Otherwise runs defaultBehavior.
+  /// Always fires onRemoteLoad, showNowPlaying, and completion afterward.
+  @discardableResult
+  private func handleLoadAsync(
+    track: Track, queue: [Track], startIndex: Double,
+    audioBrowser: HybridAudioBrowser,
+    completion: @escaping () -> Void,
+    defaultBehavior: () async -> Void
+  ) async -> Bool {
+    let event = RemoteLoadEvent(track: track, queue: queue, startIndex: startIndex)
+    let handled: Bool
+    if let handler = audioBrowser.handleRemoteLoad {
+      handler(event)
+      handled = true
+    } else {
+      await defaultBehavior()
+      handled = false
+    }
+    audioBrowser.onRemoteLoad(event)
+    await MainActor.run { self.showNowPlaying(); completion() }
+    return handled
+  }
+
   private func handleItemSelection(track: Track, completion: @escaping () -> Void) {
     logger.info("Selected track: \(track.title)")
 
@@ -465,10 +514,10 @@ public final class RNABCarPlayController: NSObject {
          parentPath == player?.queueSourcePath,
          let index = player?.tracks.firstIndex(where: { $0.src == trackId })
       {
-        logger.debug("Queue already from \(parentPath), skipping to index \(index)")
-        try? player?.skipTo(index, playWhenReady: true)
-        showNowPlaying()
-        completion()
+        let queue = player?.tracks ?? []
+        handleLoad(track: track, queue: queue, startIndex: Double(index), audioBrowser: audioBrowser, completion: completion) {
+          try? player?.skipTo(index, playWhenReady: true)
+        }
         return
       }
 
@@ -477,42 +526,41 @@ public final class RNABCarPlayController: NSObject {
           // Expand the queue from the contextual URL
           if let expanded = try await audioBrowser.browserManager.expandQueueFromContextualUrl(url) {
             let (tracks, startIndex) = expanded
-
-            await MainActor.run {
-              // Replace queue and start at the selected track
-              audioBrowser.getPlayer()?.setQueue(tracks, initialIndex: startIndex, playWhenReady: true, sourcePath: parentPath)
-
-              // Show now playing template
-              self.showNowPlaying()
-              completion()
+            await handleLoadAsync(track: track, queue: tracks, startIndex: Double(startIndex), audioBrowser: audioBrowser, completion: completion) {
+              await MainActor.run {
+                // Replace queue and start at the selected track
+                audioBrowser.getPlayer()?.setQueue(tracks, initialIndex: startIndex, playWhenReady: true, sourcePath: parentPath)
+              }
             }
           } else {
             // Fallback: just load the single track
-            await MainActor.run {
-              try? audioBrowser.load(track: track)
-              try? audioBrowser.play()
-              self.showNowPlaying()
-              completion()
+            await handleLoadAsync(track: track, queue: [track], startIndex: 0, audioBrowser: audioBrowser, completion: completion) {
+              await MainActor.run {
+                try? audioBrowser.load(track: track)
+                try? audioBrowser.play()
+              }
             }
           }
         } catch {
           logger.error("Error expanding queue: \(error.localizedDescription)")
-          await MainActor.run {
-            try? audioBrowser.load(track: track)
-            try? audioBrowser.play()
-            self.showNowPlaying()
-            completion()
+          await handleLoadAsync(track: track, queue: [track], startIndex: 0, audioBrowser: audioBrowser, completion: completion) {
+            await MainActor.run {
+              try? audioBrowser.load(track: track)
+              try? audioBrowser.play()
+            }
           }
         }
       }
     }
     // If track has src, it's playable - load it
     else if track.src != nil {
-      Task { @MainActor in
-        try? audioBrowser.load(track: track)
-        try? audioBrowser.play()
-        showNowPlaying()
-        completion()
+      Task {
+        await handleLoadAsync(track: track, queue: [track], startIndex: 0, audioBrowser: audioBrowser, completion: completion) {
+          await MainActor.run {
+            try? audioBrowser.load(track: track)
+            try? audioBrowser.play()
+          }
+        }
       }
     }
     // If track has url, it's browsable - navigate to it

package/ios/HybridAudioBrowser.swift

@@ -175,6 +175,7 @@ public class HybridAudioBrowser: HybridAudioBrowserSpec, @unchecked Sendable {
   public var onRemoteJumpBackward: (RemoteJumpBackwardEvent) -> Void = { _ in }
   public var onRemoteJumpForward: (RemoteJumpForwardEvent) -> Void = { _ in }
   public var onRemoteLike: () -> Void = {}
+  public var onRemoteLoad: (RemoteLoadEvent) -> Void = { _ in }
   public var onRemoteNext: () -> Void = {}
   public var onRemotePause: () -> Void = {}
   public var onRemotePlay: () -> Void = {}
@@ -193,6 +194,7 @@ public class HybridAudioBrowser: HybridAudioBrowserSpec, @unchecked Sendable {
   public var handleRemoteJumpBackward: ((RemoteJumpBackwardEvent) -> Void)?
   public var handleRemoteJumpForward: ((RemoteJumpForwardEvent) -> Void)?
   public var handleRemoteLike: (() -> Void)?
+  public var handleRemoteLoad: ((RemoteLoadEvent) -> Void)?
   public var handleRemoteNext: (() -> Void)?
   public var handleRemotePause: (() -> Void)?
   public var handleRemotePlay: (() -> Void)?
@@ -373,6 +375,24 @@ public class HybridAudioBrowser: HybridAudioBrowserSpec, @unchecked Sendable {
     }
   }
 
+  /// Centralizes handleRemoteLoad interception logic.
+  /// If handleRemoteLoad is set, calls it (intercepted). Otherwise runs defaultBehavior.
+  /// Always fires onRemoteLoad afterward.
+  ///
+  /// - Returns: true if the handler intercepted, false if defaultBehavior ran
+  @discardableResult
+  private func handleLoad(track: Track, queue: [Track], startIndex: Double, defaultBehavior: () -> Void) -> Bool {
+    let event = RemoteLoadEvent(track: track, queue: queue, startIndex: startIndex)
+    if let handler = handleRemoteLoad {
+      handler(event)
+      onRemoteLoad(event)
+      return true
+    }
+    defaultBehavior()
+    onRemoteLoad(event)
+    return false
+  }
+
   public func navigateTrack(track: Track) throws {
     let url = track.url
 
@@ -391,8 +411,11 @@ public class HybridAudioBrowser: HybridAudioBrowserSpec, @unchecked Sendable {
       }
       if let index = existingIndex {
         logger.debug("Queue already from \(parentPath), skipping to index \(index)")
-        onMainActor {
-          try? player?.skipTo(index, playWhenReady: true)
+        let queue: [Track] = onMainActor { player?.tracks ?? [] }
+        handleLoad(track: track, queue: queue, startIndex: Double(index)) {
+          onMainActor {
+            try? player?.skipTo(index, playWhenReady: true)
+          }
         }
         return
       }
@@ -402,30 +425,37 @@ public class HybridAudioBrowser: HybridAudioBrowserSpec, @unchecked Sendable {
           // Expand the queue from the contextual URL
           if let expanded = try await browserManager.expandQueueFromContextualUrl(url) {
             let (tracks, startIndex) = expanded
-
-            // Replace queue and start at the selected track (auto-play)
-            await MainActor.run {
-              player?.setQueue(tracks, initialIndex: startIndex, playWhenReady: true, sourcePath: parentPath)
+            handleLoad(track: track, queue: tracks, startIndex: Double(startIndex)) {
+              // Replace queue and start at the selected track (auto-play)
+              onMainActor {
+                player?.setQueue(tracks, initialIndex: startIndex, playWhenReady: true, sourcePath: parentPath)
+              }
             }
           } else {
             // Fallback: just load the single track (auto-play)
-            await MainActor.run {
-              player?.load(track, playWhenReady: true)
+            handleLoad(track: track, queue: [track], startIndex: 0) {
+              onMainActor {
+                player?.load(track, playWhenReady: true)
+              }
             }
           }
         } catch {
           logger.error("Error expanding queue: \(error.localizedDescription)")
           // Fallback to single track (auto-play) - playback errors reported via TrackPlayer callbacks
-          await MainActor.run {
-            player?.load(track, playWhenReady: true)
+          handleLoad(track: track, queue: [track], startIndex: 0) {
+            onMainActor {
+              player?.load(track, playWhenReady: true)
+            }
           }
         }
       }
     }
     // If track has src, it's playable - load and auto-play
     else if track.src != nil {
-      onMainActor {
-        player?.load(track, playWhenReady: true)
+      handleLoad(track: track, queue: [track], startIndex: 0) {
+        onMainActor {
+          player?.load(track, playWhenReady: true)
+        }
       }
     }
     // If track has url, it's browsable - navigate to it