react-native-audio-browser 0.2.0-next.33 → 0.2.0-next.35

package/ios/Tests/MediaIntentCriteriaTests.swift

@@ -2,93 +2,105 @@ import Testing
 
 @testable import AudioBrowserTestable
 
+private func criteria(
+  mediaName: String? = nil,
+  genreNames: [String] = [],
+  artistName: String? = nil,
+  albumName: String? = nil,
+  mediaTypeMode: String? = nil,
+  reference: MediaIntentCriteria.Reference = .unknown,
+  hasMediaType: Bool = false,
+  appName: String? = "Acme Radio",
+) -> MediaIntentCriteria {
+  MediaIntentCriteria(
+    mediaName: mediaName, genreNames: genreNames, artistName: artistName,
+    albumName: albumName, mediaTypeMode: mediaTypeMode,
+    reference: reference, hasMediaType: hasMediaType, appName: appName,
+  )
+}
+
 @Suite("MediaIntentCriteria")
 struct MediaIntentCriteriaTests {
   @Test func emptyEverything_isResume() {
-    let c = MediaIntentCriteria(query: "", reference: .unknown, hasGenres: false, hasMediaType: false, matchesAppName: false)
-    #expect(c.isResume)
+    #expect(criteria().isResume)
   }
 
   @Test func whitespaceQuery_isResume() {
-    let c = MediaIntentCriteria(query: "   ", reference: .unknown, hasGenres: false, hasMediaType: false, matchesAppName: false)
+    let c = criteria(mediaName: "   ")
+    #expect(c.query == "")
     #expect(c.isResume)
   }
 
   // currentlyPlaying always resumes — "play this" makes the active track play.
   @Test func currentlyPlaying_isResume() {
-    #expect(MediaIntentCriteria(query: "", reference: .currentlyPlaying, hasGenres: false, hasMediaType: false, matchesAppName: false).isResume)
+    #expect(criteria(reference: .currentlyPlaying).isResume)
     // even with a stray query/filter, "play this" is a resume
-    #expect(MediaIntentCriteria(query: "jazz", reference: .currentlyPlaying, hasGenres: true, hasMediaType: true, matchesAppName: false).isResume)
+    #expect(criteria(mediaName: "jazz", genreNames: ["jazz"], reference: .currentlyPlaying, hasMediaType: true).isResume)
   }
 
   // .my always searches — "play my favorites" goes to the consumer, never resume.
   @Test func my_isNotResume() {
-    #expect(!MediaIntentCriteria(query: "", reference: .my, hasGenres: false, hasMediaType: false, matchesAppName: false).isResume)
-    #expect(!MediaIntentCriteria(query: "", reference: .my, hasGenres: false, hasMediaType: false, matchesAppName: true).isResume)
+    #expect(!criteria(reference: .my).isResume)
+    let namesApp = criteria(mediaName: "Acme", reference: .my)
+    #expect(namesApp.matchesAppName)
+    #expect(!namesApp.isResume)
   }
 
   @Test func anyCriteria_isNotResume() {
-    #expect(!MediaIntentCriteria(query: "kcrw", reference: .unknown, hasGenres: false, hasMediaType: false, matchesAppName: false).isResume)
-    #expect(!MediaIntentCriteria(query: "", reference: .unknown, hasGenres: true, hasMediaType: false, matchesAppName: false).isResume)
-    #expect(!MediaIntentCriteria(query: "", reference: .unknown, hasGenres: false, hasMediaType: true, matchesAppName: false).isResume)
+    #expect(!criteria(mediaName: "kcrw").isResume)
+    #expect(!criteria(genreNames: ["jazz"]).isResume)
+    #expect(!criteria(hasMediaType: true).isResume)
   }
 
   @Test func queryNamesApp_isResume() {
-    let c = MediaIntentCriteria(query: "Garden", reference: .unknown, hasGenres: false, hasMediaType: true, matchesAppName: true)
+    let c = criteria(mediaName: "Acme", hasMediaType: true)
+    #expect(c.matchesAppName)
     #expect(c.isResume)
   }
 
   @Test func queryNamesApp_withGenre_isNotResume() {
-    #expect(!MediaIntentCriteria(query: "Garden", reference: .unknown, hasGenres: true, hasMediaType: false, matchesAppName: true).isResume)
+    let c = criteria(mediaName: "Acme", genreNames: ["jazz"])
+    #expect(c.matchesAppName)
+    #expect(!c.isResume)
   }
 
   @Test func queryNotApp_isNotResume() {
-    #expect(!MediaIntentCriteria(query: "jazz", reference: .unknown, hasGenres: false, hasMediaType: false, matchesAppName: false).isResume)
+    #expect(!criteria(mediaName: "jazz").isResume)
   }
-}
 
