react-native-audio-browser 0.2.0-next.27 → 0.2.0-next.29

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

@@ -19,18 +19,22 @@ internal class ServiceBinding(private val context: Context) {
   var isBound: Boolean = false
     private set
 
+  @Volatile private var bindSucceeded: Boolean = false
+
   /**
-   * Binds if not already bound, and returns whether a binding is held afterwards. A second call
-   * while bound is a no-op: Android would otherwise count the extra bind and expect a matching
+   * Binds if not already bound, and returns whether the service will connect: what
+   * [Context.bindService] returned for the binding held. A second call while bound is a no-op that
+   * returns the same answer: Android would otherwise count the extra bind and expect a matching
    * unbind.
    */
   fun bind(intent: Intent, connection: ServiceConnection): Boolean {
-    if (isBound) return true
+    if (isBound) return bindSucceeded
     // Marked bound whatever the result: Android registers the connection before it asks the
     // ActivityManager, so a false return still leaves one to release — "regardless of the return
     // value, you should later call unbindService()".
     isBound = true
-    return context.bindService(intent, connection, Context.BIND_AUTO_CREATE)
+    bindSucceeded = context.bindService(intent, connection, Context.BIND_AUTO_CREATE)
+    return bindSucceeded
   }
 
   /**

package/android/src/main/java/com/audiobrowser/browser/BrowserUrlResolution.kt

@@ -14,10 +14,9 @@ import timber.log.Timber
 
 /**
  * Outbound URL resolution for media and artwork — the Android analog of iOS
- * `BrowserManager+URLResolution.swift`. Owns how a Track's `src` / `artwork` becomes a fetchable
- * request: request layer (shared, incl. its transform) → kind config (media / artwork /
- * nowPlayingArtwork) → per-Track Resolve, with transform-wins semantics centralised in
- * [RequestConfigBuilder].
+ * `RequestPipeline.swift`. Owns how a Track's `src` / `artwork` becomes a fetchable request:
+ * request layer (shared, incl. its transform) → kind config (media / artwork / nowPlayingArtwork) →
+ * per-Track Resolve, with transform-wins semantics centralised in [RequestConfigBuilder].
  */
 
 /**

package/android/src/test/java/com/audiobrowser/ServiceBindingTest.kt

@@ -74,6 +74,19 @@ class ServiceBindingTest {
     assertEquals(1, shadowOf(app).unboundServiceConnections.size)
   }
 
+  /**
+   * setupPlayer binds after the auto-bind at construction already has. If that first bind failed,
+   * the service never connects, so setup must hear false and reject rather than wait for it.
+   */
+  @Test
+  fun bindingAgainAfterAFailedBindReportsTheFailure() {
+    val binding = ServiceBinding(app)
+    shadowOf(app).declareActionUnbindable("unbindable")
+
+    assertFalse(binding.bind(Intent("unbindable"), connection))
+    assertFalse(binding.bind(Intent("unbindable"), connection))
+  }
+
   @Test
   fun unbindIsIdempotent() {
     val binding = ServiceBinding(app)

package/android/src/test/java/com/audiobrowser/browser/BrowserUrlResolutionTest.kt

@@ -15,8 +15,8 @@ import org.junit.Test
 
 /**
  * Tests browser/BrowserUrlResolution.kt — media/artwork URL resolution owned by BrowserManager (the
- * Kotlin analog of iOS BrowserManager+URLResolution.swift). Static configs only (Nitro Promises are
- * JNI-backed; see file-top note in BrowserManagerLayerResolutionTest).
+ * Kotlin analog of iOS RequestPipeline.swift). Static configs only (Nitro Promises are JNI-backed;
+ * see file-top note in BrowserManagerLayerResolutionTest).
  */
 class BrowserUrlResolutionTest {
 

package/ios/AVPlayerEngine.swift

@@ -0,0 +1,334 @@
+@preconcurrency import AVFoundation
+import Foundation
+import MediaPlayer
+import NitroModules
+import os.log
+
+/// The `PlayerEngine` over AVFoundation: the AVPlayer and its observers, media loading, the
+/// now-playing session and the remote commands. Carries out what the `Player` decides; holds
+/// no playback policy.
+@MainActor
+final class AVPlayerEngine: PlayerEngine {
+  let logger = Logger(subsystem: "com.audiobrowser", category: "AVPlayerEngine")
+
+  var onEvent: (@MainActor (EngineEvent) -> Void)?
+  private weak var callbacks: AVPlayerEngineCallbacks?
+
+  let nowPlayingInfoController: NowPlayingInfoController
+  let nowPlayingUpdater: NowPlayingUpdater
+  let remoteCommandController: RemoteCommandController
+  private let mediaLoader = MediaLoader()
+  private let silentAudioPrimer = SilentAudioPrimer()
+
+  private var avPlayer = AVPlayer()
+  private var playerObserver: PlayerObserver?
+  private var itemObserver: ItemObserver?
+  private var rate: Float = 1
+  private var skipAvailability = (canNext: false, canPrevious: false)
+
+  var remoteCommands: [RemoteCommand] = [] {
+    didSet { remoteCommandController.enable(commands: remoteCommands) }
+  }
+
+  /// - Parameter resolver: Resolves media URLs and now-playing artwork.
+  init(
+    callbacks: AVPlayerEngineCallbacks?,
+    resolver: MediaResolving?,
+    nowPlayingInfoController: NowPlayingInfoController = NowPlayingInfoController(),
+  ) {
+    self.callbacks = callbacks
+    self.nowPlayingInfoController = nowPlayingInfoController
+    nowPlayingUpdater = NowPlayingUpdater(nowPlayingInfoController: nowPlayingInfoController)
+    remoteCommandController = RemoteCommandController(callbacks: callbacks)
+
+    mediaLoader.onEvent = { [weak self] in self?.mediaLoaderDidEmit($0) }
+    mediaLoader.mediaUrlResolver = { [weak resolver] src, track in
+      await resolver?.resolveMediaUrl(src, track: track) ?? MediaResolvedUrl(url: src, headers: nil, userAgent: nil)
+    }
+    nowPlayingUpdater.artworkUrlResolver = { [weak resolver] track, imageContext in
+      await resolver?.resolveNowPlayingArtwork(track: track, imageContext: imageContext)
+    }
+    nowPlayingUpdater.onChanged = { [weak self] in self?.callbacks?.playerDidChangeNowPlaying($0) }
+    remoteCommandController.skipAvailability = { [weak self] in
+      self?.skipAvailability ?? (false, false)
+    }
+    setUpAVPlayer()
+  }
+
+  /// Releases the player for good: the now-playing session, the observers and the remote
+  /// commands go with it.
+  func destroy() {
+    remoteCommandController.disableAll()
+    nowPlayingInfoController.unlinkPlayer()
+    playerObserver?.invalidate()
+    playerObserver = nil
+    stopObservingItem()
+  }
+
+  /// Re-requests the now-playing election, which the system may have declined at link time while
+  /// the audio session was still inactive.
+  func reactivateNowPlayingSession() {
+    nowPlayingInfoController.reactivateSessionIfNeeded()
+  }
+
+  // MARK: - Buffering
+
+  var bufferDuration: Double = 0 {
+    didSet {
+      avPlayer.automaticallyWaitsToMinimizeStalling = bufferDuration == 0
+      mediaLoader.bufferDuration = bufferDuration
+    }
+  }
+
+  // MARK: - The Current Item
+
+  var hasItem: Bool {
+    avPlayer.currentItem != nil
+  }
+
+  var hasLoadedAsset: Bool {
+    mediaLoader.asset != nil
+  }
+
+  var currentTime: Double {
+    let seconds = avPlayer.currentTime().seconds
+    return seconds.isNaN ? 0 : seconds
+  }
+
+  /// The current item's duration, or 0 when it has none (a live stream). Not
+  /// `item.asset.duration`: deprecated since iOS 16, and it blocks the main actor fetching a
+  /// remote asset's duration.
+  var duration: Double {
+    guard let item = avPlayer.currentItem else { return 0 }
+    if !item.duration.seconds.isNaN {
+      return item.duration.seconds
+    }
+    if let seekable = item.seekableTimeRanges.last?.timeRangeValue.duration.seconds, !seekable.isNaN {
+      return seekable
+    }
+    return 0
+  }
+
+  var bufferedPosition: Double {
+    avPlayer.currentItem?.loadedTimeRanges.last?.timeRangeValue.end.seconds ?? 0
+  }
+
+  var resumePosition: Double? {
+    guard let item = avPlayer.currentItem, !item.duration.isIndefinite else { return nil }
+    return item.currentTime().seconds
+  }
+
+  var liveEdge: Double? {
+    guard let range = avPlayer.currentItem?.seekableTimeRanges.last?.timeRangeValue,
+          range.duration.seconds > 0
+    else { return nil }
+    return range.end.seconds
+  }
+
+  var isPlaybackLikelyToKeepUp: Bool {
+    avPlayer.currentItem?.isPlaybackLikelyToKeepUp ?? false
+  }
+
+  var isAirPlayRoute: Bool {
+    AVAudioSession.sharedInstance().currentRoute.outputs.contains { $0.portType == .airPlay }
+  }
+
+  var volume: Float {
+    get { avPlayer.volume }
+    set { avPlayer.volume = newValue }
+  }
+
+  // MARK: - Loading
+
+  func resolveAndLoad(src: String, track: Track) {
+    mediaLoader.resolveAndLoad(src: src, track: track)
+  }
+
+  func loadResolved() {
+    mediaLoader.loadAsset()
+  }
+
+  func cancelLoading() {
+    mediaLoader.cancelAll()
+  }
+
+  func dropAsset() {
+    stopObservingItem()
+    mediaLoader.clearAsset()
+  }
+
+  func clearItem() {
+    dropAsset()
+    avPlayer.replaceCurrentItem(with: nil)
+  }
+
+  func stopObservingItem() {
+    itemObserver?.invalidate()
+    itemObserver = nil
+  }
+
+  func recreate() {
+    playerObserver?.invalidate()
+    nowPlayingInfoController.unlinkPlayer()
+    avPlayer = AVPlayer()
+    setUpAVPlayer()
+  }
+
+  private func setUpAVPlayer() {
+    avPlayer.allowsExternalPlayback = false
+    avPlayer.automaticallyWaitsToMinimizeStalling = bufferDuration == 0
+    playerObserver = PlayerObserver(player: avPlayer) { [weak self] in self?.playerDidEmit($0) }
+    remoteCommandController.switchCommandCenter(nowPlayingInfoController.linkPlayer(avPlayer))
+    avPlayer.defaultRate = rate
+  }
+
+  // MARK: - Transport
+
+  func play() {
+    avPlayer.play()
+    if rate != 1 { avPlayer.rate = rate }
+  }
+
+  func pause() {
+    avPlayer.pause()
+  }
+
+  func setRate(_ rate: Float, playing: Bool) {
+    self.rate = rate
+    avPlayer.defaultRate = rate
+    if playing { avPlayer.rate = rate }
+  }
+
+  func seek(to seconds: Double, completion: @escaping @MainActor (Bool) -> Void) {
+    avPlayer.seek(
+      to: CMTime(seconds: seconds, preferredTimescale: 1000), toleranceBefore: .zero, toleranceAfter: .zero,
+    ) { finished in
+      Task { @MainActor in completion(finished) }
+    }
+  }
+
+  func applyTimePitchAlgorithm() {
+    avPlayer.currentItem?.audioTimePitchAlgorithm = .timeDomain
+  }
+
+  // MARK: - Now Playing and Remote Commands
+
+  func primeNowPlaying() {
+    silentAudioPrimer.prime()
+  }
+
+  func loadNowPlayingMetadata(for track: Track) {
+    nowPlayingUpdater.loadMetaValues(for: track)
+  }
+
+  func clearNowPlaying() {
+    nowPlayingUpdater.clearNowPlaying()
+  }
+
+  func updateRemoteRepeatMode(_ mode: RepeatMode) {
+    remoteCommandController.updateRepeatMode(mode)
+  }
+
+  func updateRemoteShuffleMode(_ enabled: Bool) {
+    remoteCommandController.updateShuffleMode(enabled)
+  }
+
+  func updateSkipAvailability(canNext: Bool, canPrevious: Bool) {
+    skipAvailability = (canNext, canPrevious)
+    remoteCommandController.refreshSkipAvailability()
+  }
+
+  // MARK: - Observed Events
+
+  private func playerDidEmit(_ event: PlayerObserver.Event) {
+    switch event {
+    case let .status(status):
+      if status == .failed { reportFailure(nil) }
+    case let .timeControlStatus(status):
+      let mapped: PlayerTimeControlStatus
+      switch status {
+      case .paused: mapped = .paused
+      case .waitingToPlayAtSpecifiedRate: mapped = .waitingToPlayAtSpecifiedRate
+      case .playing: mapped = .playing
+      @unknown default: return
+      }
+      onEvent?(.timeControlStatus(mapped, waitingForNoItem: avPlayer.reasonForWaitingToPlay == .noItemToPlay))
+    case .audioDidStart:
+      onEvent?(.audioDidStart)
+    }
+  }
+
+  private func itemDidEmit(_ event: ItemObserver.Event) {
+    switch event {
+    case let .likelyToKeepUp(isLikely): onEvent?(.likelyToKeepUp(isLikely))
+    case let .failed(error), let .failedToPlayToEnd(error): reportFailure(error)
+    case .playedToEnd: onEvent?(.playedToEnd)
+    case .stalled: onEvent?(.stalled)
+    case let .timedMetadata(groups): callbacks?.playerDidReceiveTimedMetadata(groups)
+    }
+  }
+
+  /// The item's own error stands in when the report carried none.
+  private func reportFailure(_ error: Error?) {
+    onEvent?(.failed(error ?? avPlayer.currentItem?.error, httpStatusCode: currentItemHttpStatusCode))
+  }
+
+  /// The HTTP status the server last answered the current item with. `AVPlayerItem.error` never
+  /// carries it (a 404 arrives as an opaque CoreMedia error), so the per-item error log is the
+  /// only place it surfaces.
+  private var currentItemHttpStatusCode: Int? {
+    guard let events = avPlayer.currentItem?.errorLog()?.events else { return nil }
+    return PlaybackFailure.httpStatusCode(fromErrorStatusCodes: events.map(\.errorStatusCode))
+  }
+
+  private func mediaLoaderDidEmit(_ event: MediaLoader.Event) {
+    switch event {
+    case let .prepared(item):
+      nowPlayingInfoController.prepareItem(item)
+      avPlayer.replaceCurrentItem(with: item)
+      itemObserver?.invalidate()
+      itemObserver = ItemObserver(item: item) { [weak self] in self?.itemDidEmit($0) }
+      onEvent?(.itemPrepared(likelyToKeepUp: item.isPlaybackLikelyToKeepUp))
+    case let .failed(error):
+      attachPublishingCarrierItemIfNeeded()
+      onEvent?(.loadFailed(error))
+    case .unplayable:
+      attachPublishingCarrierItemIfNeeded()
+      onEvent?(.unplayable)
+    case let .invalidSource(url):
+      // No carrier: an invalid src never produced an asset.
+      onEvent?(.invalidSource(url))
+    case let .commonMetadata(items):
+      callbacks?.playerDidReceiveCommonMetadata(items)
+    case let .chapterMetadata(groups):
+      callbacks?.playerDidReceiveChapterMetadata(groups)
+    case let .timedMetadata(groups):
+      callbacks?.playerDidReceiveTimedMetadata(groups)
+    }
+  }
+
+  /// `MPNowPlayingSession` publishes only through the linked player's current item, so a load
+  /// that fails before item creation (a dead host on a cold start) leaves nothing to surface on
+  /// the lock screen or CarPlay. The failed asset's item is attached purely as a publishing
+  /// carrier, unobserved, so its `.failed` status cannot re-report the loader's error. A
+  /// successful load replaces it; a retry's reload leaves it in place, so the surface doesn't
+  /// flicker.
+  private func attachPublishingCarrierItemIfNeeded() {
+    guard avPlayer.currentItem == nil, let asset = mediaLoader.asset else { return }
+    logger.notice("Attaching publishing-carrier item for failed load")
+    let item = AVPlayerItem(asset: asset)
+    nowPlayingInfoController.prepareItem(item)
+    avPlayer.replaceCurrentItem(with: item)
+  }
+}
+
+extension Player: AudioSessionPlayer {}
+
+extension Player: NowPlayingSource {}
+
+/// Resolves the URLs the player fetches.
+@MainActor
+protocol MediaResolving: AnyObject {
+  func resolveMediaUrl(_ src: String, track: Track?) async -> MediaResolvedUrl
+  func resolveNowPlayingArtwork(track: Track, imageContext: ImageContext?) async -> ImageSource?
+}

package/ios/AVPlayerEngineCallbacks.swift

@@ -0,0 +1,15 @@
+import AVFoundation
+import MediaPlayer
+import NitroModules
+
+/// What the AVPlayerEngine reports: the remote commands, and the metadata and now-playing
+/// changes, which carry AVFoundation types. HybridAudioBrowser implements it. The method names
+/// are prefixed so they don't collide with the JS callback properties.
+@MainActor
+protocol AVPlayerEngineCallbacks: RemoteCommandCallbacks {
+  func playerDidReceiveCommonMetadata(_ metadata: [AVMetadataItem])
+  func playerDidReceiveTimedMetadata(_ metadata: [AVTimedMetadataGroup])
+  func playerDidReceiveChapterMetadata(_ metadata: [AVTimedMetadataGroup])
+  /// The now-playing lines or track changed; carries the metadata JS sees.
+  func playerDidChangeNowPlaying(_ metadata: NowPlayingMetadata)
+}

package/ios/Browser/BrowseGate.swift

@@ -0,0 +1,58 @@
+import NitroModules
+
+/// The Browse Gate: an app-imposed block on browsing and searching from external surfaces,
+/// decided per request. It never blocks the Player, the Queue or Now Playing.
+@MainActor
+final class BrowseGate {
+  enum Mode {
+    case off
+    /// Every request is gated, with this chrome or the built-in one.
+    case fixed(Gate?)
+    /// JS decides each request; `default` is the chrome when its decision carries none.
+    case resolved(default: Gate?)
+  }
+
+  /// Served when a request is gated with no chrome from JS or `setGate`.
+  static let builtInChrome = Gate(title: "Unavailable", message: nil)
+
+  private(set) var mode: Mode = .off
+
+  /// Fires `isActive` on every set and clear; chrome is per request, so surfaces re-render.
+  let changed = Emitter<Bool>()
+
+  /// Asks JS for a decision; set by the bridge, whose JS resolver it calls.
+  var resolve: @MainActor (NativeGateRequest) async throws -> GateDecision = { _ in throw CancellationError() }
+
+  nonisolated init() {}
+
+  var isActive: Bool {
+    if case .off = mode { false } else { true }
+  }
+
+  func set(chrome: Gate?, hasResolver: Bool) {
+    mode = hasResolver ? .resolved(default: chrome) : .fixed(chrome)
+    changed.emit(true)
+  }
+
+  func clear() {
+    guard isActive else { return }
+    mode = .off
+    changed.emit(false)
+  }
+
+  /// The chrome to show if `request` is gated; nil when it is allowed. A resolver that fails
+  /// cannot prove the request allowed, so it is gated: a gate exists to withhold content, and
+  /// serving on an error would leak it.
+  func decide(_ request: NativeGateRequest) async -> Gate? {
+    switch mode {
+    case .off:
+      return nil
+    case let .fixed(chrome):
+      return chrome ?? Self.builtInChrome
+    case let .resolved(defaultChrome):
+      guard let decision = try? await resolve(request) else { return defaultChrome ?? Self.builtInChrome }
+      guard decision.gated else { return nil }
+      return decision.gate ?? defaultChrome ?? Self.builtInChrome
+    }
+  }
+}

package/ios/Browser/BrowserConfig.swift

@@ -1,97 +1,64 @@
 import Foundation
 import NitroModules
-import os.log
 
-/// Flattened browser configuration (matches Kotlin BrowserConfig).
-///
-/// This is a convenience wrapper around NativeBrowserConfiguration that
-/// provides easier access to configuration properties.
+/// The browser configuration, copied out of `NativeBrowserConfiguration` once per
+/// `configureBrowser`: the generated getters convert from C++ on every read, and routes are read
+/// on every resolve. Matches Kotlin's BrowserConfig.
 struct BrowserConfig {
   /// Base HTTP request configuration (applied to every request kind)
-  let request: TransformableRequestConfig?
+  var request: TransformableRequestConfig?
 
   /// Browse-kind request configuration (applied to every browse request,
   /// layered request → browse → route)
-  let browse: TransformableRequestConfig?
+  var browse: TransformableRequestConfig?
 
   /// Resolver for the shared request layer (resolved once per content generation).
-  let requestResolver: (() -> Promise<Promise<TransformableRequestConfig>>)?
+  var requestResolver: (() -> Promise<Promise<TransformableRequestConfig>>)?
 
   /// Resolver for the browse layer (resolved once per content generation).
-  let browseResolver: (() -> Promise<Promise<TransformableRequestConfig>>)?
+  var browseResolver: (() -> Promise<Promise<TransformableRequestConfig>>)?
 
   /// Media URL transformation configuration
-  let media: MediaRequestConfig?
+  var media: MediaRequestConfig?
 
   /// Artwork URL transformation configuration
-  let artwork: ArtworkRequestConfig?
+  var artwork: ArtworkRequestConfig?
 
   /// Now-playing-only artwork configuration (lock screen / CarPlay / Android Auto
   /// now-playing). A distinct kind from `artwork`; the now-playing path falls back to
   /// `artwork` when this is nil.
-  let nowPlayingArtwork: ArtworkRequestConfig?
+  var nowPlayingArtwork: ArtworkRequestConfig?
 
   /// Routes as array with flattened entries
   /// Includes __tabs__, __search__, and __default__ special routes
-  let routes: [NativeRouteEntry]?
+  var routes: [NativeRouteEntry]?
 
   /// Behavior: single track playback vs queue expansion
-  let singleTrack: Bool
+  var singleTrack: Bool = false
 
   /// Behavior: show offline error in Android Auto controller
-  let androidControllerOfflineError: Bool
+  var androidControllerOfflineError: Bool = true
 
   // MARK: - CarPlay Options
 
   /// App-localized title for CarPlay loading screens (shown as the centered
   /// empty state while content resolves; nil leaves them blank)
-  let carPlayLoadingTitle: String?
+  var carPlayLoadingTitle: String?
 
   /// Resolves a browse path for the CarPlay Now Playing album line when the
   /// active track has no albumPath. Invoked on track changes (not at tap) so
   /// the album line only becomes tappable when a destination exists.
-  let resolveAlbumPath: ((_ track: Track) -> Promise<String?>)?
+  var resolveAlbumPath: ((_ track: Track) -> Promise<String?>)?
 
   /// Custom handler for track load events (overrides default load behavior)
-  let handleTrackLoad: ((_ event: TrackLoadEvent) -> Promise<Promise<Void>>)?
+  var handleTrackLoad: ((_ event: TrackLoadEvent) -> Promise<Promise<Void>>)?
 
   /// Callback to customize navigation error display (for i18n)
   /// Used by CarPlay and available via `useFormattedNavigationError()` for app UI.
-  let formatNavigationError: ((_ params: FormatNavigationErrorParams) -> Promise<FormattedNavigationError?>)?
-
-  init(
-    request: TransformableRequestConfig? = nil,
-    browse: TransformableRequestConfig? = nil,
-    requestResolver: (() -> Promise<Promise<TransformableRequestConfig>>)? = nil,
-    browseResolver: (() -> Promise<Promise<TransformableRequestConfig>>)? = nil,
-    media: MediaRequestConfig? = nil,
-    artwork: ArtworkRequestConfig? = nil,
-    nowPlayingArtwork: ArtworkRequestConfig? = nil,
-    routes: [NativeRouteEntry]? = nil,
-    singleTrack: Bool = false,
-    handleTrackLoad: ((_ event: TrackLoadEvent) -> Promise<Promise<Void>>)? = nil,
-    androidControllerOfflineError: Bool = true,
-    carPlayLoadingTitle: String? = nil,
-    resolveAlbumPath: ((_ track: Track) -> Promise<String?>)? = nil,
-    formatNavigationError: ((_ params: FormatNavigationErrorParams) -> Promise<FormattedNavigationError?>)? = nil,
-  ) {
-    self.request = request
-    self.browse = browse
-    self.requestResolver = requestResolver
-    self.browseResolver = browseResolver
-    self.media = media
-    self.artwork = artwork
-    self.nowPlayingArtwork = nowPlayingArtwork
-    self.routes = routes
-    self.singleTrack = singleTrack
-    self.handleTrackLoad = handleTrackLoad
-    self.androidControllerOfflineError = androidControllerOfflineError
-    self.carPlayLoadingTitle = carPlayLoadingTitle
-    self.resolveAlbumPath = resolveAlbumPath
-    self.formatNavigationError = formatNavigationError
-  }
+  var formatNavigationError: ((_ params: FormatNavigationErrorParams) -> Promise<FormattedNavigationError?>)?
+
+  init() {}
 
-  /// Create from NativeBrowserConfiguration
   init(from config: NativeBrowserConfiguration) {
     request = config.request
     browse = config.browse
@@ -117,43 +84,18 @@ struct BrowserConfig {
   /// no-content path). See `HybridAudioBrowser.dropStaleJSCallbacks` for why
   /// invoking a stale callback is fatal.
   func strippingJSCallbacks() -> BrowserConfig {
-    BrowserConfig(
-      request: request?.strippingJSCallbacks(),
-      browse: browse?.strippingJSCallbacks(),
-      media: media?.strippingJSCallbacks(),
-      artwork: artwork?.strippingJSCallbacks(),
-      nowPlayingArtwork: nowPlayingArtwork?.strippingJSCallbacks(),
-      routes: routes?.map { $0.strippingJSCallbacks() },
-      singleTrack: singleTrack,
-      androidControllerOfflineError: androidControllerOfflineError,
-      carPlayLoadingTitle: carPlayLoadingTitle,
-    )
-  }
-
-  // MARK: - Track Load Handler
-
-  private static let logger = Logger(subsystem: "com.audiobrowser", category: "BrowserConfig")
-
-  /// Awaits the handleTrackLoad callback using the double-Promise pattern required by Nitro.
-  ///
-  /// Nitro wraps value-returning JS callbacks in Promise<T> for thread safety, so a JS callback
-  /// returning Promise<void> becomes Promise<Promise<Void>> on the native side. Both layers
-  /// must be awaited to properly wait for the JS work to complete.
-  ///
-  /// - Returns: true if the handler was present and invoked, false if not configured
-  func awaitTrackLoadHandler(event: TrackLoadEvent) async -> Bool {
-    guard let handler = handleTrackLoad else { return false }
-    do {
-      // MainActor: Nitro bridge call must be on main thread (C++ noexcept)
-      nonisolated(unsafe) let _handler = handler
-      nonisolated(unsafe) let _event = event
-      let outerPromise = await MainActor.run { _handler(_event) }
-      let innerPromise = try await outerPromise.await()
-      try await innerPromise.await()
-    } catch {
-      Self.logger.error("handleTrackLoad failed: \(error.localizedDescription)")
-    }
-    return true
+    // Built up from empty, so a field added later is dropped unless it is copied here.
+    var stripped = BrowserConfig()
+    stripped.request = request?.strippingJSCallbacks()
+    stripped.browse = browse?.strippingJSCallbacks()
+    stripped.media = media?.strippingJSCallbacks()
+    stripped.artwork = artwork?.strippingJSCallbacks()
+    stripped.nowPlayingArtwork = nowPlayingArtwork?.strippingJSCallbacks()
+    stripped.routes = routes?.map { $0.strippingJSCallbacks() }
+    stripped.singleTrack = singleTrack
+    stripped.androidControllerOfflineError = androidControllerOfflineError
+    stripped.carPlayLoadingTitle = carPlayLoadingTitle
+    return stripped
   }
 }