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

package/ios/Tests/FavoriteSetTests.swift

@@ -0,0 +1,60 @@
+import Testing
+
+@testable import AudioBrowserTestable
+
+struct FavoriteSetTests {
+  private func favorites(_ identities: [String], enabled: Bool = true) -> FavoriteSet {
+    var set = FavoriteSet()
+    set.enabled = enabled
+    _ = set.replace(with: identities)
+    return set
+  }
+
+  @Test func replaceReportsWhetherTheIdentitiesChanged() {
+    var set = FavoriteSet()
+    let changes = [["a", "b"], ["b", "a"], ["a", "b", "a"], []].map { set.replace(with: $0) }
+    #expect(changes == [true, false, false, true])
+  }
+
+  @Test func hydratesTrueOrFalseByIdentity() {
+    let set = favorites(["a", "stable"])
+    #expect(set.hydrate(Track(src: "a")).favorited == true)
+    #expect(set.hydrate(Track(src: "b")).favorited == false)
+    #expect(set.hydrate(Track(id: "stable", src: "x")).favorited == true)
+    #expect(set.hydrate(Track(id: "other", src: "a")).favorited == false)
+  }
+
+  @Test func leavesATrackAloneWhenDisabled() {
+    #expect(favorites(["a"], enabled: false).hydrate(Track(src: "a")).favorited == nil)
+  }
+
+  @Test func leavesATrackWithoutIdentityAlone() {
+    #expect(favorites(["a"]).hydrate(Track(path: "/browse")).favorited == nil)
+  }
+
+  @Test func aFavoritedTheTrackCarriesWins() {
+    let set = favorites(["a"])
+    #expect(set.hydrate(Track(src: "a", favorited: false)).favorited == false)
+    #expect(set.hydrate(Track(src: "b", favorited: true)).favorited == true)
+  }
+
+  @Test func aLocalToggleHoldsUntilTheNextReplace() {
+    var set = favorites(["a"])
+    set.set("b", favorited: true)
+    set.set("a", favorited: false)
+    #expect(set.hydrate(Track(src: "a")).favorited == false)
+    #expect(set.hydrate(Track(src: "b")).favorited == true)
+    _ = set.replace(with: ["a"])
+    #expect(set.hydrate(Track(src: "b")).favorited == false)
+  }
+
+  @Test func hydratesEverySectionOfAPage() {
+    let page = ResolvedTrack(
+      path: "/p",
+      sections: [Section(children: [Track(src: "a")]), Section(children: [Track(src: "b")])],
+      title: "P",
+    )
+    let hydrated = favorites(["b"]).hydrate(page)
+    #expect(hydrated.sections?.map { $0.children.map(\.favorited) } == [[false], [true]])
+  }
+}

package/ios/Tests/PlayerPolicyTests.swift

@@ -177,18 +177,42 @@ struct PlayerRecoveringTests {
     let (player, engine, _) = makePlaying()
     player.transition(.avPlayerWaiting)
     #expect(player.state == .buffering)
-    player.networkDidReturn()
+    player.networkStatusDidChange(isOnline: true)
     #expect(engine.resolveAndLoadCalls.count == 2)
   }
 
   @Test func theNetworkReturningLeavesAPausedOrPlayingStreamAlone() {
     let (player, engine, _) = makePlaying()
-    player.networkDidReturn()
+    player.networkStatusDidChange(isOnline: true)
     player.pause()
-    player.networkDidReturn()
+    player.networkStatusDidChange(isOnline: true)
     #expect(engine.resolveAndLoadCalls.count == 1)
   }
 