-@Suite("MediaIntentCriteria.from")
-struct MediaIntentCriteriaFromTests {
-  private func from(
-    mediaName: String? = nil,
-    genreNames: [String] = [],
-    artistName: String? = nil,
-    albumName: String? = nil,
-    mediaTypeMode: String? = nil,
-    reference: MediaIntentCriteria.Reference = .unknown,
-    hasMediaType: Bool = false,
-    appName: String? = "Radio Garden",
-  ) -> MediaIntentCriteria {
-    MediaIntentCriteria.from(
-      mediaName: mediaName, genreNames: genreNames, artistName: artistName,
-      albumName: albumName, mediaTypeMode: mediaTypeMode,
-      reference: reference, hasMediaType: hasMediaType, appName: appName,
-    )
+  // An empty genre name is still a genre filter: the fact is that genres were given.
+  @Test func emptyGenreName_isStillAGenreFilter() {
+    let c = criteria(genreNames: [""])
+    #expect(c.genre == "")
+    #expect(!c.isResume)
   }
+}
 
+@Suite("MediaIntentCriteria from intent fields")
+struct MediaIntentCriteriaFromTests {
   // MARK: resume vs search
 
   @Test func playAppName_resumes() {
-    let c = from(mediaName: "Garden", hasMediaType: true)
-    #expect(c.query == "Garden")
+    let c = criteria(mediaName: "Acme", hasMediaType: true)
+    #expect(c.query == "Acme")
     #expect(c.matchesAppName)
     #expect(c.isResume)
   }
 
   @Test func emptyIntent_resumes() {
-    let c = from()
+    let c = criteria()
     #expect(c.query == "")
     #expect(c.isResume)
   }
 
   @Test func playMyFavorites_searches() {
-    let c = from(reference: .my)
+    let c = criteria(reference: .my)
     #expect(!c.isResume)
     #expect(c.reference == .my)
   }
 
   @Test func stationName_searches() {
-    let c = from(mediaName: "KCRW")
+    let c = criteria(mediaName: "KCRW")
     #expect(c.query == "KCRW")
     #expect(!c.matchesAppName)
     #expect(!c.isResume)
@@ -99,23 +111,22 @@ struct MediaIntentCriteriaFromTests {
 
   // "Play jazz" → genre is a FILTER, not a mode. mode stays nil; genre set.
   @Test func genre_isFilterNotMode() {
-    let c = from(genreNames: ["jazz"], hasMediaType: true)
+    let c = criteria(genreNames: ["jazz"], hasMediaType: true)
     #expect(c.query == "jazz")
     #expect(c.searchMode == nil)
     #expect(c.genre == "jazz")
-    #expect(c.hasGenres)
     #expect(!c.isResume)
   }
 
   @Test func multiWordGenre_joined_noMode() {
-    let c = from(mediaName: "   ", genreNames: ["classic", "rock"])
+    let c = criteria(mediaName: "   ", genreNames: ["classic", "rock"])
     #expect(c.query == "classic rock")
     #expect(c.genre == "classic rock")
     #expect(c.searchMode == nil)
   }
 
   @Test func artist_isFilterNotMode() {
-    let c = from(artistName: "Michael Jackson")
+    let c = criteria(artistName: "Michael Jackson")
     #expect(c.query == "Michael Jackson")
     #expect(c.searchMode == nil)
     #expect(c.artist == "Michael Jackson")
@@ -123,7 +134,7 @@ struct MediaIntentCriteriaFromTests {
   }
 
   @Test func albumAndArtist_areFiltersNotMode() {
-    let c = from(mediaName: "Thriller", artistName: "Michael Jackson", albumName: "Thriller")
+    let c = criteria(mediaName: "Thriller", artistName: "Michael Jackson", albumName: "Thriller")
     #expect(c.searchMode == nil)
     #expect(c.album == "Thriller")
     #expect(c.artist == "Michael Jackson")
@@ -132,7 +143,7 @@ struct MediaIntentCriteriaFromTests {
 
   // A vertical mediaType DOES set the mode, and travels with its filters.
   @Test func song_viaMediaTypeMode_setsTitle() {
-    let c = from(mediaName: "Billie Jean", mediaTypeMode: "song")
+    let c = criteria(mediaName: "Billie Jean", mediaTypeMode: "song")
     #expect(c.query == "Billie Jean")
     #expect(c.searchMode == "song")
     #expect(c.title == "Billie Jean")
@@ -140,7 +151,7 @@ struct MediaIntentCriteriaFromTests {
   }
 
   @Test func playlist_viaMediaTypeMode_setsPlaylist() {
-    let c = from(mediaName: "Workout", mediaTypeMode: "playlist")
+    let c = criteria(mediaName: "Workout", mediaTypeMode: "playlist")
     #expect(c.query == "Workout")
     #expect(c.searchMode == "playlist")
     #expect(c.playlist == "Workout")
@@ -149,19 +160,19 @@ struct MediaIntentCriteriaFromTests {
 
   // "Play jazz station" → vertical wins as mode; genre rides as a filter.
   @Test func station_withGenreFilter() {
-    let c = from(genreNames: ["jazz"], mediaTypeMode: "station", hasMediaType: true)
+    let c = criteria(genreNames: ["jazz"], mediaTypeMode: "station", hasMediaType: true)
     #expect(c.searchMode == "station")
     #expect(c.genre == "jazz")
   }
 
   @Test func podcast_setsMode() {
-    let c = from(mediaName: "Serial", mediaTypeMode: "podcast", hasMediaType: true)
+    let c = criteria(mediaName: "Serial", mediaTypeMode: "podcast", hasMediaType: true)
     #expect(c.searchMode == "podcast")
     #expect(c.query == "Serial")
   }
 
   @Test func plainName_hasNoStructuredFields() {
-    let c = from(mediaName: "KCRW")
+    let c = criteria(mediaName: "KCRW")
     #expect(c.searchMode == nil)
     #expect(c.genre == nil)
     #expect(c.artist == nil)

package/ios/Tests/NowPlayingButtonRulesTests.swift

@@ -0,0 +1,43 @@
+@testable import AudioBrowserTestable
+import Testing
+
+@Suite("NowPlayingButtonRules")
+struct NowPlayingButtonRulesTests {
+  @Test func buttons_dropRepeats_keepingFirstOrder() {
+    #expect(NowPlayingButtonRules.buttons(["shuffle", "favorite", "shuffle", "repeat"]) == ["shuffle", "favorite", "repeat"])
+  }
+
+  @Test func buttons_capAtFive_afterDroppingRepeats() {
+    let configured = ["a", "a", "b", "c", "d", "e", "f"]
+    #expect(NowPlayingButtonRules.buttons(configured) == ["a", "b", "c", "d", "e"])
+  }
+
+  @Test func buttons_empty() {
+    #expect(NowPlayingButtonRules.buttons([String]()).isEmpty)
+  }
+
+  @Test func repeatMode_cyclesOffTrackQueue() {
+    #expect(NowPlayingButtonRules.repeatMode(after: .off) == .track)
+    #expect(NowPlayingButtonRules.repeatMode(after: .track) == .queue)
+    #expect(NowPlayingButtonRules.repeatMode(after: .queue) == .off)
+  }
+
+  @Test func rate_advancesFromAConfiguredRate_andWraps() {
+    let rates = [0.5, 1, 1.5, 2]
+    #expect(NowPlayingButtonRules.rate(after: 1, in: rates) == 1.5)
+    #expect(NowPlayingButtonRules.rate(after: 2, in: rates) == 0.5)
+  }
+
+  @Test func rate_matchesAConfiguredRateWithinAHundredth() {
+    #expect(NowPlayingButtonRules.rate(after: 1.005, in: [1, 1.5]) == 1.5)
+  }
+
+  @Test func rate_offTheList_takesTheFirstAboveIt_elseTheFirst() {
+    #expect(NowPlayingButtonRules.rate(after: 1.2, in: [0.5, 1, 1.5]) == 1.5)
+    #expect(NowPlayingButtonRules.rate(after: 3, in: [0.5, 1, 1.5]) == 0.5)
+  }
+
+  @Test func rate_noRates_isNil() {
+    #expect(NowPlayingButtonRules.rate(after: 1, in: []) == nil)
+  }
+}

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,167 @@ 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])
+  }
+}
+
+@Suite("Player - now-playing preview")
+struct NowPlayingPreviewTests {
+  @Test @MainActor
+  func preview_showsTheTappedTrackWithoutLoadingIt() {
+    let (c, eh, _, _) = makeCoordinator()
+    let tapped = Track(id: "tapped", src: "https://example.com/tapped.mp3", title: "Tapped")
+
+    c.previewNowPlaying(tapped)
+
+    #expect(eh.loadNowPlayingMetadataCalls.map(\.id) == ["tapped"])
+    #expect(eh.resolveAndLoadCalls.isEmpty)
+    #expect(c.currentTrack == nil)
+  }
+
+  @Test @MainActor
+  func endingPreview_restoresTheCurrentTrackAndRendersItsLines() {
+    let (c, eh, _, _) = makeCoordinator()
+    loadTrack(c, id: "current")
+    c.previewNowPlaying(Track(id: "tapped", src: "https://example.com/tapped.mp3", title: "Tapped"))
+    let rendersBefore = eh.nowPlayingRenderCount
+
+    c.endNowPlayingPreview()
+
+    #expect(eh.loadNowPlayingMetadataCalls.last?.id == "current")
+    #expect(eh.nowPlayingRenderCount == rendersBefore + 1)
+    #expect(eh.clearNowPlayingCallCount == 0)
+  }
+
+  @Test @MainActor
+  func endingPreview_withNothingCurrent_clearsTheSurface() {
+    let (c, eh, _, _) = makeCoordinator()
+    c.previewNowPlaying(Track(id: "tapped", src: "https://example.com/tapped.mp3", title: "Tapped"))
+
+    c.endNowPlayingPreview()
+
+    #expect(eh.clearNowPlayingCallCount == 1)
+    #expect(eh.loadNowPlayingMetadataCalls.map(\.id) == ["tapped"])
+    #expect(eh.nowPlayingRenderCount == 0)
   }
 }

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
     }