react-native-audio-browser 0.1.1 → 0.2.0-next.2

package/ios/Browser/BrowserManager.swift

@@ -74,9 +74,19 @@ final class BrowserManager {
   private var lastSearchQuery: String?
   private var lastSearchResults: [Track]?
 
+  // Resolver caching: request/browse thunks resolve once per content generation.
+  private var layerGeneration = 0
+  private var resolvedLayerGeneration = -1
+  var resolvedRequestLayer: TransformableRequestConfig?
+  private var resolvedBrowseLayer: TransformableRequestConfig?
+
   // Set of favorited track identifiers (src)
   private var favoriteIds: Set<String> = []
 
+  // Favorite match mode, propagated from the player's `favorite` capability.
+  // nil = favoriting disabled (no row hearts). Set via setFavoriteMatch.
+  private var favoriteMatch: FavoritesMatchMode?
+
   // Navigation tracking to prevent race conditions
   private var currentNavigationId: Int = 0
 
@@ -99,7 +109,11 @@ final class BrowserManager {
 
   private(set) var tabs: [Track]? {
     didSet {
-      if let tabs {
+      // Emit only on a real change: invalidateAllContent() re-queries the tabs
+      // source on every invalidation (a callback source can re-resolve, e.g.
+      // titles in a new locale), and an unchanged result must not churn the
+      // CarPlay tab bar or reset its selection.
+      if let tabs, !TabBarEntries.same(oldValue, tabs) {
         onTabsChanged?(tabs)
       }
     }
@@ -114,6 +128,8 @@ final class BrowserManager {
   var config: BrowserConfig = .init() {
     didSet {
       isConfigured = true
+      // New config means the cached resolver results are stale.
+      layerGeneration += 1
       onConfigChanged?(config)
     }
   }
@@ -124,6 +140,11 @@ final class BrowserManager {
   var onContentChanged: ((ResolvedTrack?) -> Void)?
   var onTabsChanged: (([Track]) -> Void)?
   var onConfigChanged: ((BrowserConfig) -> Void)?
+  /// Fired when the favorite id set changes (e.g. an app/webview-originated
+  /// favorite). Lets surfaces like the CarPlay now-playing heart re-render —
+  /// they otherwise only learn of their own toggles via favorite/active-track
+  /// events, never an external change routed through `setFavorites`.
+  var onFavoritesChanged: (() -> Void)?
 
   /// Forwards to config.awaitTrackLoadHandler so callers don't need to
   /// cross the MainActor boundary to access `config`.
@@ -138,25 +159,46 @@ final class BrowserManager {
 
   /// Sets the favorited track identifiers.
   func setFavorites(_ favorites: [String]) {
-    favoriteIds = Set(favorites)
+    let newIds = Set(favorites)
+    guard newIds != favoriteIds else { return }
+    favoriteIds = newIds
+    onFavoritesChanged?()
   }
 
-  /// Updates the favorite state for a single track identifier.
-  func updateFavorite(id: String, favorited: Bool) {
+  /// Sets the favorite match mode (propagated from the `favorite` capability).
+  /// nil disables row-heart hydration.
+  func setFavoriteMatch(_ match: FavoritesMatchMode?) {
+    favoriteMatch = match
+  }
+
+  /// Optimistically reflects a local favorite toggle for `src` in the match set,
+  /// needing no consumer-specific id extraction: favoriting inserts `src` (which
+  /// matches itself under either mode). Removal mirrors `isFavorite`'s match
+  /// semantics — partial drops every id that is a path segment of `src` (the
+  /// channel uid, and self-heals stray ids); exact (or disabled) drops only
+  /// `src`, so unrelated exact favorites that happen to be a segment of `src`
+  /// aren't collaterally lost. The consumer reconciles `favoriteIds` to its
+  /// canonical ids on the next `setFavorites`; `isFavorite(src:)` gives the same
+  /// answer before and after, so the now-playing heart stays responsive.
+  func setFavorited(src: String, favorited: Bool) {
     if favorited {
-      favoriteIds.insert(id)
+      favoriteIds.insert(src)
+    } else if favoriteMatch == .partial {
+      favoriteIds = favoriteIds.filter { !BrowserPathHelper.containsSegment(src, $0) }
     } else {
-      favoriteIds.remove(id)
+      favoriteIds.remove(src)
     }
   }
 
   /// Hydrates the favorited field on a track based on the favoriteIds set.
-  /// Local favoriteIds always take precedence over API-provided values.
-  private func hydrateFavorite(_ track: Track) -> Track {
-    guard let src = track.src else { return track }
+  /// No-op unless favoriting is enabled (the `favorite` capability). Only
+  /// playable (src-bearing) tracks are favoritable; the flag is set to true OR
+  /// false so non-favorited tracks still show an (empty) heart. Local
+  /// favoriteIds take precedence over API-provided values.
+  func hydrateFavorite(_ track: Track) -> Track {
+    guard let match = favoriteMatch, let src = track.src else { return track }
 
-    // Check if this track is in our local favorites set
-    let isFavorited = favoriteIds.contains(src)
+    let isFavorited = isFavorite(src: src, match: match)
 
     // Only create a new track if the favorited state differs
     if track.favorited == isFavorited { return track }
@@ -164,6 +206,16 @@ final class BrowserManager {
     return track.copying(favorited: isFavorited)
   }
 
+  /// Whether `src` is favorited under the given match mode.
+  private func isFavorite(src: String, match: FavoritesMatchMode) -> Bool {
+    switch match {
+    case .exact:
+      favoriteIds.contains(src)
+    case .partial:
+      favoriteIds.contains { BrowserPathHelper.containsSegment(src, $0) }
+    }
+  }
+
   /// Hydrates favorites on all children of a ResolvedTrack.
   private func hydrateChildren(_ resolvedTrack: ResolvedTrack) -> ResolvedTrack {
     guard let children = resolvedTrack.children else { return resolvedTrack }
@@ -187,23 +239,6 @@ final class BrowserManager {
     resolvedTrack.children?.forEach { cacheTrack($0) }
   }
 
-  /// Get a cached Track by mediaId (url or src), or nil if not cached.
-  func getCachedTrack(_ mediaId: String) -> Track? {
-    // Try direct lookup first (matches url or src)
-    if let track = trackCache.get(mediaId) {
-      return hydrateFavorite(track)
-    }
-
-    // Try extracting src from contextual URL
-    if let trackId = BrowserPathHelper.extractTrackId(mediaId) {
-      if let track = trackCache.get(trackId) {
-        return hydrateFavorite(track)
-      }
-    }
-
-    return nil
-  }
-
   // MARK: - Navigation
 
   /// Main navigation method - updates path and resolves content.
@@ -252,6 +287,13 @@ final class BrowserManager {
     contentCache.remove(path)
   }
 
+  /// Clears the entire content cache (e.g. on a locale change).
+  /// Runs from `invalidateAllContent`, so re-resolve the layer thunks too.
+  func clearContentCache() {
+    contentCache.clear()
+    layerGeneration += 1
+  }
+
   /// Refreshes the current path by invalidating cache and re-resolving.
   ///
   /// Uses navigation ID tracking to prevent race conditions.
@@ -271,21 +313,24 @@ final class BrowserManager {
   }
 
   private func resolveUncached(_ path: String) async throws -> ResolvedTrack {
-    guard let routes = config.routes, !routes.isEmpty else {
-      throw BrowserError.contentNotFound(path: path)
-    }
+    // Match an explicit route (or the '*' default). With no match, fall back to
+    // the implicit default: fetch the path via the request + browse config.
+    let routeEntry = (config.routes).flatMap { findBestRouteMatch(path: path, routes: $0) }
 
-    // Find best matching route
-    guard let (routeEntry, routeMatch) = findBestRouteMatch(path: path, routes: routes) else {
-      throw BrowserError.contentNotFound(path: path)
+    let resolvedTrack: ResolvedTrack = if let (entry, routeMatch) = routeEntry {
+      try await resolveRouteEntry(entry, path: path, params: routeMatch.params)
+    } else {
+      // Implicit default — no route config, just request → browse → fetch path.
+      try await resolveFromConfig(
+        nil, path: path, params: ["path": path],
+      )
     }
 
-    // Resolve the track from the route
-    let resolvedTrack = try await resolveRouteEntry(routeEntry, path: path, params: routeMatch.params)
-
     // Validate and transform children
     if let children = resolvedTrack.children {
-      let transformed = try await transformChildren(children, parentPath: path, routeEntry: routeEntry)
+      let transformed = try await transformChildren(
+        children, parentPath: path, routeEntry: routeEntry?.0,
+      )
       return resolvedTrack.copying(children: transformed)
     }
 
@@ -326,21 +371,29 @@ final class BrowserManager {
     // Priority: callback > config > static
     if let callback = entry.browseCallback {
       let callbackParam = BrowserSourceCallbackParam(path: path, routeParams: params)
-      let outerPromise = callback(callbackParam)
-      let innerPromise = try await outerPromise.await()
-      let result = try await innerPromise.await()
-
-      // Handle the BrowseResult union type
-      switch result {
+      // BrowserSourceCallback may return a BrowseResult synchronously or via a
+      // Promise. Nitro flattens (ResolvedTrack | BrowseError) | Promise<BrowseResult>
+      // into a 3-arm variant: sync track, sync error, or a Promise resolving to a
+      // BrowseResult (which is itself a ResolvedTrack | BrowseError variant).
+      switch try await callback(callbackParam).await() {
       case let .first(resolvedTrack):
         return resolvedTrack
       case let .second(browseError):
         throw BrowserError.callbackError(browseError.error)
+      case let .third(promise):
+        switch try await promise.await() {
+        case let .first(resolvedTrack):
+          return resolvedTrack
+        case let .second(browseError):
+          throw BrowserError.callbackError(browseError.error)
+        }
       }
     }
 
     if let browseConfig = entry.browseConfig {
-      return try await resolveFromConfig(browseConfig, path: path, params: params)
+      return try await resolveFromConfig(
+        browseConfig, path: path, params: params,
+      )
     }
 
     if let staticContent = entry.browseStatic {
@@ -350,37 +403,68 @@ final class BrowserManager {
     throw BrowserError.contentNotFound(path: path)
   }
 
-  private func resolveFromConfig(
-    _ routeConfig: TransformableRequestConfig,
+  /// Builds the HTTP request for an API-backed route by layering
+  /// request → kind → route configs. `initialQuery` seeds request-level query
+  /// params (e.g. search q/mode/…) onto the base before the route layer, so they
+  /// survive into `request.query` even when a layer's transform "wins
+  /// completely" (it is handed only the base, so the route config's own static
+  /// query would otherwise be dropped). `routeConfig` is nil for the implicit
+  /// browse default; `kindConfig` is nil for kinds with no per-kind config.
+  private func buildApiRequest(
+    kind kindConfig: TransformableRequestConfig?,
+    _ routeConfig: TransformableRequestConfig?,
     path: String,
-    params _: [String: String],
-  ) async throws -> ResolvedTrack {
-    // Build the request URL - route config takes precedence over global config
-    let baseUrl = routeConfig.baseUrl ?? config.request?.baseUrl
-    guard let baseUrl else {
-      throw BrowserError.invalidConfiguration("No URL configured for route")
-    }
+    params: [String: String],
+    initialQuery: [String: String]? = nil,
+  ) async throws -> HttpClient.HttpRequest {
+    try await ensureLayersResolved()
 
-    var url = BrowserPathHelper.buildUrl(baseUrl: baseUrl, path: path)
+    var merged = RequestConfig(
+      method: nil, path: path, baseUrl: nil, headers: nil,
+      query: nil, body: nil, contentType: nil, userAgent: nil,
+    )
+    merged = try await applyLayer(resolvedRequestLayer, to: merged, params: params)
+    if let initialQuery, !initialQuery.isEmpty {
+      merged = merged.copying(query: mergeDicts(merged.query, initialQuery))
+    }
+    merged = try await applyLayer(kindConfig, to: merged, params: params)
+    merged = try await applyLayer(routeConfig, to: merged, params: params)
 
-    // Add query parameters from config - route config values override global config
-    if let queryParams = mergeDicts(config.request?.query, routeConfig.query) {
-      url = BrowserPathHelper.appendQuery(queryParams, to: url)
+    guard let baseUrl = merged.baseUrl else {
+      throw BrowserError.invalidConfiguration("No URL configured for route")
+    }
+    var url = BrowserPathHelper.buildUrl(baseUrl: baseUrl, path: merged.path ?? path)
+    if let query = merged.query, !query.isEmpty {
+      url = BrowserPathHelper.appendQuery(query, to: url)
     }
 
-    // Build HTTP request - route config takes precedence
-    let method = (routeConfig.method ?? config.request?.method)?.stringValue ?? "GET"
-    let request = HttpClient.HttpRequest(
+    return HttpClient.HttpRequest(
       url: url,
-      method: method,
-      headers: mergeDicts(config.request?.headers, routeConfig.headers),
+      method: merged.method?.stringValue ?? "GET",
+      headers: merged.headers,
+      body: merged.body,
+      contentType: merged.contentType ?? HttpClient.defaultContentType,
+      userAgent: merged.userAgent ?? HttpClient.defaultUserAgent,
+    )
+  }
+
+  /// Resolves a browse route: a page object (`{title,url,children:[…]}`).
+  /// The browse kind layer is the cached resolved layer (`resolvedBrowseLayer`),
+  /// populated by `ensureLayersResolved()` inside `buildApiRequest`.
+  private func resolveFromConfig(
+    _ routeConfig: TransformableRequestConfig?,
+    path: String,
+    params: [String: String],
+  ) async throws -> ResolvedTrack {
+    try await ensureLayersResolved()
+    let request = try await buildApiRequest(
+      kind: resolvedBrowseLayer, routeConfig, path: path, params: params,
     )
 
     logger.debug("Resolving content from API")
     logger.debug("  path: \(path)")
-    logger.debug("  url: \(url)")
+    logger.debug("  url: \(request.url)")
 
-    // Execute request
     let result: JsonResolvedTrack = try await httpClient.requestJson(request, as: JsonResolvedTrack.self)
     let nitroResult = result.toNitro()
 
@@ -392,14 +476,73 @@ final class BrowserManager {
     return nitroResult
   }
 
+  /// Applies one request-config layer (request / browse / route) onto a base.
+  /// A transform (async and/or sync) wins completely: it receives the base and its
+  /// result replaces it. When both are set they run as a pipeline — async first,
+  /// then sync. Otherwise the layer's static fields merge over the base. `path` is
+  /// carried from the base (only a transform may change it).
+  func applyLayer(
+    _ layer: TransformableRequestConfig?,
+    to base: RequestConfig,
+    params: [String: String],
+  ) async throws -> RequestConfig {
+    guard let layer else { return base }
+    // Run-both transform: async first, then sync (each replaces the running config).
+    // The bridge await depth — the bug-prone part — is centralised in awaitAsync/SyncConfig.
+    if layer.transform != nil || layer.transformSync != nil {
+      var result = base
+      if let transform = layer.transform { result = try await awaitAsyncConfig(transform(result, params)) }
+      if let transformSync = layer.transformSync { result = try await awaitSyncConfig(transformSync(result, params)) }
+      return result
+    }
+    return RequestConfig(
+      method: layer.method ?? base.method,
+      path: base.path,
+      baseUrl: layer.baseUrl ?? base.baseUrl,
+      headers: mergeDicts(base.headers, layer.headers),
+      query: mergeDicts(base.query, layer.query),
+      body: layer.body ?? base.body,
+      contentType: layer.contentType ?? base.contentType,
+      userAgent: layer.userAgent ?? base.userAgent,
+    )
+  }
+
   /// Merges two optional dictionaries, with override values taking precedence.
+  /// Delegates to the pure, unit-tested `MediaResolveComposer.mergeDicts`.
   func mergeDicts(
     _ base: [String: String]?,
     _ override: [String: String]?,
   ) -> [String: String]? {
-    guard let base else { return override }
-    guard let override else { return base }
-    return base.merging(override) { _, new in new }
+    MediaResolveComposer.mergeDicts(base, override)
+  }
+
+  // MARK: - Layer Resolvers
+
+  /// Resolve one layer: invoke its resolver if present, else return the static
+  /// layer config unchanged. The resolver is Promise-only (the TS layer wraps a
+  /// sync-or-async thunk in Promise.resolve), so its result is the JS promise
+  /// behind the bridge promise — a double await.
+  private func resolveLayer(
+    config staticConfig: TransformableRequestConfig?,
+    resolver: (() -> Promise<Promise<TransformableRequestConfig>>)?,
+  ) async throws -> TransformableRequestConfig? {
+    guard let resolver else { return staticConfig }
+    return try await resolver().await().await()
+  }
+
+  /// Ensure request/browse resolvers are resolved for the current generation,
+  /// caching the results. Re-resolves after a generation bump (config change /
+  /// invalidateAllContent). Idempotent within a generation.
+  func ensureLayersResolved() async throws {
+    guard resolvedLayerGeneration != layerGeneration else { return }
+    let generation = layerGeneration
+    let req = try await resolveLayer(config: config.request, resolver: config.requestResolver)
+    let brw = try await resolveLayer(config: config.browse, resolver: config.browseResolver)
+    // Only commit if still current (a newer generation may have started during await).
+    guard generation == layerGeneration else { return }
+    resolvedRequestLayer = req
+    resolvedBrowseLayer = brw
+    resolvedLayerGeneration = generation
   }
 
   // MARK: - Child Transformation
@@ -407,13 +550,15 @@ final class BrowserManager {
   private func transformChildren(
     _ children: [Track],
     parentPath: String,
-    routeEntry: NativeRouteEntry,
+    routeEntry: NativeRouteEntry?,
   ) async throws -> [Track] {
     var transformed: [Track] = []
 
     for track in children {
-      // Validate track has stable identifier
-      if track.url == nil, track.src == nil {
+      // Validate track has stable identifier. A track carrying an imageRow is
+      // exempt: a url-less row is a pure preview — never selected, navigated
+      // to, or cached (its items carry their own identity).
+      if track.url == nil, track.src == nil, track.imageRow?.isEmpty != false {
         throw BrowserError.invalidConfiguration(
           "Track must have either 'url' or 'src' for stable identification: \(track.title)",
         )
@@ -427,7 +572,7 @@ final class BrowserManager {
       }
 
       // Resolve artwork URL at browse-time (no size context)
-      let artworkConfig = routeEntry.artwork ?? config.artwork
+      let artworkConfig = routeEntry?.artwork ?? config.artwork
       if let imageSource = await resolveArtworkUrl(track: transformedTrack, perRouteConfig: artworkConfig) {
         transformedTrack = transformedTrack.copying(artworkSource: imageSource)
       }
@@ -436,32 +581,25 @@ final class BrowserManager {
       if let imageRowItems = transformedTrack.imageRow {
         var resolvedItems: [ImageRowItem] = []
         for item in imageRowItems {
-          let itemTrack = Track(
-            url: item.url,
-            src: nil,
-            artwork: item.artwork,
-            artworkSource: nil,
-            artworkCarPlayTinted: nil,
-            title: item.title,
-            subtitle: nil,
-            artist: nil,
-            album: nil,
-            description: nil,
-            genre: nil,
-            duration: nil,
-            style: nil,
-            childrenStyle: nil,
-            favorited: nil,
-            groupTitle: nil,
-            live: nil,
-            imageRow: nil,
-          )
-          let itemImageSource = await resolveArtworkUrl(track: itemTrack, perRouteConfig: artworkConfig)
+          let itemImageSource = await resolveArtworkUrl(track: item.toTrack(), perRouteConfig: artworkConfig)
+          // Playable items get a contextual URL like any list row, so a
+          // thumbnail tap expands into its section's queue instead of a
+          // queue of one (ADR 0006).
+          let itemUrl = item.url ?? item.src.map {
+            BrowserPathHelper.build(parentPath: parentPath, trackId: $0)
+          }
           resolvedItems.append(ImageRowItem(
-            url: item.url,
+            id: item.id,
+            url: itemUrl,
+            src: item.src,
             artwork: item.artwork,
             artworkSource: itemImageSource,
             title: item.title,
+            artist: item.artist,
+            album: item.album,
+            albumUrl: item.albumUrl,
+            live: item.live,
+            request: item.request,
           ))
         }
         transformedTrack = transformedTrack.copying(imageRow: resolvedItems)
@@ -476,7 +614,19 @@ final class BrowserManager {
   // MARK: - Search
 
   /// Execute a search query.
+  /// Plain free-text search — wraps the structured overload with no mode/filters.
   func search(_ query: String) async throws -> ResolvedTrack {
+    try await search(
+      SearchParams(mode: nil, query: query, genre: nil, artist: nil, album: nil, title: nil, playlist: nil, reference: .unknown),
+    )
+  }
+
+  /// Structured search. Emits `q` plus any of `mode`/`genre`/`artist`/`album`/
+  /// `title`/`playlist` that are set, mirroring Android's `executeSearchApiRequest`
+  /// and the web stub. Cached by `query`.
+  func search(_ params: SearchParams) async throws -> ResolvedTrack {
+    let query = params.query
+
     // Check cache - re-hydrate favorites since they may have changed
     if query == lastSearchQuery, let results = lastSearchResults {
       let hydratedResults = results.map { hydrateFavorite($0) }
@@ -491,25 +641,36 @@ final class BrowserManager {
       throw BrowserError.contentNotFound(path: Self.searchRoutePath)
     }
 
-    let searchParams = SearchParams(
-      mode: nil,
-      query: query,
-      genre: nil,
-      artist: nil,
-      album: nil,
-      title: nil,
-      playlist: nil,
-    )
-
     var results: [Track]
 
     if let callback = searchEntry.searchCallback {
-      let outerPromise = callback(searchParams)
+      let outerPromise = callback(params)
       let innerPromise = try await outerPromise.await()
       results = try await innerPromise.await()
     } else if let searchConfig = searchEntry.searchConfig {
-      let resolved = try await resolveFromConfig(searchConfig, path: "/__search", params: ["q": query])
-      results = resolved.children ?? []
+      // Search is its own kind — request → search route (no browse layer). The
+      // endpoint returns a bare Track array (unlike browse's page object). The
+      // search params go through `initialQuery` so they land in `request.query`
+      // (and the URL); a config with a transform only ever sees the base.
+      // Seed the search config's static path onto the base — a layer's static
+      // path never applies (carried from the base; only a transform may change
+      // it). Matches the web stub's fetchSearchResults and Android.
+      var queryParams: [String: String] = ["q": query]
+      if let mode = params.mode { queryParams["mode"] = mode.stringValue }
+      if params.reference == .my { queryParams["reference"] = "my" }
+      if let genre = params.genre { queryParams["genre"] = genre }
+      if let artist = params.artist { queryParams["artist"] = artist }
+      if let album = params.album { queryParams["album"] = album }
+      if let title = params.title { queryParams["title"] = title }
+      if let playlist = params.playlist { queryParams["playlist"] = playlist }
+
+      let request = try await buildApiRequest(
+        kind: nil, searchConfig, path: searchConfig.path ?? "", params: ["q": query],
+        initialQuery: queryParams,
+      )
+      logger.debug("Searching via API: \(request.url)")
+      let jsonTracks: [JsonTrack] = try await httpClient.requestJson(request, as: [JsonTrack].self)
+      results = jsonTracks.map { $0.toNitro() }
     } else {
       throw BrowserError.contentNotFound(path: Self.searchRoutePath)
     }
@@ -527,18 +688,32 @@ final class BrowserManager {
     return makeSearchResult(query: query, results: hydratedResults)
   }
 
+  /// Search and return playable tracks for "play «X»" voice intents, drilling
+  /// into a browsable-only first result (place/genre page) so we play its first
+  /// station. Decision in `SearchDrillIn.playable`; mirrors Android's
+  /// `searchPlayable`.
+  func searchPlayable(_ params: SearchParams) async throws -> [Track]? {
+    let children = try await (search(params).children) ?? []
+    return try await SearchDrillIn.playable(from: children) { [self] url in
+      logger.debug("First search result is browsable-only, resolving: \(url)")
+      return try await (resolve(url).children) ?? []
+    }
+  }
+
   private func makeSearchResult(query: String, results: [Track]) -> ResolvedTrack {
     ResolvedTrack(
       url: BrowserPathHelper.createSearchPath(query),
       children: results,
       carPlaySiriListButton: nil,
+      id: nil,
       src: nil,
       artwork: nil,
-      artworkSource: nil,
+      artworkSource: nil, request: nil,
       artworkCarPlayTinted: nil,
       title: "Search: \(query)",
       subtitle: nil,
       artist: nil,
+      albumUrl: nil,
       album: nil,
       description: nil,
       genre: nil,
@@ -589,8 +764,22 @@ final class BrowserManager {
     let resolved = try await resolve(parentPath, useCache: true)
     guard let children = resolved.children else { return nil }
 
+    // Queue scope is the tapped section, not the whole page (ADR 0006). An
+    // id that no longer appears on the page aborts the expansion — the
+    // caller falls back to the stored single track (matching Android);
+    // silently queueing the changed list would resume the wrong station.
+    let sectionTracks: [Track]
+    switch SectionScope.section(of: children, containing: trackId) {
+    case .imageRow(let items):
+      sectionTracks = items.map { $0.toTrack() }
+    case .run(let tracks):
+      sectionTracks = tracks
+    case nil:
+      return nil
+    }
+
     // Filter to playable tracks (have src)
-    let playableTracks = children.filter { $0.src != nil }
+    let playableTracks = sectionTracks.filter { $0.src != nil }
     guard !playableTracks.isEmpty else { return nil }
 
     logger.debug("Found \(playableTracks.count) playable tracks")
@@ -599,7 +788,11 @@ final class BrowserManager {
     }
 
     // Find selected track index
-    let selectedIndex = playableTracks.firstIndex { $0.src == trackId } ?? 0
+    // Unreachable in practice (the section was found BY this id), but a miss
+    // must abort rather than silently start the queue at the wrong track.
+    guard let selectedIndex = playableTracks.firstIndex(where: { $0.src == trackId }) else {
+      return nil
+    }
     logger.debug("Selected track index: \(selectedIndex)")
 
     // If singleTrack mode, return just the selected track

package/ios/Browser/BrowserPathHelper.swift

@@ -173,18 +173,47 @@ enum BrowserPathHelper {
       return path
     }
 
-    // Ensure baseUrl ends with / and path doesn't start with /
+    // Strip trailing slashes from the base and leading slashes from the path so
+    // they join with exactly one separator.
     var normalizedBase = baseUrl
     while normalizedBase.hasSuffix("/") {
       normalizedBase.removeLast()
     }
-    normalizedBase += "/"
 
     var normalizedPath = path
     while normalizedPath.hasPrefix("/") {
       normalizedPath.removeFirst()
     }
 
-    return "\(normalizedBase)\(normalizedPath)"
+    // Empty path → the base IS the full URL (e.g. a search endpoint whose
+    // baseUrl already includes the path); don't leave a dangling trailing slash.
+    if normalizedPath.isEmpty {
+      return normalizedBase
+    }
+
+    return "\(normalizedBase)/\(normalizedPath)"
+  }
+
+  /// True if `segment` appears in `path` as a complete path segment — bounded on
+  /// the left by the string start or `/`, and on the right by the string end or
+  /// one of `/`, `?`, `#`.
+  static func containsSegment(_ path: String, _ segment: String) -> Bool {
+    guard !segment.isEmpty else { return false }
+    var searchStart = path.startIndex
+    while let range = path.range(of: segment, range: searchStart ..< path.endIndex) {
+      let beforeOk =
+        range.lowerBound == path.startIndex
+          || path[path.index(before: range.lowerBound)] == "/"
+      let afterOk: Bool
+      if range.upperBound == path.endIndex {
+        afterOk = true
+      } else {
+        let next = path[range.upperBound]
+        afterOk = next == "/" || next == "?" || next == "#"
+      }
+      if beforeOk, afterOk { return true }
+      searchStart = range.upperBound
+    }
+    return false
   }
 }