+  @Test func theNetworkGoingReRendersTheStallLineWithoutReconnecting() {
+    let (player, engine, _) = makePlaying()
+    player.transition(.avPlayerWaiting)
+    engine.nowPlayingRenderCount = 0
+
+    player.networkStatusDidChange(isOnline: false)
+
+    #expect(engine.nowPlayingRenderCount == 1)
+    #expect(engine.resolveAndLoadCalls.count == 1)
+  }
+
+  @Test func theNetworkReturningReRendersBeforeReconnecting() {
+    let (player, engine, _) = makePlaying()
+    player.transition(.avPlayerWaiting)
+    var order: [String] = []
+    engine.onSeamCall = { order.append($0) }
+    let loadsBefore = engine.resolveAndLoadCalls.count
+
+    player.networkStatusDidChange(isOnline: true)
+
+    #expect(order.first == "renderNowPlaying")
+    #expect(engine.resolveAndLoadCalls.count == loadsBefore + 1)
+  }
+
   /// A restart from a terminal error is a new Load: fresh retry budgets, unproven playback, the
   /// primer allowed again; a retry within a Load keeps its Load.
   @Test func aRestartFromAnErrorBeginsANewLoad() async {

package/ios/Tests/PlayerTests.swift

@@ -681,13 +681,13 @@ struct NaturalEndPlayIntentTests {
 
   @Test @MainActor
   func naturalEnd_requestsSessionRelease() {
-    let (c, eh, callbacks, _) = makeCoordinator()
+    let (c, eh, _, _) = makeCoordinator()
     startPlaying(c, eh)
-    callbacks.releaseSessionCount = 0
+    eh.scheduleAudioSessionReleaseCount = 0
 
     eh.emit(.playedToEnd)
 
-    #expect(callbacks.releaseSessionCount == 1)
+    #expect(eh.scheduleAudioSessionReleaseCount == 1)
   }
 
   /// play() from .ended must reload from the start — startPlayback() alone is a
@@ -1272,48 +1272,126 @@ struct StopCancelsRetryTests {
 struct SessionReleaseTests {
   @Test @MainActor
   func deliberatePause_requestsRelease() {
-    let (c, eh, callbacks, _) = makeCoordinator()
+    let (c, eh, _, _) = makeCoordinator()
     startPlaying(c, eh)
-    callbacks.releaseSessionCount = 0
+    eh.scheduleAudioSessionReleaseCount = 0
     c.pause()
-    #expect(callbacks.releaseSessionCount == 1)
+    #expect(eh.scheduleAudioSessionReleaseCount == 1)
   }
 
   @Test @MainActor
   func play_doesNotRequestRelease() {
-    let (c, eh, callbacks, _) = makeCoordinator()
+    let (c, eh, _, _) = makeCoordinator()
     startPlaying(c, eh)
-    #expect(callbacks.releaseSessionCount == 0)
+    #expect(eh.scheduleAudioSessionReleaseCount == 0)
   }
 
   @Test @MainActor
   func interruptionBegan_doesNotRequestRelease() {
     // A phone call pauses (playWhenReady → false) but is meant to resume, so the session must be
     // held — the exact race the intent-gating design exists to avoid.
-    let (c, eh, callbacks, _) = makeCoordinator()
+    let (c, eh, _, _) = makeCoordinator()
     startPlaying(c, eh)
-    callbacks.releaseSessionCount = 0
+    eh.scheduleAudioSessionReleaseCount = 0
     c.handleInterruptionBegan()
-    #expect(callbacks.releaseSessionCount == 0)
+    #expect(eh.scheduleAudioSessionReleaseCount == 0)
   }
 
   @Test @MainActor
   func interruptionEnded_withResume_doesNotRequestRelease() {
-    let (c, eh, callbacks, _) = makeCoordinator()
+    let (c, eh, _, _) = makeCoordinator()
     startPlaying(c, eh)
     c.handleInterruptionBegan()
-    callbacks.releaseSessionCount = 0
+    eh.scheduleAudioSessionReleaseCount = 0
     c.handleInterruptionEnded(shouldResume: true)
-    #expect(callbacks.releaseSessionCount == 0)
+    #expect(eh.scheduleAudioSessionReleaseCount == 0)
   }
 
   @Test @MainActor
   func interruptionEnded_withoutResume_requestsRelease() {
-    let (c, eh, callbacks, _) = makeCoordinator()
+    let (c, eh, _, _) = makeCoordinator()
     startPlaying(c, eh)
     c.handleInterruptionBegan()
-    callbacks.releaseSessionCount = 0
+    eh.scheduleAudioSessionReleaseCount = 0
     c.handleInterruptionEnded(shouldResume: false)
-    #expect(callbacks.releaseSessionCount == 1)
+    #expect(eh.scheduleAudioSessionReleaseCount == 1)
+  }
+}
+
+// MARK: - Media-stack effects of a publish
+
+/// The audio-session and now-playing effects the Player drives through its engine, in their
+/// order relative to the callbacks JS hears.
+@Suite("Player - media-stack effects")
+struct MediaStackEffectTests {
+  @MainActor
+  private func makeTraced() -> (Player, MockPlayerEngine, MockPlayerCallbacks) {
+    let (c, eh, cb, _) = makeCoordinator()
+    eh.onSeamCall = { [weak cb] in cb?.publishOrder.append($0) }
+    return (c, eh, cb)
+  }
+
+  @Test @MainActor
+  func playIntent_cancelsTheReleaseBeforeJSHearsIt_thenActivatesOnOutput() {
+    let (c, _, cb) = makeTraced()
+    loadTrack(c)
+    cb.publishOrder.removeAll()
+
+    c.setPlayWhenReady(true)
+
+    #expect(cb.publishOrder == [
+      "cancelAudioSessionRelease", "playWhenReady",
+      "playingState", "activateAudioSession", "renderNowPlaying",
+    ])
+  }
+
+  @Test @MainActor
+  func pause_rendersWithoutActivating_thenSchedulesTheRelease() {
+    let (c, eh, cb) = makeTraced()
+    startPlaying(c, eh)
+    cb.publishOrder.removeAll()
+
+    c.pause()
+
+    #expect(cb.publishOrder == [
+      "playWhenReady", "playingState", "renderNowPlaying", "scheduleAudioSessionRelease",
+    ])
+  }
+
+  @Test @MainActor
+  func playbackChange_rendersAfterJSHearsIt() {
+    let (c, _, cb) = makeTraced()
+    loadTrack(c)
+    cb.publishOrder.removeAll()
+
+    c.transition(.errorOccurred(.playbackFailed))
+
+    #expect(cb.publishOrder == ["playback", "renderNowPlaying"])
+  }
+
+  @Test @MainActor
+  func activeTrackChange_resetsTheNowPlayingLinesAfterJSHearsIt() {
+    let (c, eh, cb, _) = makeCoordinator()
+    eh.onSeamCall = { [weak cb] call in
+      if call == "nowPlayingTrackChanged" { cb?.queueAndTrackOrder.append(call) }
+    }
+
+    c.setQueue([Track(id: "t1", src: "https://example.com/a.mp3", title: "A")])
+
+    #expect(cb.queueAndTrackOrder == ["queue", "activeTrack", "nowPlayingTrackChanged"])
+    #expect(eh.nowPlayingTrackChangedCount == 1)
+  }
+
+  @Test @MainActor
+  func timedMetadata_reachesJSThenTheNowPlayingLines() {
+    let (c, eh, cb) = makeTraced()
+    let metadata = TimedMetadata(title: "Song", artist: "Artist")
+
+    eh.emit(.timedMetadata(metadata))
+    withExtendedLifetime(c) {}
+
+    #expect(cb.publishOrder == ["timedMetadata", "applyTimedMetadata"])
+    #expect(cb.timedMetadata == [metadata])
+    #expect(eh.appliedTimedMetadata == [metadata])
   }
 }

