react-native-audio-browser 0.2.0-next.11 → 0.2.0-next.13

package/ios/HybridAudioBrowser.swift

@@ -34,6 +34,24 @@ 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).
+  @MainActor private static let reloadObserver: NSObjectProtocol = NotificationCenter.default.addObserver(
+    forName: Notification.Name("RCTTriggerReloadCommandNotification"),
+    object: nil,
+    queue: .main,
+  ) { _ in
+    MainActor.assumeIsolated {
+      HybridAudioBrowser.shared?.dropStaleJSCallbacks()
+    }
+  }
+
   // MARK: - Private Properties
 
   /// Main-confined by convention, not annotation: `deinit` reads it as a
@@ -70,6 +88,10 @@ public class HybridAudioBrowser: HybridAudioBrowserSpec, @unchecked Sendable {
     playerOptions.carPlayNowPlayingButtons
   }
 
+  @MainActor var carPlayPlayingIndicatorLocation: CarPlayPlayingIndicatorLocation {
+    playerOptions.carPlayPlayingIndicatorLocation
+  }
+
   /// Written from the JS thread, the cooperative pool and MainActor, with a
   /// `didSet` that calls back into Nitro. MainActor-isolated so the compiler
   /// requires an `onMainActor` hop at every access.
@@ -164,7 +186,7 @@ public class HybridAudioBrowser: HybridAudioBrowserSpec, @unchecked Sendable {
   public var configuration: NativeBrowserConfiguration = .init(
     path: nil, request: nil, requestResolver: nil, browse: nil, browseResolver: nil, media: nil, artwork: nil, nowPlayingArtwork: nil, routes: nil,
     singleTrack: nil, handleTrackLoad: nil,
-    androidControllerOfflineError: nil, carPlayLoadingTitle: nil, resolveAlbumUrl: nil, formatNavigationError: nil,
+    androidControllerOfflineError: nil, carPlayLoadingTitle: nil, resolveAlbumPath: nil, formatNavigationError: nil,
   ) {
     didSet {
       // Copied here, on the setter's thread: the Task below outlives this call,
@@ -181,7 +203,7 @@ public class HybridAudioBrowser: HybridAudioBrowserSpec, @unchecked Sendable {
       Task {
         let tabs = try? await browserManager.queryTabs()
         // Navigate to configured path, first tab, or "/"
-        let initialPath = configuredPath ?? tabs?.first?.url ?? "/"
+        let initialPath = configuredPath ?? tabs?.first?.path ?? "/"
         // Clear error before navigation (matches Kotlin clearNavigationError())
         clearNavigationError()
         do {
@@ -213,8 +235,14 @@ public class HybridAudioBrowser: HybridAudioBrowserSpec, @unchecked Sendable {
   /// state, e.g. CarPlay re-seeding `isGated` at scene connect). Serving content
   /// in that window would be a fail-open leak — same direction as the
   /// resolver-error path in `gateDecision`. Matches Android's default.
-  public var resolveGate: (NativeGateRequest) -> Promise<Promise<GateDecision>> = { _ in
-    Promise.resolved(withResult: Promise.resolved(withResult: GateDecision(gated: true, gate: nil)))
+  public var resolveGate: (NativeGateRequest) -> Promise<Promise<GateDecision>> = HybridAudioBrowser.defaultResolveGate
+
+  // Computed, not stored: a nonisolated static holding a non-Sendable closure
+  // is rejected under Swift 6 concurrency checking.
+  static var defaultResolveGate: (NativeGateRequest) -> Promise<Promise<GateDecision>> {
+    { _ in
+      Promise.resolved(withResult: Promise.resolved(withResult: GateDecision(gated: true, gate: nil)))
+    }
   }
 
   /// Fired when a request is gated (served the gate). Set by JS.
@@ -306,7 +334,11 @@ public class HybridAudioBrowser: HybridAudioBrowserSpec, @unchecked Sendable {
     // playerAndConfiguredBrowser OnceValue, so we must explicitly stop
     // its player to prevent two audio streams running simultaneously.
     onMainActor {
+      // Statics are lazy — touch the observer so it's installed from the first
+      // instance onward.
+      _ = HybridAudioBrowser.reloadObserver
       HybridAudioBrowser.shared?.player?.destroy()
+      HybridAudioBrowser.shared?.dropStaleJSCallbacks()
       playerAndConfiguredBrowser.reset()
       HybridAudioBrowser.shared = self
       // Tell connected external controllers (CarPlay) to re-subscribe against
@@ -319,7 +351,52 @@ public class HybridAudioBrowser: HybridAudioBrowserSpec, @unchecked Sendable {
     setupBrowserCallbacks()
   }
 
+  /// 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 `onConfigChanged`
+  /// → CarPlay now-playing button rebuild — for nothing.
+  @MainActor private var didDropJSCallbacks = false
+
+  @MainActor
+  private func dropStaleJSCallbacks() {
+    guard !didDropJSCallbacks else { return }
+    didDropJSCallbacks = true
+    // Guarded: assigning `config` marks the browser configured (the setter's
+    // didSet), and a never-configured browser must keep cold-start waiters
+    // (CarPlay, Siri) blocked on the readiness gate rather than resolve them
+    // against an empty config.
+    if browserManager.isConfigured {
+      browserManager.config = browserManager.config.strippingJSCallbacks()
+    }
+    resolveGate = Self.defaultResolveGate
+    nowPlayingMetadataFormatter = nil
+  }
+
   deinit {
+    // Block-based notification observers are retained by the center until an
+    // explicit removeObserver — observer death isn't detected — so without this
+    // every JS reload strands another token + closure. They capture `self`
+    // weakly, so a stranded one no-ops rather than misbehaving; what accumulates
+    // is the tokens and a wasted main-queue dispatch per interruption / route
+    // change / media-services reset. (`volumeObservation` needs no counterpart:
+    // NSKeyValueObservation invalidates itself when this instance releases it.)
+    for observer in [interruptionObserver, routeChangeObserver, mediaServicesResetObserver]
+      .compactMap(\.self)
+    {
+      NotificationCenter.default.removeObserver(observer)
+    }
+
     // Safety net: ensure the AVPlayer is stopped if this instance is deallocated.
     let player = self.player
     if Thread.isMainThread {
@@ -447,8 +524,8 @@ public class HybridAudioBrowser: HybridAudioBrowserSpec, @unchecked Sendable {
         executePlayback(intent)
       case .intercepted:
         break
-      case let .browse(url):
-        navigateToBrowsableUrl(url)
+      case let .browse(path):
+        navigateToBrowsablePath(path)
       case .none:
         break
       }
@@ -472,13 +549,13 @@ public class HybridAudioBrowser: HybridAudioBrowserSpec, @unchecked Sendable {
     }
   }
 
-  private func navigateToBrowsableUrl(_ url: String) {
+  private func navigateToBrowsablePath(_ path: String) {
     clearNavigationError()
     Task {
       do {
-        try await browserManager.navigate(url)
+        try await browserManager.navigate(path)
       } catch {
-        handleNavigationError(error, path: url)
+        handleNavigationError(error, path: path)
       }
     }
   }
@@ -487,7 +564,7 @@ public class HybridAudioBrowser: HybridAudioBrowserSpec, @unchecked Sendable {
     Promise.async { [weak self] in
       guard let self else { return [] }
       let resolved = try await browserManager.search(query)
-      return resolved.children ?? []
+      return resolved.flattenedChildren ?? []
     }
   }
 
@@ -510,7 +587,9 @@ public class HybridAudioBrowser: HybridAudioBrowserSpec, @unchecked Sendable {
   static let invalidateAllSentinel = "__rnab_invalidate_all__"
 
   public func notifyContentChanged(path: String) throws {
-    onMainActor { browserManager.invalidateContentCache(path) }
+    // 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)
@@ -690,6 +769,16 @@ public class HybridAudioBrowser: HybridAudioBrowserSpec, @unchecked Sendable {
         guard let self else { return }
         self.applyAudioSessionCategory = applyCategory
 
+        // A re-setup REPLACES the player, so the outgoing one has to be torn down
+        // and un-published first. `TrackPlayer` has no deinit: dropping the
+        // reference alone would leave its AVPlayer and MPNowPlayingSession alive.
+        // And `playerAndConfiguredBrowser` holds the old player strongly — its
+        // `resolve` is a one-shot, so without the reset the gate would keep
+        // handing the dead player to the CarPlay controller and Siri intents,
+        // which both await it. No-op on first setup.
+        player?.destroy()
+        playerAndConfiguredBrowser.reset()
+
         // Create player with self as callbacks delegate
         player = TrackPlayer(callbacks: self)
 
@@ -739,11 +828,16 @@ public class HybridAudioBrowser: HybridAudioBrowserSpec, @unchecked Sendable {
           return await browserManager.resolveMediaUrl(src, track: track)
         }
 
-        // Configure artwork URL resolver for Now Playing (with size context)
+        // Configure artwork URL resolver for Now Playing (with size context). The
+        // `nowPlayingArtwork` config runs for EVERY playing track, id or not — an id-less track
+        // leaves any `{id}` token unfilled (resolveArtworkUrl warns and the request visibly
+        // 404s) rather than skipping the config.
         player?.nowPlayingUpdater.artworkUrlResolver = { [weak self] track, imageContext in
           guard let self else { return nil }
-          let perRoute = (track.id?.isEmpty == false) ? browserManager.config.nowPlayingArtwork : nil
-          return await browserManager.resolveArtworkUrl(track: track, perRouteConfig: perRoute, imageContext: imageContext)
+          return await browserManager.resolveArtworkUrl(
+            track: track, perRouteConfig: browserManager.config.nowPlayingArtwork,
+            imageContext: imageContext,
+          )
         }
 
         // Emit the JS `onNowPlayingChanged` event when the rendered text lines change. The updater
@@ -784,6 +878,13 @@ public class HybridAudioBrowser: HybridAudioBrowserSpec, @unchecked Sendable {
         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)
         playerAndConfiguredBrowser.check()
       }
@@ -813,9 +914,9 @@ public class HybridAudioBrowser: HybridAudioBrowserSpec, @unchecked Sendable {
       // Update stored options
       playerOptions.update(from: options)
 
-      // Propagate the favorite match mode to the browser so it can hydrate
+      // Propagate the favorite flag to the browser so it can hydrate
       // row hearts (the `favorite` capability is the single favoriting switch).
-      browserManager.setFavoriteMatch(playerOptions.capabilities.favoriteMatch)
+      browserManager.setFavoriteEnabled(playerOptions.capabilities.favoriteEnabled)
 
       // Apply remote commands to player
       applyRemoteCommands()
@@ -848,8 +949,16 @@ public class HybridAudioBrowser: HybridAudioBrowserSpec, @unchecked Sendable {
     onMainActor { playerOptions.toOptions() }
   }
 
+  /// 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 private var playbackIntervalEnabled = false
+
   public func setPlaybackIntervalEnabled(enabled: Bool) {
-    onMainActor { player?.setPlaybackIntervalEnabled(enabled) }
+    onMainActor {
+      playbackIntervalEnabled = enabled
+      player?.setPlaybackIntervalEnabled(enabled)
+    }
   }
 
   // MARK: - Playback Control
@@ -1063,24 +1172,25 @@ public class HybridAudioBrowser: HybridAudioBrowserSpec, @unchecked Sendable {
   }
 
   public func setActiveTrackFavorited(favorited: Bool) throws {
-    onMainActor {
-      guard let track = player?.currentTrack, let src = track.src else { return }
+    try onMainActor {
+      guard let track = player?.currentTrack, let identity = track.identity else { return }
       guard let index = player?.currentIndex, index >= 0 else { return }
-      // Optimistically reflect in the authoritative match set so the now-playing
-      // heart (hydrated from it in getActiveTrack) flips immediately; native
-      // reconciles to its canonical ids on the next setFavorites.
-      browserManager.setFavorited(src: src, favorited: favorited)
+      // Optimistically reflect in the authoritative favorite set so the
+      // now-playing heart (hydrated from it in getActiveTrack) flips
+      // immediately; the consumer reconciles to its canonical identities on
+      // the next setFavorites.
+      browserManager.setFavorited(identity: identity, favorited: favorited)
       let updatedTrack = track.copying(favorited: favorited)
+      // Hydration never overrides a caller-set `favorited`, so the queued
+      // track must itself carry the latest explicit value (as Android's tag
+      // swap and web's replaceTrack do).
+      try player?.replace(index, updatedTrack)
+      // The ONLY emit: a favorite toggle is an in-place mutation of the active
+      // track, not a transition — onPlaybackActiveTrackChanged stays
+      // transition-only, and the useActiveTrack / useQueue hooks subscribe to
+      // onFavoriteChanged themselves. Native surfaces (CarPlay heart) observe
+      // favoriteChangedEmitter / onFavoritesChanged directly.
       favoriteChangedEmitter.emit(FavoriteChangedEvent(track: updatedTrack, favorited: favorited))
-      // Fire active track changed so the now-playing heart + useActiveTrack() refresh.
-      let position = player?.currentTime ?? 0
-      activeTrackChangedEmitter.emit(PlaybackActiveTrackChangedEvent(
-        lastIndex: Double(index),
-        lastTrack: track,
-        lastPosition: position,
-        index: Double(index),
-        track: updatedTrack,
-      ))
     }
   }
 
@@ -1220,7 +1330,7 @@ public class HybridAudioBrowser: HybridAudioBrowserSpec, @unchecked Sendable {
       duration: track.duration,
       artwork: nowPlayingArtwork(for: track),
       description: track.description,
-      mediaId: track.src ?? track.url,
+      mediaId: track.src ?? track.path,
       genre: track.genre,
     )
   }
@@ -1233,7 +1343,7 @@ public class HybridAudioBrowser: HybridAudioBrowserSpec, @unchecked Sendable {
     // Classify a stall by connectivity so the formatter can show "No internet connection" vs
     // "Reconnecting…" without a separate read. nil while not stalled.
     let stalled: StallReason? =
-      player.isStalled ? (networkMonitor.getOnline() ? .buffering : .offline) : nil
+      player.isStalled ? (networkMonitor.isOnline ? .buffering : .offline) : nil
     player.nowPlayingUpdater.render(
       track: track,
       timedMetadata: latestTimedMetadata,
@@ -1249,7 +1359,9 @@ public class HybridAudioBrowser: HybridAudioBrowserSpec, @unchecked Sendable {
   // MARK: - Network
 
   public func getOnline() throws -> Bool {
-    networkMonitor.getOnline()
+    // No `onMainActor` hop: `isOnline` is lock-protected, so this stays a
+    // cheap read on the JS thread instead of blocking on the main queue.
+    networkMonitor.isOnline
   }
 
   // MARK: - System Volume
@@ -1429,11 +1541,9 @@ public class HybridAudioBrowser: HybridAudioBrowserSpec, @unchecked Sendable {
   public func openOutputPicker() throws {
     DispatchQueue.main.async { [weak self] in
       guard let self else { return }
-      guard let windowScene = UIApplication.shared.connectedScenes
-        .compactMap({ $0 as? UIWindowScene })
-        .first(where: { $0.activationState == .foregroundActive }),
-        let window = windowScene.windows.first(where: { $0.isKeyWindow }),
-        var topController = window.rootViewController
+      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
@@ -1809,14 +1919,25 @@ extension HybridAudioBrowser: TrackPlayerCallbacks {
           browser.showNowPlayingRequestedEmitter.emit(())
           completion(true)
         } else if let state = browser.playbackStateStore.load() {
-          browser.logger.info("resume: cold — restoring persisted track")
           let track = state.track.toNitro()
+          // The persisted track can carry `disabled` — it became unavailable
+          // after it was saved. A disabled track never plays, resumption
+          // included (Track.disabled).
+          if track.disabled == true {
+            browser.logger.info("resume: persisted track is disabled — refusing")
+            completion(false)
+            return
+          }
+          browser.logger.info("resume: cold — restoring persisted track")
+          // Repeat / shuffle / speed come back before the queue is built — see
+          // `restorePlaybackSettings(from:)` for why that ordering matters.
+          player.restorePlaybackSettings(from: state)
           let startMs = (track.live == true) ? nil : state.positionMs
           // Match Android resume: re-expand the full queue from the track's contextual
-          // URL (parent container → siblings + selected index). Fall back to the single
-          // track when the url isn't contextual or expansion fails.
-          if let url = state.track.url,
-             let expanded = try? await browser.browserManager.expandQueueFromContextualUrl(url)
+          // path (parent container → siblings + selected index). Fall back to the single
+          // track when the path isn't contextual or expansion fails.
+          if let path = state.track.path,
+             let expanded = try? await browser.browserManager.expandQueueFromContextualPath(path)
           {
             player.setQueue(expanded.tracks, initialIndex: expanded.selectedIndex, startPositionMs: startMs, playWhenReady: true)
           } else {

package/ios/Model/NitroTypeStubs.swift

@@ -30,18 +30,18 @@
 
   struct Track: Equatable {
     var id: String?
-    var url: String?
+    var path: String?
     var src: String?
+    var artwork: Variant_String_ArtworkVariants?
+    var artworkSource: ImageSource?
     var request: TrackRequest?
     var title: String = ""
     var artist: String?
-    var albumUrl: String?
+    var albumPath: String?
     var album: String?
+    var style: TrackStyle?
+    var disabled: Bool?
     var live: Bool?
-    var artwork: Variant_String_ArtworkVariants?
-    var artworkSource: ImageSource?
-    var groupTitle: String?
-    var imageRow: [ImageRowItem]?
   }
 
   struct TrackLoadEvent {
@@ -86,7 +86,7 @@
     var body: String?
   }
 
-  enum TrackStyle {
+  enum StyleDisplay: Equatable {
     case list
     case grid
 
@@ -99,17 +99,106 @@
     }
   }
 
-  struct ImageRowItem: Equatable {
-    var id: String?
-    var url: String?
-    var src: String?
-    var artwork: String?
-    var artworkSource: ImageSource?
-    var title: String
+  enum ArtworkRendering: Equatable {
+    case original
+    case stencil
+
+    init?(fromString string: String) {
+      switch string {
+      case "original": self = .original
+      case "stencil": self = .stencil
+      default: return nil
+      }
+    }
+  }
+
+  enum ImageShape: Equatable {
+    case circular
+    case roundedRectangle
+
+    init?(fromString string: String) {
+      switch string {
+      case "circular": self = .circular
+      case "rounded-rectangle": self = .roundedRectangle
+      default: return nil
+      }
+    }
+  }
+
+  enum GridTile: Equatable {
+    case plain
+    case card
+    case condensed
+
+    init?(fromString string: String) {
+      switch string {
+      case "plain": self = .plain
+      case "card": self = .card
+      case "condensed": self = .condensed
+      default: return nil
+      }
+    }
+
+    // Mirrors the generated extension (nitrogen emits `stringValue` beside
+    // `init?(fromString:)` for every string-backed enum).
+    var stringValue: String {
+      switch self {
+      case .plain: "plain"
+      case .card: "card"
+      case .condensed: "condensed"
+      }
+    }
+  }
+
+  enum CardImage: Equatable {
+    case normal
+    case background
+
+    init?(fromString string: String) {
+      switch string {
+      case "normal": self = .normal
+      case "background": self = .background
+      default: return nil
+      }
+    }
+  }
+
+  struct TrackStyle: Equatable {
+    var display: StyleDisplay?
+    var artworkRendering: ArtworkRendering?
+    var imageShape: ImageShape?
+    var accessorySymbol: String?
+    var cardTint: String?
+    var cardImage: CardImage?
+  }
+
+  // Member order matches the generated init (own properties before inherited
+  // ones — Nitro flattens `extends` own-props-first): the memberwise init this
+  // produces must accept the same argument order as the real type, or
+  // `swift test` passes while the app build breaks on argument order.
+  struct SectionStyle: Equatable {
+    var gridWrap: Bool?
+    var gridTile: GridTile?
+    var display: StyleDisplay?
+    var artworkRendering: ArtworkRendering?
+    var imageShape: ImageShape?
+    var accessorySymbol: String?
+    var cardTint: String?
+    var cardImage: CardImage?
+  }
+
+  struct Section: Equatable {
+    var title: String?
+    var subtitle: String?
+    var style: SectionStyle?
+    var path: String?
+    var children: [Track]
   }
 
   struct ResolvedTrack: Equatable {
-    var url: String
+    var path: String
+    var style: SectionStyle?
+    var sections: [Section]?
     var children: [Track]?
     var carPlaySiriListButton: CarPlaySiriListButtonPosition?
     var id: String?
@@ -117,21 +206,17 @@
     var artwork: Variant_String_ArtworkVariants?
     var artworkSource: ImageSource?
     var request: TrackRequest?
-    var artworkCarPlayTinted: Bool?
     var title: String
     var subtitle: String?
     var artist: String?
-    var albumUrl: String?
+    var albumPath: String?
     var album: String?
     var description: String?
     var genre: String?
     var duration: Double?
-    var style: TrackStyle?
-    var childrenStyle: TrackStyle?
+    var disabled: Bool?
     var favorited: Bool?
-    var groupTitle: String?
     var live: Bool?
-    var imageRow: [ImageRowItem]?
   }
 
   enum PlaybackState: Equatable {

package/ios/Model/PlayerUpdateOptions.swift

@@ -32,6 +32,9 @@ class PlayerUpdateOptions {
   /// Custom buttons for the CarPlay Now Playing screen
   var carPlayNowPlayingButtons: [CarPlayNowPlayingButton] = []
 
+  /// Where the now-playing indicator draws on CarPlay list rows
+  var carPlayPlayingIndicatorLocation: CarPlayPlayingIndicatorLocation = .leading
+
   // MARK: - Initialization
 
   init() {}
@@ -74,6 +77,9 @@ class PlayerUpdateOptions {
       if let buttons = ios.carPlayNowPlayingButtons {
         carPlayNowPlayingButtons = buttons
       }
+      if let location = ios.carPlayPlayingIndicatorLocation {
+        carPlayPlayingIndicatorLocation = location
+      }
     }
   }
 
@@ -92,6 +98,7 @@ class PlayerUpdateOptions {
         playbackRates: playbackRates,
         carPlayUpNextButton: carPlayUpNextButton,
         carPlayNowPlayingButtons: carPlayNowPlayingButtons,
+        carPlayPlayingIndicatorLocation: carPlayPlayingIndicatorLocation,
       ),
     )
   }

package/ios/Player/MediaIntentCriteria.swift

@@ -126,14 +126,22 @@ public struct MediaIntentCriteria: Sendable {
 
   /// Whether `query` is effectively the host app's own name. Case- and
   /// diacritic-insensitive.
+  ///
+  /// Whole-word subset match in either direction. Siri may deliver only part of
+  /// the name ("Name" for «App Name»), so a partial match must count — but a
+  /// substring match swallowed any query appearing inside the app name, making
+  /// one-word stations unreachable by voice.
   private static func queryMatchesAppName(_ query: String, appName: String?) -> Bool {
     guard let appName else { return false }
-    let normalize: (String) -> String = {
-      $0.folding(options: [.diacriticInsensitive, .caseInsensitive], locale: nil)
-        .trimmingCharacters(in: .whitespacesAndNewlines)
+    let tokens: (String) -> Set<String> = {
+      Set(
+        $0.folding(options: [.diacriticInsensitive, .caseInsensitive], locale: nil)
+          .split(whereSeparator: { !$0.isLetter && !$0.isNumber })
+          .map(String.init),
+      )
     }
-    let q = normalize(query), a = normalize(appName)
+    let q = tokens(query), a = tokens(appName)
     guard !q.isEmpty, !a.isEmpty else { return false }
-    return a.contains(q) || q.contains(a)
+    return q.isSubset(of: a) || a.isSubset(of: q)
   }
 }