react-native-audio-browser 0.2.0-next.32 → 0.2.0-next.34

package/ios/HybridAudioBrowser+Browser.swift

@@ -10,12 +10,16 @@ public extension HybridAudioBrowser {
   /// synchronous: JS hears it before the navigation that may set the error again.
   internal func navigate(_ path: String, clearError: Bool) {
     if clearError { onMainActor { navigationError.clear() } }
-    Task { @MainActor in
-      do {
-        try await browserManager.load(path)
-      } catch {
-        await reportNavigationError(error, path: path)
-      }
+    Task { @MainActor in await loadPath(path) }
+  }
+
+  /// Loads `path` into the browser, reporting a failure as the navigation error.
+  @MainActor
+  private func loadPath(_ path: String) async {
+    do {
+      try await browserManager.load(path)
+    } catch {
+      await reportNavigationError(error, path: path)
     }
   }
 
@@ -33,9 +37,7 @@ public extension HybridAudioBrowser {
   }
 
   func navigateTrack(track: Track) throws {
-    // @MainActor: `player` is main-confined, and `trackSelector.select` is
-    // MainActor anyway — a bare Task read the reference off the cooperative
-    // pool, racing the assignment in `setupPlayer`.
+    // @MainActor: `player` is main-confined.
     Task { @MainActor in
       guard let player else { return }
       let result = await trackSelector.select(track: track, player: player)
@@ -81,41 +83,22 @@ public extension HybridAudioBrowser {
   func notifyContentChanged(path: String) throws {
     // Throws on a contextual path (matching Android's `require`) — the caller
     // must pass the container path, or the invalidation silently hits nothing.
-    try onMainActor { try browserManager.invalidateContentCache(path) }
-
-    // Notify external controllers (CarPlay) that content changed
-    externalContentChangedEmitter.emit(path)
-
-    // Re-resolve the path if it's the current browser path
-    if onMainActor({ browserManager.path }) == path {
-      navigate(path, clearError: false)
+    let isCurrentPath = try onMainActor {
+      try browserManager.invalidateContentCache(path)
+      return browserManager.path == path
     }
+    externalContentChangedEmitter.emit(path)
+    if isCurrentPath { navigate(path, clearError: false) }
   }
 
   func invalidateAllContent() throws {
-    onMainActor { browserManager.clearContentCache() }
-
-    // Tell external controllers (CarPlay) to refresh every displayed template.
-    externalContentChangedEmitter.emit(Self.invalidateAllSentinel)
-
-    // Re-query the tabs source too: a callback source can resolve to new
-    // titles after an invalidation (e.g. a locale switch). BrowserManager
-    // emits tabsChanged only when the result actually differs, and a failed
-    // re-query keeps the current tabs. (Android needs no equivalent — its
-    // root re-query already runs queryTabs(); the web stub re-queries tabs on
-    // the re-navigation.)
-    Task {
-      _ = try? await browserManager.queryTabs()
-    }
-
-    // Re-resolve the JS-facing current path with the cache cleared.
-    Task { @MainActor in
-      do {
-        try await browserManager.load(browserManager.path, bypassCache: true)
-      } catch {
-        await reportNavigationError(error, path: browserManager.path)
+    onMainActor {
+      browserManager.invalidateAll { error, path in
+        await self.reportNavigationError(error, path: path)
       }
     }
+    // Tell external controllers (CarPlay) to refresh every displayed template.
+    externalContentChangedEmitter.emit(Self.invalidateAllSentinel)
   }
 
   func setFavorites(favorites: [String]) throws {

package/ios/HybridAudioBrowser+Options.swift

@@ -10,7 +10,6 @@ public extension HybridAudioBrowser {
 
   func setupPlayer(options: NativeSetupPlayerOptions) throws -> Promise<Void> {
     Promise.async {
-      // Create player and configure on main actor
       await MainActor.run { [weak self] in
         guard let self else { return }
         // Set the category now, but activate only when playback produces output.
@@ -20,58 +19,34 @@ public extension HybridAudioBrowser {
         // and un-published first. No-op on first setup.
         destroyPlayer()
 
-        let newEngine = AVPlayerEngine(callbacks: self, resolver: browserManager.requests)
-        if let buffer = options.ios?.buffer { newEngine.bufferDuration = buffer }
-        newEngine.nowPlayingUpdater.enabled = options.autoUpdateNowPlayingMetadata ?? true
-        newEngine.nowPlayingUpdater.formatter = options.nowPlayingMetadataFormatter
-        newEngine.nowPlayingUpdater.isOnline = networkMonitor.isOnline
-        let newPlayer = Player(engine: newEngine)
-        newPlayer.callbacks = self
-        newPlayer.retry.networkMonitor = networkMonitor
+        let newEngine = AVPlayerEngine(
+          callbacks: self,
+          resolver: browserManager.requests,
+          audioSession: audioSession,
+          networkStatus: networkMonitor,
+          bufferDuration: options.ios?.buffer ?? 0,
+          nowPlayingEnabled: options.autoUpdateNowPlayingMetadata ?? true,
+          nowPlayingFormatter: options.nowPlayingMetadataFormatter,
+        )
+        let newPlayer = Player(engine: newEngine, callbacks: self, retry: RetryLoop(networkMonitor: networkMonitor))
         if let retry = options.retry { newPlayer.retry.updatePolicy(from: retry) }
         newEngine.nowPlayingUpdater.source = newPlayer
         engine = newEngine
         player = newPlayer
         audioSession.player = newPlayer
 
-        // Connectivity fans out here, whether or not JS subscribes: the JS event, the
-        // now-playing stall line, and reconnecting a stalled stream. The monitor mutates on main.
-        networkMonitor.onChanged = { [weak self] isOnline in
-          MainActor.assumeIsolated {
-            self?.onOnlineChanged(isOnline)
-            self?.engine?.nowPlayingUpdater.isOnline = isOnline
-            if isOnline { self?.player?.networkDidReturn() }
-          }
-        }
-
-        // `options.keepSessionAliveOnError` is deliberately ignored here: iOS needs no masking.
-        // A terminal error keeps the now-playing info (never cleared on error), and next/previous
-        // stay enabled (gated on queue position, not state). So the
-        // session stays controllable through errors by default — the behavior Android achieves via
-        // InterceptingPlayer is already the iOS norm.
+        // `options.keepSessionAliveOnError` is ignored: on iOS an error never clears the now-playing
+        // info, and next/previous follow the queue, not the state.
 
         // The bundled runtime options and initial state are part of the atomic launch
         // description. Stage the state first so setup options and earlier pre-setup setter
         // calls resolve by strict last-write-wins, then apply everything to the live player.
-        if let bundled = options.options {
-          updateOptions(options: bundled)
-        } else {
-          // updateOptions applies remote commands itself; without bundled options, apply the
-          // defaults (play, pause, next, previous, seekTo) here.
-          applyRemoteCommands()
-        }
+        if let bundled = options.options { updateOptions(options: bundled) }
         if let mode = options.repeatMode { pendingRepeatMode = mode }
         if let intent = options.playWhenReady { pendingPlayWhenReady = intent }
         applyPendingPlayerState()
-
-        // Push the resolved event cadence unconditionally. `updateOptions` applies
-        // the interval only when it *differs* from the stored one, but the store
-        // outlives the player — so on a re-setup with unchanged options the new
-        // player would come up with no progress timer at all.
-        player?.setProgressUpdateInterval(playerOptions.progressUpdateEventInterval)
-        player?.setPlaybackIntervalEnabled(playbackIntervalEnabled)
-
-        // Notify listeners that player is ready (e.g., CarPlay)
+        // The stored options outlive the player, so a re-setup applies them to the new one.
+        applyOptions()
         playerAndConfiguredBrowser.check()
       }
     }
@@ -95,40 +70,26 @@ public extension HybridAudioBrowser {
 
   func updateOptions(options: NativeUpdateOptions) {
     onMainActor {
-      let previousInterval = playerOptions.progressUpdateEventInterval
-
-      // Update stored options
       playerOptions.update(from: options)
-
-      // Propagate the favorite flag to the browser so it can hydrate
-      // row hearts (the `favorite` capability is the single favoriting switch).
-      browserManager.setFavoriteEnabled(playerOptions.capabilities.favoriteEnabled)
-
-      // Apply remote commands to player
-      applyRemoteCommands()
-
-      // Apply progress update interval if changed
-      if playerOptions.progressUpdateEventInterval != previousInterval {
-        player?.setProgressUpdateInterval(playerOptions.progressUpdateEventInterval)
-      }
-
+      applyOptions()
       onOptionsChanged(playerOptions.toOptions())
       playerOptionsChangedEmitter.emit(())
     }
   }
 
-  /// Converts capabilities to remote commands and applies them to the player
+  /// Applies the stored options to the browser, the player and its engine. Idempotent.
   @MainActor
-  private func applyRemoteCommands() {
-    guard let engine else { return }
-
-    let remoteCommands = playerOptions.capabilities.buildRemoteCommands(
-      forwardJumpInterval: NSNumber(value: playerOptions.forwardJumpInterval),
-      backwardJumpInterval: NSNumber(value: playerOptions.backwardJumpInterval),
+  private func applyOptions() {
+    // The `favorite` capability is the one favoriting switch: it also drives the row hearts.
+    browserManager.setFavoriteEnabled(playerOptions.capabilities.favoriteEnabled)
+    engine?.remoteCommandController.enable(
+      commands: playerOptions.capabilities.remoteCommands,
+      forwardJumpInterval: playerOptions.forwardJumpInterval,
+      backwardJumpInterval: playerOptions.backwardJumpInterval,
       playbackRates: playerOptions.playbackRates,
     )
-
-    engine.remoteCommands = remoteCommands
+    player?.setProgressUpdateInterval(playerOptions.progressUpdateEventInterval)
+    player?.setPlaybackIntervalEnabled(playerOptions.playbackIntervalEnabled)
   }
 
   func getOptions() throws -> Options {
@@ -137,7 +98,7 @@ public extension HybridAudioBrowser {
 
   func setPlaybackIntervalEnabled(enabled: Bool) {
     onMainActor {
-      playbackIntervalEnabled = enabled
+      playerOptions.playbackIntervalEnabled = enabled
       player?.setPlaybackIntervalEnabled(enabled)
     }
   }

package/ios/HybridAudioBrowser+Player.swift

@@ -230,7 +230,9 @@ public extension HybridAudioBrowser {
       try player.replace(player.queue.currentIndex, updated)
       // The only emit: a favorite toggle mutates the active track in place, so
       // onPlaybackActiveTrackChanged stays transition-only.
-      favoriteChangedEmitter.emit(FavoriteChangedEvent(track: updated, favorited: favorited))
+      let event = FavoriteChangedEvent(track: updated, favorited: favorited)
+      onFavoriteChanged(event)
+      favoriteChangedEmitter.emit(event)
       return true
     }
   }
@@ -334,64 +336,6 @@ public extension HybridAudioBrowser {
   }
 
   func openOutputPicker() throws {
-    DispatchQueue.main.async { [weak self] in
-      guard let self else { return }
-      guard let windowScene = UIApplication.shared.activeWindowScene,
-            let window = windowScene.windows.first(where: { $0.isKeyWindow }),
-            var topController = window.rootViewController
-      else {
-        self.logger.error("openOutputPicker: no active window scene / root view controller")
-        return
-      }
-
-      // Walk up to the topmost presented view controller
-      while let presented = topController.presentedViewController {
-        topController = presented
-      }
-
-      // AVRoutePickerView has no public API to present its picker
-      // programmatically, so we add it to the hierarchy and tap its internal
-      // button. Two requirements that are easy to get wrong:
-      //   1. The view must be *visible* to the system (a `isHidden` source view
-      //      suppresses the presentation), so we keep it transparent instead.
-      //   2. The internal button can be nested below the top-level subviews on
-      //      modern iOS, so we search recursively rather than only direct children.
-      let routePicker = AVRoutePickerView(frame: CGRect(x: 0, y: 0, width: 1, height: 1))
-      routePicker.alpha = 0.01
-      topController.view.addSubview(routePicker)
-
-      let button = Self.firstButton(in: routePicker)
-      self.logger.notice(
-        "openOutputPicker: hierarchy=\(Self.describeHierarchy(routePicker), privacy: .public), buttonFound=\(button != nil, privacy: .public)",
-      )
-
-      if let button {
-        button.sendActions(for: .touchUpInside)
-      } else {
-        self.logger.error("openOutputPicker: no UIButton found inside AVRoutePickerView")
-      }
-
-      // Keep the source view in the hierarchy long enough for the picker to
-      // present (on iPad it anchors a popover to this view).
-      DispatchQueue.main.asyncAfter(deadline: .now() + 2.0) {
-        routePicker.removeFromSuperview()
-      }
-    }
-  }
-
-  /// Depth-first search for the first `UIButton` inside a view tree.
-  private static func firstButton(in view: UIView) -> UIButton? {
-    if let button = view as? UIButton { return button }
-    for subview in view.subviews {
-      if let button = firstButton(in: subview) { return button }
-    }
-    return nil
-  }
-
-  /// Compact description of a view tree, e.g. `AVRoutePickerView[UIButton[UIImageView]]`.
-  private static func describeHierarchy(_ view: UIView) -> String {
-    let name = String(describing: type(of: view))
-    let children = view.subviews.map(describeHierarchy).joined(separator: ", ")
-    return children.isEmpty ? name : "\(name)[\(children)]"
+    DispatchQueue.main.async { OutputPicker.present() }
   }
 }

package/ios/HybridAudioBrowser+PlayerCallbacks.swift

@@ -10,8 +10,6 @@ import os.log
 extension HybridAudioBrowser: PlayerCallbacks, AVPlayerEngineCallbacks {
   public func playerDidChangePlayback(_ playback: Playback) {
     onPlaybackChanged(playback)
-    // The Player sets the error before this fires, so the error line renders.
-    engine?.nowPlayingUpdater.render()
   }
 
   public func playerDidChangeActiveTrack(_ event: PlaybackActiveTrackChangedEvent) {
@@ -25,8 +23,8 @@ extension HybridAudioBrowser: PlayerCallbacks, AVPlayerEngineCallbacks {
       index: event.index,
       track: event.track.map(browserManager.hydrateFavorite),
     )
+    onPlaybackActiveTrackChanged(hydrated)
     activeTrackChangedEmitter.emit(hydrated)
-    engine?.nowPlayingUpdater.trackChanged()
   }
 
   public func playerDidUpdateProgress(_ event: PlaybackProgressUpdatedEvent) {
@@ -38,32 +36,11 @@ extension HybridAudioBrowser: PlayerCallbacks, AVPlayerEngineCallbacks {
   }
 
   public func playerDidChangePlayWhenReady(_ playWhenReady: Bool) {
-    // Intent to play again is the earliest cancel signal for a pending session release.
-    if playWhenReady { audioSession.cancelRelease() }
     onPlaybackPlayWhenReadyChanged(PlaybackPlayWhenReadyChangedEvent(playWhenReady: playWhenReady))
   }
 
   public func playerDidChangePlayingState(_ state: PlayingState) {
     onPlaybackPlayingState(state)
-    // Lazily activate the audio session the moment playback actually produces — or is buffering to
-    // produce — output. This (not setup) is where we grab the session, so launching the app never
-    // interrupts other apps' audio; the interruption only happens when the user truly starts
-    // playback, which is correct. Keyed off play *state*, not `playWhenReady`, because the intent
-    // can be set at setup (before any track) while output only begins here. Idempotent:
-    // `setActive(true)` is a no-op when the session is already active.
-    if state.playing || state.buffering {
-      // The now-playing session's activation request at link time predates this
-      // (the audio session was still inactive, and the system may have declined);
-      // re-request once the audio session is active, so the surface can appear even if
-      // playback never produces audio (first-ever load failing on a dead stream).
-      audioSession.activate { [weak self] in self?.engine?.reactivateNowPlayingSession() }
-    }
-    // A stall starting or recovering may not change the Player state.
-    engine?.nowPlayingUpdater.render()
-  }
-
-  public func playerShouldReleaseSession() {
-    audioSession.scheduleRelease()
   }
 
   public func playerDidEndQueue(_ event: PlaybackQueueEndedEvent) {
@@ -71,16 +48,18 @@ extension HybridAudioBrowser: PlayerCallbacks, AVPlayerEngineCallbacks {
   }
 
   public func playerDidChangeQueue(_ tracks: [Track]) {
+    onPlaybackQueueChanged(tracks)
     queueChangedEmitter.emit(tracks)
   }
 
   public func playerDidChangeRepeatMode(_ event: RepeatModeChangedEvent) {
+    onPlaybackRepeatModeChanged(event)
     repeatModeChangedEmitter.emit(event)
   }
 
   public func playerDidChangeShuffleEnabled(_ enabled: Bool) {
-    shuffleChangedEmitter.emit(enabled)
     onPlaybackShuffleModeChanged(enabled)
+    shuffleChangedEmitter.emit(enabled)
   }
 
   public func playerDidError(_ event: PlaybackErrorEvent) {
@@ -100,13 +79,8 @@ extension HybridAudioBrowser: PlayerCallbacks, AVPlayerEngineCallbacks {
     onTrackMetadata(metadata)
   }
 
-  public func playerDidReceiveTimedMetadata(_ groups: [AVTimedMetadataGroup]) {
-    for group in groups {
-      if let metadata = TimedMetadata.from(items: group.items, icyCharset: player?.currentTrack?.icyCharset) {
-        onTimedMetadata(metadata)
-        engine?.nowPlayingUpdater.receivedTimedMetadata(metadata)
-      }
-    }
+  public func playerDidReceiveTimedMetadata(_ metadata: TimedMetadata) {
+    onTimedMetadata(metadata)
   }
 
   public func playerDidReceiveChapterMetadata(_ groups: [AVTimedMetadataGroup]) {
@@ -126,10 +100,6 @@ extension HybridAudioBrowser: PlayerCallbacks, AVPlayerEngineCallbacks {
     dispatchRemote(handler: handleRemoteStop, report: onRemoteStop) { player?.stop() }
   }
 
-  public func remotePlayPause() {
-    if player?.playWhenReady == true { remotePause() } else { remotePlay() }
-  }
-
   public func remoteNext() {
     dispatchRemote(handler: handleRemoteNext, report: onRemoteNext) { player?.next() }
   }
@@ -174,12 +144,10 @@ extension HybridAudioBrowser: PlayerCallbacks, AVPlayerEngineCallbacks {
   }
 
   public func remoteChangeRepeatMode(mode: RepeatMode) {
-    // Apply the repeat mode change from CarPlay/lock screen
     try? setRepeatMode(mode: mode)
   }
 
   public func remoteChangeShuffleMode(enabled: Bool) {
-    // Apply the shuffle mode change from CarPlay/lock screen
     try? setShuffleEnabled(enabled: enabled)
   }
 

package/ios/HybridAudioBrowser.swift

@@ -8,7 +8,7 @@ import os.log
 @MainActor let playerAndConfiguredBrowser = ReadyValue<(HybridAudioBrowser, Player)> {
   guard let browser = HybridAudioBrowser.shared,
         browser.browserManager.isConfigured,
-        let player = browser.getPlayer() else { return nil }
+        let player = browser.player else { return nil }
   return (browser, player)
 }
 
@@ -34,14 +34,10 @@ public class HybridAudioBrowser: HybridAudioBrowserSpec, @unchecked Sendable {
   /// silent.
   static let instanceChangedEmitter = Emitter<Void>()
 
-  /// Installed once, on first instance creation. React Native posts this
-  /// notification (from `RCTReloadCommand`) when a JS reload — dev or
-  /// OTA-update restart — is triggered, *before* the old runtime is destroyed:
-  /// the earliest signal that this instance's JS callbacks are about to go
-  /// stale. `init` of the replacement instance drops them too, but only after
-  /// the new runtime is up; this observer closes the window in between.
-  /// Observed by name so the library needs no React-Core dependency (and
-  /// stays inert under SPM tests, where nothing posts it).
+  /// React Native posts this notification when a JS reload is triggered, before the old runtime
+  /// is destroyed: the earliest sign this instance's JS callbacks go stale. The replacement's
+  /// `init` drops them too, but only once the new runtime is up. Observed by name, so the library
+  /// needs no React-Core dependency.
   @MainActor private static let reloadObserver: NSObjectProtocol = NotificationCenter.default.addObserver(
     forName: Notification.Name("RCTTriggerReloadCommandNotification"),
     object: nil,
@@ -71,29 +67,16 @@ public class HybridAudioBrowser: HybridAudioBrowserSpec, @unchecked Sendable {
   @MainActor var pendingRepeatMode: RepeatMode?
   @MainActor let playerOptions = PlayerUpdateOptions()
 
-  /// Configured playback rates for the playback-rate capability (for CarPlay rate cycling)
-  @MainActor var playbackRates: [Double] { playerOptions.playbackRates }
-  @MainActor var carPlayUpNextButton: Bool { playerOptions.carPlayUpNextButton }
-  @MainActor var carPlayNowPlayingButtons: [CarPlayNowPlayingButton] {
-    playerOptions.carPlayNowPlayingButtons
-  }
-
-  @MainActor var carPlayPlayingIndicatorLocation: CarPlayPlayingIndicatorLocation {
-    playerOptions.carPlayPlayingIndicatorLocation
-  }
-
   @MainActor lazy var navigationError = NavigationErrorState(
-    onErrorChanged: { [weak self] in self?.navigationErrorEmitter.emit(NavigationErrorEvent(error: $0)) },
+    onErrorChanged: { [weak self] in self?.onNavigationError(NavigationErrorEvent(error: $0)) },
     onFormattedChanged: { [weak self] in self?.onFormattedNavigationError($0) },
   )
 
-  // MARK: - Multi-Listener Emitters
+  // MARK: - Emitters for Native Listeners
 
-  /// Emitters allow multiple listeners for each event type, avoiding callback hijacking
   public let favoriteChangedEmitter = Emitter<FavoriteChangedEvent>()
   public let activeTrackChangedEmitter = Emitter<PlaybackActiveTrackChangedEvent>()
   public let queueChangedEmitter = Emitter<[Track]>()
-  public let navigationErrorEmitter = Emitter<NavigationErrorEvent>()
   public let repeatModeChangedEmitter = Emitter<RepeatModeChangedEvent>()
   public let shuffleChangedEmitter = Emitter<Bool>()
   public let externalContentChangedEmitter = Emitter<String>()
@@ -111,17 +94,7 @@ public class HybridAudioBrowser: HybridAudioBrowserSpec, @unchecked Sendable {
 
   /// Runs a closure on MainActor synchronously. Safe for non-Sendable return types
   /// because DispatchQueue.main.sync blocks the caller — no concurrent access window.
-  func onMainActor<T>(_ work: @MainActor () -> T) -> T {
-    if Thread.isMainThread {
-      MainActor.assumeIsolated { UncheckedSendableBox(value: work()) }.value
-    } else {
-      DispatchQueue.main.sync {
-        MainActor.assumeIsolated { UncheckedSendableBox(value: work()) }.value
-      }
-    }
-  }
-
-  func onMainActor<T>(_ work: @MainActor () throws -> T) throws -> T {
+  func onMainActor<T>(_ work: @MainActor () throws -> T) rethrows -> T {
     if Thread.isMainThread {
       try MainActor.assumeIsolated { try UncheckedSendableBox(value: work()) }.value
     } else {
@@ -159,14 +132,11 @@ public class HybridAudioBrowser: HybridAudioBrowserSpec, @unchecked Sendable {
       let configuredPath = configuration.path
       onMainActor { browserManager.config = BrowserConfig(from: configuration) }
 
-      // Query tabs and navigate to initial path after config is set (matches Kotlin behavior)
       Task { @MainActor in
-        // Notify waiting listeners (e.g., CarPlay cold start)
         playerAndConfiguredBrowser.check()
       }
       Task {
         let tabs = try? await browserManager.queryTabs()
-        // Navigate to configured path, first tab, or "/"
         navigate(configuredPath ?? tabs?.first?.path ?? "/", clearError: true)
       }
     }
@@ -258,9 +228,7 @@ public class HybridAudioBrowser: HybridAudioBrowserSpec, @unchecked Sendable {
   public var onNowPlayingChanged: (NowPlayingMetadata) -> Void = { _ in }
   public var onOnlineChanged: (Bool) -> Void = { _ in } {
     didSet {
-      // The monitor->JS bridge is wired centrally in setupPlayer (so it doesn't depend on a JS
-      // subscription and can also drive the now-playing re-render + player reconnect). Here we only
-      // push the current state to a newly-attached subscriber.
+      // A new subscriber hears the current state at once.
       onOnlineChanged(networkMonitor.isOnline)
     }
   }
@@ -280,11 +248,6 @@ public class HybridAudioBrowser: HybridAudioBrowserSpec, @unchecked Sendable {
     }
   }
 
-  /// Stored so a re-setup can re-apply it: unlike the other runtime options this
-  /// one has no home in `playerOptions`, and the player it was pushed to does not
-  /// survive `setupPlayer`.
-  @MainActor var playbackIntervalEnabled = false
-
   // MARK: - Initialization
 
   override public init() {
@@ -302,6 +265,15 @@ public class HybridAudioBrowser: HybridAudioBrowserSpec, @unchecked Sendable {
       HybridAudioBrowser.shared = self
       audioSession.outputChanged.addListener { [weak self] in self?.onOutputChanged($0) }
       audioSession.volumeChanged.addListener { [weak self] in self?.onSystemVolumeChanged($0) }
+      // From the first setup on, whether or not JS subscribes: JS, then the player.
+      networkMonitor.changed.addListener { [weak self] isOnline in
+        guard let self else { return }
+        MainActor.assumeIsolated {
+          guard let player = self.player else { return }
+          self.onOnlineChanged(isOnline)
+          player.networkStatusDidChange(isOnline: isOnline)
+        }
+      }
       browseGate.resolve = { [weak self] request in
         guard let self else { throw CancellationError() }
         return try await resolveGate(request).await().await()
@@ -312,24 +284,18 @@ public class HybridAudioBrowser: HybridAudioBrowserSpec, @unchecked Sendable {
       // controller is subscribed to a dead instance's emitters.
       HybridAudioBrowser.instanceChangedEmitter.emit(())
     }
-    setupEmitterToNitroForwarding()
+    forwardBrowserEventsToJS()
   }
 
   /// Drops every JS-provided callback that native code can invoke on its own
   /// initiative (browse resolvers, `handleTrackLoad`, `resolveAlbumPath`,
   /// `formatNavigationError`, `resolveGate`, the now-playing formatter).
   ///
-  /// Called on the *previous* instance when a new one takes over: its JS runtime
-  /// is gone, and invoking a callback from a dead runtime aborts the process —
-  /// Nitro's `AsyncJSCallback` throws on a destroyed Dispatcher, and the throw
-  /// crosses the generated bridge wrapper's `noexcept` boundary. Native code
-  /// (e.g. a CarPlay controller still bound to this instance mid-reload) keeps
-  /// working off the data-only config with built-in fallbacks; `resolveGate`
-  /// reverts to the fail-closed default it documents for exactly this window.
-  /// One-shot: on a normal reload both triggers hit the same dying instance
-  /// (the reload notification, then the replacement's `init`), and the second
-  /// strip would re-fire the config-setter cascade — another `configChanged`
-  /// → CarPlay now-playing button rebuild — for nothing.
+  /// Called on the previous instance when a new one takes over: invoking a callback of a dead
+  /// runtime aborts the process (Nitro throws across a `noexcept` boundary). Native code still
+  /// bound to this instance (CarPlay mid-reload) keeps working off the data-only config;
+  /// `resolveGate` reverts to its fail-closed default. One-shot: both triggers reach the same
+  /// dying instance, and a second strip would re-run the config setter's cascade.
   @MainActor private var didDropJSCallbacks = false
 
   @MainActor
@@ -348,61 +314,32 @@ public class HybridAudioBrowser: HybridAudioBrowserSpec, @unchecked Sendable {
   }
 
   deinit {
-    // Safety net: ensure the AVPlayer is stopped if this instance is deallocated.
+    // Safety net: the AVPlayer must not outlive this instance. `self` can't reach the main
+    // actor from here, so the teardown takes what it releases.
     let player = self.player, engine = self.engine
-    if Thread.isMainThread {
-      MainActor.assumeIsolated {
-        player?.clear()
-        engine?.destroy()
-      }
-    } else {
-      DispatchQueue.main.async {
-        MainActor.assumeIsolated {
-          player?.clear()
-          engine?.destroy()
-        }
-      }
-    }
-  }
-
-  /// Returns the player, if setup has been called.
-  func getPlayer() -> Player? {
-    player
+    let tearDown: @Sendable () -> Void = { MainActor.assumeIsolated { Self.destroy(player, engine) } }
+    if Thread.isMainThread { tearDown() } else { DispatchQueue.main.async(execute: tearDown) }
   }
 
   /// Stops the player and releases its media stack: the AVPlayer and the now-playing session
   /// outlive a dropped reference otherwise.
   @MainActor
   func destroyPlayer() {
+    Self.destroy(player, engine)
+  }
+
+  @MainActor
+  private static func destroy(_ player: Player?, _ engine: AVPlayerEngine?) {
     player?.clear()
     engine?.destroy()
   }
 
-  /// Sets up automatic forwarding from emitters to Nitro callbacks
-  private func setupEmitterToNitroForwarding() {
+  /// Forwards the browser's events to JS. The bridge's own events call JS where they are
+  /// emitted; their emitters are for native listeners (CarPlay).
+  private func forwardBrowserEventsToJS() {
     browserManager.pathChanged.addListener { [weak self] in self?.onPathChanged($0) }
     browserManager.tabsChanged.addListener { [weak self] in self?.onTabsChanged($0) }
     browserManager.contentChanged.addListener { [weak self] in self?.onContentChanged($0) }
-
-    favoriteChangedEmitter.addListener { [weak self] event in
-      self?.onFavoriteChanged(event)
-    }
-
-    activeTrackChangedEmitter.addListener { [weak self] event in
-      self?.onPlaybackActiveTrackChanged(event)
-    }
-
-    queueChangedEmitter.addListener { [weak self] tracks in
-      self?.onPlaybackQueueChanged(tracks)
-    }
-
-    navigationErrorEmitter.addListener { [weak self] event in
-      self?.onNavigationError(event)
-    }
-
-    repeatModeChangedEmitter.addListener { [weak self] event in
-      self?.onPlaybackRepeatModeChanged(event)
-    }
   }
 }