package/ios/Tests/RemoteCommandControllerTests.swift

@@ -18,7 +18,6 @@ struct RemoteCommandControllerTests {
     func remotePlay() { events.append("play") }
     func remotePause() { events.append("pause") }
     func remoteStop() { events.append("stop") }
-    func remotePlayPause() { events.append("playPause") }
     func remoteNext() { events.append("next") }
     func remotePrevious() { events.append("previous") }
     func remoteJumpForward(interval: Double) { events.append("jumpForward:\(interval)") }
@@ -34,28 +33,23 @@ struct RemoteCommandControllerTests {
   private func makeController() -> (RemoteCommandController, SpyCallbacks) {
     let center = MPRemoteCommandCenter.shared()
     let reset = RemoteCommandController(remoteCommandCenter: center)
-    reset.enable(commands: RemoteCommand.all())
+    reset.enable(commands: Set(RemoteCommand.allCases))
     reset.disableAll()
 
     let spy = SpyCallbacks()
     return (RemoteCommandController(remoteCommandCenter: center, callbacks: spy), spy)
   }
 
-  /// The reported bug: a changed jump interval used to disable the very command
-  /// it had just re-enabled, removing the skip button from the lock screen,
-  /// Control Center and CarPlay while `enabledCommands` still reported it on.
   @Test func changedJumpIntervalKeepsCommandEnabled() {
     let (controller, _) = makeController()
     let center = MPRemoteCommandCenter.shared()
 
-    controller.enable(commands: [
-      .play, .skipForward(preferredIntervals: [15]), .skipBackward(preferredIntervals: [15]),
-    ])
+    controller.enable(commands: [.play, .skipForward, .skipBackward])
     #expect(center.skipForwardCommand.isEnabled)
 
-    controller.enable(commands: [
-      .play, .skipForward(preferredIntervals: [30]), .skipBackward(preferredIntervals: [30]),
-    ])
+    controller.enable(
+      commands: [.play, .skipForward, .skipBackward], forwardJumpInterval: 30, backwardJumpInterval: 30,
+    )
 
     #expect(center.skipForwardCommand.isEnabled)
     #expect(center.skipBackwardCommand.isEnabled)
@@ -67,8 +61,8 @@ struct RemoteCommandControllerTests {
     let (controller, _) = makeController()
     let center = MPRemoteCommandCenter.shared()
 
-    controller.enable(commands: [.changePlaybackRate(supportedPlaybackRates: [1.0])])
-    controller.enable(commands: [.changePlaybackRate(supportedPlaybackRates: [1.0, 1.5, 2.0])])
+    controller.enable(commands: [.changePlaybackRate], playbackRates: [1.0])
+    controller.enable(commands: [.changePlaybackRate], playbackRates: [1.0, 1.5, 2.0])
 
     #expect(center.changePlaybackRateCommand.isEnabled)
     #expect(center.changePlaybackRateCommand.supportedPlaybackRates == [1.0, 1.5, 2.0])
@@ -87,11 +81,46 @@ struct RemoteCommandControllerTests {
     #expect(center.playCommand.isEnabled)
   }
 
+  @Test func retainedCommandStaysEnabledWhenOthersAreAdded() {
+    let (controller, _) = makeController()
+    let center = MPRemoteCommandCenter.shared()
+
+    controller.enable(commands: [.play, .pause])
+    controller.enable(commands: [.play, .pause, .stop])
+
+    #expect(center.playCommand.isEnabled)
+    #expect(center.pauseCommand.isEnabled)
+    #expect(center.stopCommand.isEnabled)
+  }
+
+  @Test func droppedJumpCommandIsDisabled() {
+    let (controller, _) = makeController()
+    let center = MPRemoteCommandCenter.shared()
+
+    controller.enable(commands: [.play, .skipForward])
+    controller.enable(commands: [.play])
+
+    #expect(!center.skipForwardCommand.isEnabled)
+    #expect(center.playCommand.isEnabled)
+  }
+
+  @Test func enablingNoCommandsDisablesEveryOne() {
+    let (controller, _) = makeController()
+    let center = MPRemoteCommandCenter.shared()
+
+    controller.enable(commands: Set(RemoteCommand.allCases))
+    controller.enable(commands: [])
+
+    #expect(!center.playCommand.isEnabled)
+    #expect(!center.skipBackwardCommand.isEnabled)
+    #expect(!center.changePlaybackRateCommand.isEnabled)
+  }
+
   @Test func disableAllClearsEveryTarget() {
     let (controller, _) = makeController()
     let center = MPRemoteCommandCenter.shared()
 
-    controller.enable(commands: [.play, .pause, .skipForward(preferredIntervals: [15])])
+    controller.enable(commands: [.play, .pause, .skipForward])
     controller.disableAll()
 
     #expect(!center.playCommand.isEnabled)
@@ -126,7 +155,7 @@ struct RemoteCommandControllerTests {
     weak var weakController: RemoteCommandController?
     autoreleasepool {
       let (controller, _) = makeController()
-      controller.enable(commands: RemoteCommand.all())
+      controller.enable(commands: Set(RemoteCommand.allCases))
       controller.disableAll()
       weakController = controller
     }

package/ios/Tests/RequestLayerTests.swift

@@ -109,4 +109,120 @@ struct RequestLayerTests {
     #expect(RequestLayer.mergeDicts(["a": "1"], nil) == ["a": "1"])
     #expect(RequestLayer.mergeDicts(nil, ["b": "2"]) == ["b": "2"])
   }
+
+  @Test func baseSetsOnlyThePath() {
+    #expect(Config.base(path: "/a") == Config(path: "/a"))
+  }
+
+  // MARK: - artwork
+
+  private func artwork(
+    _ artwork: Config = Config(),
+    over base: Config = Config(path: "/art.png"),
+    resolve: (nonisolated(nonsending)() async throws -> Config?)? = nil,
+    trackHasArtwork: Bool = true,
+    sizeQuery: [String: String] = [:],
+    transforms: [nonisolated(nonsending)(Config) async throws -> Config] = [],
+    id: String? = nil,
+  ) async throws -> Config? {
+    try await RequestLayer.artwork(
+      artwork, over: base, resolve: resolve, trackHasArtwork: trackHasArtwork,
+      sizeQuery: sizeQuery, transforms: transforms, id: id,
+    )
+  }
+
+  @Test func artworkStaticFieldsMergeOverTheBasePathIncluded() async throws {
+    let result = try await artwork(
+      Config(path: "/artwork/{id}", baseUrl: "https://img", headers: ["B": "2"]),
+      over: Config(path: "/art.png", baseUrl: "https://api", headers: ["A": "1"]),
+      id: "42",
+    )
+    #expect(result == Config(path: "/artwork/42", baseUrl: "https://img", headers: ["A": "1", "B": "2"]))
+  }
+
+  @Test func theResolvedConfigWinsOverTheStaticFields() async throws {
+    let result = try await artwork(
+      Config(baseUrl: "https://static", userAgent: "static"),
+      resolve: { Config(baseUrl: "https://resolved") },
+    )
+    #expect(result == Config(path: "/art.png", baseUrl: "https://resolved", userAgent: "static"))
+  }
+
+  @Test func aResolverThatProducesNothingKeepsTheTracksArtwork() async throws {
+    let result = try await artwork(Config(baseUrl: "https://img"), resolve: { nil })
+    #expect(result == Config(path: "/art.png", baseUrl: "https://img"))
+  }
+
+  @Test func aResolverThatProducesNothingForATrackWithoutArtworkIsNoArtwork() async throws {
+    let result = try await artwork(
+      Config(path: "/fallback.png"), over: Config(), resolve: { nil }, trackHasArtwork: false,
+    )
+    #expect(result == nil)
+  }
+
+  @Test func theSizeQueryMergesBeforeTheTransformsRun() async throws {
+    var seen: Config?
+    let result = try await artwork(
+      over: Config(path: "/art.png", query: ["v": "1"]),
+      sizeQuery: ["w": "300"],
+      transforms: [{ seen = $0; return $0 }],
+    )
+    #expect(seen?.query == ["v": "1", "w": "300"])
+    #expect(result?.query == ["v": "1", "w": "300"])
+  }
+
+  @Test func anEmptySizeQueryLeavesNoQuery() async throws {
+    #expect(try await artwork()?.query == nil)
+  }
+
+  @Test func transformsRunInOrderBeforeTheIdIsFilled() async throws {
+    let result = try await artwork(
+      transforms: [
+        { Config(path: "/t/{id}", baseUrl: $0.baseUrl) },
+        { Config(path: $0.path, baseUrl: "https://second", headers: ["X-Id": "{id}"], query: ["id": "{id}"]) },
+      ],
+      id: "7",
+    )
+    #expect(result == Config(path: "/t/7", baseUrl: "https://second", headers: ["X-Id": "7"], query: ["id": "7"]))
+  }
+
+  @Test func withoutAnIdTheTokenStays() async throws {
+    let result = try await artwork(Config(path: "/artwork/{id}"), id: nil)
+    #expect(result?.path == "/artwork/{id}")
+    #expect(RequestLayer.hasUnfilledIdToken(result!))
+    #expect(!RequestLayer.hasUnfilledIdToken(Config(path: "/artwork/1")))
+    #expect(RequestLayer.hasUnfilledIdToken(Config(headers: ["X": "{id}"])))
+  }
+
+  @Test func noPathLeftIsNoArtwork() async throws {
+    #expect(try await artwork(over: Config(baseUrl: "https://img")) == nil)
+    #expect(try await artwork(transforms: [{ _ in Config(baseUrl: "https://img") }]) == nil)
+  }
+
+  @Test func sizeQueryNamesTheContextsWholePixels() {
+    let params = ImageQueryParams(width: "w", height: "h")
+    #expect(RequestLayer.sizeQuery(params, ImageContext(width: 300.7, height: 200)) == ["w": "300", "h": "200"])
+    #expect(RequestLayer.sizeQuery(ImageQueryParams(width: "w"), ImageContext(width: 300, height: 200)) == ["w": "300"])
+    #expect(RequestLayer.sizeQuery(params, ImageContext(width: nil, height: 200)) == ["h": "200"])
+    #expect(RequestLayer.sizeQuery(params, nil) == [:])
+    #expect(RequestLayer.sizeQuery(nil, ImageContext(width: 300, height: 200)) == [:])
+  }
+
+  @Test func imageHeadersAddTheUserAgentUnlessAHeaderSetsIt() {
+    #expect(RequestLayer.imageHeaders(Config()) == nil)
+    #expect(RequestLayer.imageHeaders(Config(userAgent: "UA")) == ["User-Agent": "UA"])
+    #expect(RequestLayer.imageHeaders(Config(headers: ["User-Agent": "mine"], userAgent: "UA")) == ["User-Agent": "mine"])
+  }
+
+  @Test func imageHeadersAddTheContentTypeUnlessAHeaderSetsIt() {
+    #expect(RequestLayer.imageHeaders(Config(contentType: "image/png")) == ["Content-Type": "image/png"])
+    #expect(
+      RequestLayer.imageHeaders(Config(headers: ["Content-Type": "mine"], contentType: "image/png"))
+        == ["Content-Type": "mine"],
+    )
+    #expect(
+      RequestLayer.imageHeaders(Config(contentType: "image/png", userAgent: "UA"))
+        == ["Content-Type": "image/png", "User-Agent": "UA"],
+    )
+  }
 }

package/ios/Tests/SearchParamsQueryTests.swift

@@ -0,0 +1,48 @@
+import Testing
+
+@testable import AudioBrowserTestable
+
+struct SearchParamsQueryTests {
+  private func params(
+    _ query: String,
+    mode: SearchMode? = nil,
+    genre: String? = nil,
+    artist: String? = nil,
+    album: String? = nil,
+    title: String? = nil,
+    playlist: String? = nil,
+    reference: MediaReference = .unknown,
+  ) -> SearchParams {
+    SearchParams(
+      mode: mode, query: query, genre: genre, artist: artist, album: album,
+      title: title, playlist: playlist, reference: reference,
+    )
+  }
+
+  @Test func aPlainSearchSendsOnlyQ() {
+    #expect(params("jazz").queryParams == ["q": "jazz"])
+  }
+
+  @Test func everySetFilterIsSent() {
+    let all = params(
+      "x", mode: .musicVideo, genre: "g", artist: "a", album: "al", title: "t", playlist: "p", reference: .my,
+    )
+    #expect(all.queryParams == [
+      "q": "x", "mode": "music-video", "genre": "g", "artist": "a", "album": "al",
+      "title": "t", "playlist": "p", "reference": "my",
+    ])
+  }
+
+  @Test func anUnknownReferenceIsNotSent() {
+    #expect(params("x", reference: .unknown).queryParams["reference"] == nil)
+  }
+
+  @Test func theCacheKeyIsSortedAndDelimited() {
+    #expect(params("jazz", genre: "jazz").cacheKey == "genre=jazz\u{1}q=jazz")
+  }
+
+  @Test func searchesWithTheSameQueryButDifferentFiltersHaveDifferentKeys() {
+    #expect(params("jazz").cacheKey != params("jazz", genre: "jazz").cacheKey)
+    #expect(params("a", artist: "b").cacheKey != params("a", album: "b").cacheKey)
+  }
+}

package/ios/Tests/SectionScopeTests.swift

@@ -111,4 +111,57 @@ struct SectionScopeTests {
   @Test func childlessPageHasNoSections() {
     #expect(ResolvedTrack(path: "/p", title: "P").normalizedSections == nil)
   }
+
+  // MARK: - Queue
+
+  private func queue(_ sections: [Section], _ path: String, singleTrack: Bool = false) -> ([String?], Int)? {
+    SectionScope.queue(in: sections, path: path, singleTrack: singleTrack).map { ($0.tracks.map(\.src), $0.selectedIndex) }
+  }
+
+  @Test func queuesThePlayableTracksOfTheTappedSection() {
+    let page = [
+      section("First", [track("a"), Track(id: "off", src: "off", disabled: true), Track(path: "/browse"), track("b")]),
+      section("Second", [track("c")]),
+    ]
+    let result = queue(page, "/p?__trackId=b&__index=3")
+    #expect(result?.0 == ["a", "b"])
+    #expect(result?.1 == 1)
+  }
+
+  @Test func thePinnedCopyIsTheSelectedOne() {
+    let page = [section(nil, [track("a"), track("b"), track("a")])]
+    #expect(queue(page, "/p?__trackId=a&__index=2")?.1 == 2)
+    #expect(queue(page, "/p?__trackId=a")?.1 == 0)
+  }
+
+  @Test func aStaleIndexSelectsTheFirstIdentityMatch() {
+    let page = [section(nil, [track("x"), track("a"), track("a")])]
+    #expect(queue(page, "/p?__trackId=a&__index=0")?.1 == 1)
+  }
+
+  @Test func singleTrackQueuesOnlyTheTappedTrack() {
+    let page = [section(nil, [track("a"), track("b"), track("c")])]
+    let result = queue(page, "/p?__trackId=b&__index=1", singleTrack: true)
+    #expect(result?.0 == ["b"])
+    #expect(result?.1 == 0)
+  }
+
+  @Test func aDisabledTappedTrackQueuesNothing() {
+    let page = [section(nil, [track("a"), Track(id: "off", src: "off", disabled: true)])]
+    #expect(queue(page, "/p?__trackId=off&__index=1") == nil)
+    #expect(queue(page, "/p?__trackId=off") == nil)
+  }
+
+  @Test func aVanishedIdentityOrAPlainPathQueuesNothing() {
+    let page = [section(nil, [track("a")])]
+    #expect(queue(page, "/p?__trackId=gone") == nil)
+    #expect(queue(page, "/p") == nil)
+  }
+
+  @Test func isPlayableNeedsASrcAndNoDisabled() {
+    #expect(Track(src: "s").isPlayable)
+    #expect(Track(src: "s", disabled: false).isPlayable)
+    #expect(!Track(src: "s", disabled: true).isPlayable)
+    #expect(!Track(path: "/p").isPlayable)
+  }
 }

package/ios/Tests/SimpleRouterTests.swift

@@ -7,9 +7,7 @@ private struct TestRoute: RouteEntry {
 }
 
 private func match(_ path: String, _ patterns: [String]) -> (route: TestRoute, match: RouteMatch)? {
-  let router = SimpleRouter()
-  let routes = patterns.map { TestRoute(path: $0) }
-  return router.findBestMatch(path: path, routes: routes)
+  SimpleRouter.findBestMatch(path: path, routes: patterns.map { TestRoute(path: $0) })
 }
 
 // MARK: - exact matches
@@ -137,3 +135,40 @@ private func match(_ path: String, _ patterns: [String]) -> (route: TestRoute, m
   let result = match("/api/v1/users", ["/api/{version}/**", "/api/v1/**"])
   #expect(result!.route.path == "/api/v1/**")
 }
+
+@Test func treatsADoubleStarBeforeTheEndAsAConstant() {
+  #expect(match("/a/**/b", ["/a/**/b"]) != nil)
+  #expect(match("/a/x/b", ["/a/**/b"]) == nil)
+}
+
+@Test func theFirstRouteWinsATie() {
+  let result = match("/artists/123", ["/artists/{id}", "/artists/{name}"])
+  #expect(result!.route.path == "/artists/{id}")
+}
+
+// MARK: - browse route
+
+private func browseRoute(_ path: String, _ patterns: [String]) -> (route: TestRoute, match: RouteMatch)? {
+  SimpleRouter.browseRoute(for: path, in: patterns.map { TestRoute(path: $0) })
+}
+
+@Test func theSpecialRoutesNeverMatchABrowsePath() {
+  #expect(browseRoute("/__tabs__", ["__tabs__", "__search__"]) == nil)
+  #expect(browseRoute("__search__", ["__search__"]) == nil)
+}
+
+@Test func aMatchingRouteWinsOverTheDefault() {
+  let result = browseRoute("/artists/1", ["__default__", "/artists/{id}"])
+  #expect(result!.route.path == "/artists/{id}")
+  #expect(result!.match.params == ["id": "1"])
+}
+
+@Test func withoutAMatchTheDefaultRouteBrowsesThePath() {
+  let result = browseRoute("/a/b", ["/artists", "__default__"])
+  #expect(result!.route.path == "__default__")
+  #expect(result!.match.params == ["path": "/a/b"])
+}
+
+@Test func withoutAMatchOrADefaultThereIsNoBrowseRoute() {
+  #expect(browseRoute("/a/b", ["/artists", "__tabs__"]) == nil)
+}