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

package/ios/Tests/QueueManagerTests.swift

@@ -74,6 +74,52 @@ struct NextTests {
     #expect(q.currentIndex == 0)
   }
 
+  /// The start track must be first in the shuffle order, not wherever the permutation put it —
+  /// otherwise auto-advance ends the queue as soon as it is reached (#96).
+  @Test func shuffle_startTrackLeadsTheOrder() {
+    for start in 0 ..< 6 {
+      let q = QueueManager()
+      q.setQueue(tracks("a", "b", "c", "d", "e", "f"), initialIndex: start)
+      q.shuffleEnabled = true
+
+      #expect(q.shuffleOrder.isFirst(start))
+      #expect(!q.isLastInPlaybackOrder)
+      #expect(q.nextTracks.count == 5)
+      #expect(q.previousTracks.isEmpty)
+    }
+  }
+
+  /// Same hazard on enabling shuffle mid-queue: the existing order has the current track wherever
+  /// it landed, so without re-pinning, turning shuffle on can immediately report end-of-queue.
+  @Test func shuffle_enablingMidQueueLeadsFromCurrent() {
+    for start in 0 ..< 6 {
+      let q = QueueManager()
+      q.setQueue(tracks("a", "b", "c", "d", "e", "f"))
+      _ = try? q.skipTo(start)
+
+      q.shuffleEnabled = true
+
+      #expect(q.shuffleOrder.isFirst(start))
+      #expect(!q.isLastInPlaybackOrder)
+      #expect(q.nextTracks.count == 5)
+    }
+  }
+
+  /// Re-pinning happens on enable only — flipping it off and on again must not renege on the
+  /// order mid-listen, and a redundant `= true` must not reshuffle under the listener.
+  @Test func shuffle_redundantEnableKeepsTheOrder() {
+    let q = QueueManager()
+    q.setQueue(tracks("a", "b", "c", "d", "e", "f"))
+    q.shuffleEnabled = true
+    let order = q.shuffleOrder.shuffled
+
+    q.shuffleEnabled = true
+    #expect(q.shuffleOrder.shuffled == order)
+
+    q.shuffleEnabled = false
+    #expect(q.shuffleOrder.shuffled == order)
+  }
+
   @Test func shuffle_visitsAllTracks() {
     let q = QueueManager()
     q.setQueue(tracks("a", "b", "c", "d"))
@@ -767,13 +813,13 @@ struct ComputedPropertyTests {
     let q = QueueManager()
     q.setQueue(tracks("a", "b", "c", "d"))
     q.shuffleEnabled = true
-    let nextFromProp = q.nextTracks.map(\.id)
+    let nextFromProp = q.nextTracks.map { $0.id! }
     // Navigate forward only as many times as nextTracks reports
     // (nextTracks does not include wrapped tracks)
     var nextFromNav: [String] = []
     for _ in 0 ..< nextFromProp.count {
       _ = q.next()
-      nextFromNav.append(q.currentTrack!.id)
+      nextFromNav.append(q.currentTrack!.id!)
     }
     #expect(nextFromProp == nextFromNav)
   }
@@ -786,12 +832,12 @@ struct ComputedPropertyTests {
     for _ in 0 ..< 3 {
       _ = q.next()
     }
-    let prevFromProp = q.previousTracks.map(\.id)
+    let prevFromProp = q.previousTracks.map { $0.id! }
     // Navigate backward the same number of times
     var prevFromNav: [String] = []
     for _ in 0 ..< prevFromProp.count {
       _ = q.previous()
-      prevFromNav.insert(q.currentTrack!.id, at: 0)
+      prevFromNav.insert(q.currentTrack!.id!, at: 0)
     }
     #expect(prevFromProp == prevFromNav)
   }

package/ios/Tests/RemoteCommandControllerTests.swift

@@ -0,0 +1,156 @@
+import Foundation
+import MediaPlayer
+import Testing
+
+@testable import AudioBrowserTestable
+
+/// Exercises the controller against the real `MPRemoteCommandCenter`.
+///
+/// `MPRemoteCommandCenter`'s `init()` is unavailable, so `shared()` — a
+/// process-wide singleton — is the only center available. The suite is
+/// `.serialized` because of that shared state, and every test resets the
+/// commands it touches through `reset()`.
+@Suite("RemoteCommandController", .serialized)
+@MainActor
+struct RemoteCommandControllerTests {
+  final class SpyCallbacks: RemoteCommandCallbacks {
+    var events: [String] = []
+    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)") }
+    func remoteJumpBackward(interval: Double) { events.append("jumpBackward:\(interval)") }
+    func remoteSeek(position: Double) { events.append("seek:\(position)") }
+    func remoteChangeRepeatMode(mode: RepeatMode) { events.append("repeat:\(mode)") }
+    func remoteChangeShuffleMode(enabled: Bool) { events.append("shuffle:\(enabled)") }
+    func remoteChangePlaybackRate(rate: Float) { events.append("rate:\(rate)") }
+  }
+
+  /// Clears every command on the shared center so a test starts from a known
+  /// state regardless of what ran before it.
+  private func makeController() -> (RemoteCommandController, SpyCallbacks) {
+    let center = MPRemoteCommandCenter.shared()
+    let reset = RemoteCommandController(remoteCommandCenter: center)
+    reset.enable(commands: RemoteCommand.all())
+    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]),
+    ])
+    #expect(center.skipForwardCommand.isEnabled)
+
+    controller.enable(commands: [
+      .play, .skipForward(preferredIntervals: [30]), .skipBackward(preferredIntervals: [30]),
+    ])
+
+    #expect(center.skipForwardCommand.isEnabled)
+    #expect(center.skipBackwardCommand.isEnabled)
+    #expect(controller.commandTargetPointers["skipForward"] != nil)
+    #expect(controller.commandTargetPointers["skipBackward"] != nil)
+    #expect(center.skipForwardCommand.preferredIntervals == [30])
+    #expect(center.skipBackwardCommand.preferredIntervals == [30])
+  }
+
+  @Test func changedPlaybackRatesKeepCommandEnabled() {
+    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])])
+
+    #expect(center.changePlaybackRateCommand.isEnabled)
+    #expect(controller.commandTargetPointers["changePlaybackRate"] != nil)
+    #expect(center.changePlaybackRateCommand.supportedPlaybackRates == [1.0, 1.5, 2.0])
+  }
+
+  @Test func removedCommandIsDisabledAndUntargeted() {
+    let (controller, _) = makeController()
+    let center = MPRemoteCommandCenter.shared()
+
+    controller.enable(commands: [.play, .pause, .next])
+    #expect(center.nextTrackCommand.isEnabled)
+
+    controller.enable(commands: [.play, .pause])
+
+    #expect(!center.nextTrackCommand.isEnabled)
+    #expect(controller.commandTargetPointers["nextTrack"] == nil)
+    #expect(center.playCommand.isEnabled)
+    #expect(controller.commandTargetPointers["play"] != nil)
+  }
+
+  @Test func disableAllClearsEveryTarget() {
+    let (controller, _) = makeController()
+    let center = MPRemoteCommandCenter.shared()
+
+    controller.enable(commands: [.play, .pause, .skipForward(preferredIntervals: [15])])
+    controller.disableAll()
+
+    #expect(controller.commandTargetPointers.isEmpty)
+    #expect(!center.playCommand.isEnabled)
+    #expect(!center.pauseCommand.isEnabled)
+    #expect(!center.skipForwardCommand.isEnabled)
+  }
+
+  /// Re-enabling the same set must not accumulate handlers: `enableRemoteCommand`
+  /// removes the previous target before adding the new one.
+  @Test func reEnablingKeepsOneTargetPerCommand() {
+    let (controller, _) = makeController()
+
+    controller.enable(commands: [.play, .pause])
+    let first = controller.commandTargetPointers["play"]
+    controller.enable(commands: [.play, .pause])
+    let second = controller.commandTargetPointers["play"]
+
+    #expect(controller.commandTargetPointers.count == 2)
+    #expect(first as AnyObject? !== second as AnyObject?)
+  }
+
+  /// `setSkipAvailability` greys out next/previous when the queue has nowhere to
+  /// go, and the state must survive a later `enable(commands:)`.
+  @Test func skipAvailabilitySurvivesReEnable() {
+    let (controller, _) = makeController()
+    let center = MPRemoteCommandCenter.shared()
+
+    controller.enable(commands: [.next, .previous])
+    controller.setSkipAvailability(canNext: false, canPrevious: true)
+    #expect(!center.nextTrackCommand.isEnabled)
+    #expect(center.previousTrackCommand.isEnabled)
+
+    controller.enable(commands: [.next, .previous, .play])
+
+    #expect(!center.nextTrackCommand.isEnabled)
+    #expect(center.previousTrackCommand.isEnabled)
+  }
+
+  @Test func shuffleAndRepeatStateSurviveCommandCenterSwitch() {
+    let (controller, _) = makeController()
+    let center = MPRemoteCommandCenter.shared()
+
+    controller.enable(commands: [.changeShuffleMode, .changeRepeatMode])
+    controller.updateShuffleMode(true)
+    controller.updateRepeatMode(.queue)
+
+    // Same center — switchCommandCenter no-ops, but the restore path is the
+    // interesting part: state is re-applied from the stored values.
+    controller.switchCommandCenter(center)
+
+    #expect(center.changeShuffleModeCommand.currentShuffleType == .items)
+    #expect(center.changeRepeatModeCommand.currentRepeatType == .all)
+    #expect(center.changeShuffleModeCommand.isEnabled)
+    #expect(controller.commandTargetPointers["changeShuffleMode"] != nil)
+  }
+}

package/ios/Tests/RemoteCommandTests.swift

@@ -0,0 +1,67 @@
+import Foundation
+import Testing
+
+@testable import AudioBrowserTestable
+
+@Suite("RemoteCommand")
+struct RemoteCommandTests {
+  @Test func removedCommandsAreDisabled() {
+    let toDisable = RemoteCommand.commandsToDisable(
+      enabled: [.play, .pause, .next, .previous],
+      replacedBy: [.play, .pause],
+    )
+    #expect(toDisable.map(\.key) == ["nextTrack", "previousTrack"])
+  }
+
+  @Test func retainedCommandsAreNotDisabled() {
+    let toDisable = RemoteCommand.commandsToDisable(
+      enabled: [.play, .pause],
+      replacedBy: [.play, .pause, .stop],
+    )
+    #expect(toDisable.isEmpty)
+  }
+
+  /// A changed jump interval is the same command with a new associated value —
+  /// diffing by `==` would report it as removed and disable the button that the
+  /// update had just re-enabled.
+  @Test func changedJumpIntervalIsNotDisabled() {
+    let toDisable = RemoteCommand.commandsToDisable(
+      enabled: [.skipForward(preferredIntervals: [15]), .skipBackward(preferredIntervals: [15])],
+      replacedBy: [.skipForward(preferredIntervals: [30]), .skipBackward(preferredIntervals: [30])],
+    )
+    #expect(toDisable.isEmpty)
+  }
+
+  @Test func changedPlaybackRatesAreNotDisabled() {
+    let toDisable = RemoteCommand.commandsToDisable(
+      enabled: [.changePlaybackRate(supportedPlaybackRates: [1.0])],
+      replacedBy: [.changePlaybackRate(supportedPlaybackRates: [1.0, 1.5, 2.0])],
+    )
+    #expect(toDisable.isEmpty)
+  }
+
+  @Test func everyCommandIsDisabledWhenNoneRemain() {
+    let toDisable = RemoteCommand.commandsToDisable(
+      enabled: RemoteCommand.all(),
+      replacedBy: [],
+    )
+    #expect(toDisable.count == RemoteCommand.all().count)
+  }
+
+  /// `key` is the identity used both for the diff above and for the
+  /// `commandTargetPointers` slot each command's handler lives in. Two cases
+  /// sharing a key would silently share one slot: enabling one would remove the
+  /// other's handler.
+  @Test func keysAreUnique() {
+    let all = RemoteCommand.all()
+    #expect(Set(all.map(\.key)).count == all.count)
+  }
+
+  @Test func droppedJumpCommandIsStillDisabled() {
+    let toDisable = RemoteCommand.commandsToDisable(
+      enabled: [.play, .skipForward(preferredIntervals: [15])],
+      replacedBy: [.play],
+    )
+    #expect(toDisable.map(\.key) == ["skipForward"])
+  }
+}

package/ios/Tests/RetryManagerTests.swift

@@ -1,3 +1,4 @@
+import AVFoundation
 import Foundation
 import Testing
 
@@ -87,3 +88,91 @@ struct RetryManagerBudgetTests {
     #expect(manager.hasPlayed == true)
   }
 }
+
+/// Which failures earn another attempt. The reference is Android's
+/// `RetryLoadErrorHandlingPolicy.classifyError`: same HTTP set, and the same
+/// default of treating an unrecognized failure as transient. Defaulting the
+/// other way made `retry: true` largely inert on iOS, since AVFoundation
+/// reports most stream failures as opaque CoreMedia errors, not `URLError`.
+@Suite("RetryManager error classification")
+@MainActor
+struct RetryManagerClassificationTests {
+  private func makeManager() -> RetryManager {
+    let manager = RetryManager()
+    manager.updatePolicy(from: .first(true))
+    return manager
+  }
+
+  /// `AVPlayerItem.error` never carries the status, so the caller reads it off
+  /// the item's error log and passes it in. It outranks the opaque error.
+  @Test(arguments: [408, 429, 500, 502, 503, 504])
+  func retryableHTTPStatus_retries(status: Int) {
+    let opaque = NSError(domain: "CoreMediaErrorDomain", code: -12660)
+    #expect(makeManager().isRetryable(opaque, httpStatusCode: status) == true)
+  }
+
+  /// A retry cannot conjure content that isn't there, whatever the error says.
+  @Test(arguments: [400, 401, 403, 404, 410, 451])
+  func permanentHTTPStatus_doesNotRetry(status: Int) {
+    let transient = URLError(.timedOut)
+    #expect(makeManager().isRetryable(transient, httpStatusCode: status) == false)
+  }
+
+  @Test func transientURLError_retries() {
+    #expect(makeManager().isRetryable(URLError(.networkConnectionLost), httpStatusCode: nil) == true)
+  }
+
+  @Test func fatalURLError_doesNotRetry() {
+    #expect(makeManager().isRetryable(URLError(.badURL), httpStatusCode: nil) == false)
+  }
+
+  /// The regression this suite exists for: an opaque CoreMedia failure with no
+  /// status to read used to be terminal, so a station that dropped mid-song
+  /// never came back on iOS while Android reconnected.
+  @Test func opaqueCoreMediaError_retries() {
+    let error = NSError(domain: "CoreMediaErrorDomain", code: -12939)
+    #expect(makeManager().isRetryable(error, httpStatusCode: nil) == true)
+  }
+
+  /// `AVErrorUnknown` is the wrapper AVFoundation puts around transport
+  /// failures, so it must stay retryable even though it is an AVError.
+  @Test func avErrorUnknown_retries() {
+    let error = NSError(domain: AVFoundationErrorDomain, code: AVError.unknown.rawValue)
+    #expect(makeManager().isRetryable(error, httpStatusCode: nil) == true)
+  }
+
+  @Test(arguments: [
+    AVError.fileFormatNotRecognized.rawValue,
+    AVError.failedToParse.rawValue,
+    AVError.decodeFailed.rawValue,
+  ])
+  func unusableMedia_doesNotRetry(code: Int) {
+    let error = NSError(domain: AVFoundationErrorDomain, code: code)
+    #expect(makeManager().isRetryable(error, httpStatusCode: nil) == false)
+  }
+
+  /// AVFoundation wraps the real cause rather than surfacing it, which is why
+  /// the classifier walks `NSUnderlyingError` instead of inspecting only the
+  /// outermost error.
+  @Test func underlyingURLError_isFound() {
+    let manager = makeManager()
+    let wrapped = NSError(
+      domain: AVFoundationErrorDomain,
+      code: AVError.unknown.rawValue,
+      userInfo: [NSUnderlyingErrorKey: URLError(.badURL)],
+    )
+    #expect(manager.isRetryable(wrapped, httpStatusCode: nil) == false)
+
+    let transient = NSError(
+      domain: AVFoundationErrorDomain,
+      code: AVError.unknown.rawValue,
+      userInfo: [NSUnderlyingErrorKey: URLError(.dnsLookupFailed)],
+    )
+    #expect(manager.isRetryable(transient, httpStatusCode: nil) == true)
+  }
+
+  /// Nothing to classify: no error and no status stays terminal.
+  @Test func nilError_doesNotRetry() {
+    #expect(makeManager().isRetryable(nil, httpStatusCode: nil) == false)
+  }
+}

package/ios/Tests/SectionScopeTests.swift

@@ -7,12 +7,12 @@ struct SectionScopeTests {
   }
 
   private func runSrcs(_ section: SectionScope.Section?) -> [String?]? {
-    guard case .run(let tracks) = section else { return nil }
+    guard case let .run(tracks) = section else { return nil }
     return tracks.map(\.src)
   }
 
   private func imageRowSrcs(_ section: SectionScope.Section?) -> [String?]? {
-    guard case .imageRow(let items) = section else { return nil }
+    guard case let .imageRow(items) = section else { return nil }
     return items.map(\.src)
   }
 

package/ios/Tests/SleepTimerManagerTests.swift

@@ -2,15 +2,15 @@
 import Foundation
 import Testing
 
-// Timing tests use generous margins (50ms+) around DispatchQueue scheduling
-// slop. While an @MainActor test awaits Task.sleep, the main queue is free to
-// run the manager's scheduled jobs.
+// Timing tests drive a ManualSleepTimerScheduler rather than the main queue:
+// every deadline below is virtual, so nothing races the real clock.
 
 @Suite("SleepTimerManager - fade scheduling")
 struct SleepTimerManagerTests {
   @Test @MainActor
-  func fadeFiresBeforeDeadline_completionDoesNotEmitFadeCancel() async throws {
-    let manager = SleepTimerManager()
+  func fadeFiresBeforeDeadline_completionDoesNotEmitFadeCancel() {
+    let clock = ManualSleepTimerScheduler()
+    let manager = SleepTimerManager(scheduler: clock)
     var fadeStarts: [TimeInterval] = []
     var completes = 0
     var cancels = 0
@@ -20,35 +20,37 @@ struct SleepTimerManagerTests {
     // Attach after set() — replacing a timer emits a defensive onFadeCancel.
     manager.onFadeCancel = { cancels += 1 }
 
-    try await Task.sleep(nanoseconds: 50_000_000) // 0.05s — before the fade window
+    clock.advance(to: 0.05) // before the fade window
     #expect(fadeStarts.isEmpty)
     #expect(manager.get() != nil)
 
-    try await Task.sleep(nanoseconds: 170_000_000) // ~0.22s — inside the fade window
+    clock.advance(to: 0.22) // inside the fade window
     #expect(fadeStarts == [0.15])
     #expect(completes == 0)
 
-    try await Task.sleep(nanoseconds: 180_000_000) // ~0.40s — past the deadline
+    clock.advance(to: 0.4) // past the deadline
     #expect(completes == 1)
     #expect(cancels == 0)
     #expect(manager.get() == nil)
   }
 
   @Test @MainActor
-  func fadeLongerThanTimer_clampsAndStartsImmediately() async throws {
-    let manager = SleepTimerManager()
+  func fadeLongerThanTimer_clampsAndStartsImmediately() {
+    let clock = ManualSleepTimerScheduler()
+    let manager = SleepTimerManager(scheduler: clock)
     var fadeStarts: [TimeInterval] = []
     manager.onFadeStart = { fadeStarts.append($0) }
 
     manager.set(seconds: 0.2, fadeDuration: 5)
 
-    try await Task.sleep(nanoseconds: 100_000_000) // 0.1s — fade should have begun
+    clock.advance(to: 0.1) // fade should have begun
     #expect(fadeStarts == [0.2])
   }
 
   @Test @MainActor
-  func clear_emitsFadeCancel_andCancelsScheduledFade() async throws {
-    let manager = SleepTimerManager()
+  func clear_emitsFadeCancel_andCancelsScheduledFade() {
+    let clock = ManualSleepTimerScheduler()
+    let manager = SleepTimerManager(scheduler: clock)
     var fadeStarts = 0
     manager.set(seconds: 0.2, fadeDuration: 0.15)
     var cancels = 0
@@ -58,13 +60,13 @@ struct SleepTimerManagerTests {
     #expect(manager.clear())
     #expect(cancels == 1)
 
-    try await Task.sleep(nanoseconds: 300_000_000) // well past the would-be deadline
+    clock.advance(to: 0.3) // well past the would-be deadline
     #expect(fadeStarts == 0)
   }
 
   @Test @MainActor
   func replacingTimer_emitsFadeCancel() {
-    let manager = SleepTimerManager()
+    let manager = SleepTimerManager(scheduler: ManualSleepTimerScheduler())
     manager.set(seconds: 60, fadeDuration: 10)
     var cancels = 0
     manager.onFadeCancel = { cancels += 1 }
@@ -76,7 +78,7 @@ struct SleepTimerManagerTests {
 
   @Test @MainActor
   func switchingToEndOfTrack_emitsFadeCancel() {
-    let manager = SleepTimerManager()
+    let manager = SleepTimerManager(scheduler: ManualSleepTimerScheduler())
     manager.set(seconds: 60, fadeDuration: 10)
     var cancels = 0
     manager.onFadeCancel = { cancels += 1 }
@@ -88,8 +90,9 @@ struct SleepTimerManagerTests {
   }
 
   @Test @MainActor
-  func noFadeDuration_schedulesNoFade() async throws {
-    let manager = SleepTimerManager()
+  func noFadeDuration_schedulesNoFade() {
+    let clock = ManualSleepTimerScheduler()
+    let manager = SleepTimerManager(scheduler: clock)
     var fadeStarts = 0
     var completes = 0
     manager.onFadeStart = { _ in fadeStarts += 1 }
@@ -97,7 +100,7 @@ struct SleepTimerManagerTests {
 
     manager.set(seconds: 0.1)
 
-    try await Task.sleep(nanoseconds: 200_000_000)
+    clock.advance(to: 0.2)
     #expect(fadeStarts == 0)
     #expect(completes == 1)
   }

package/ios/Tests/Support/ManualSleepTimerScheduler.swift

@@ -0,0 +1,47 @@
+@testable import AudioBrowserTestable
+import Foundation
+
+/// A job handed back by `ManualSleepTimerScheduler`.
+private final class ManualJob: SleepTimerJob {
+  nonisolated(unsafe) var isCancelled = false
+  func cancel() { isCancelled = true }
+}
+
+/// Deterministic stand-in for the main-queue scheduler: jobs fire only when the
+/// test advances the clock, so an assertion can never lose a race against a
+/// real deadline on a loaded CI runner.
+@MainActor
+final class ManualSleepTimerScheduler: SleepTimerScheduling {
+  private struct Entry {
+    let deadline: TimeInterval
+    let job: ManualJob
+    let work: @MainActor () -> Void
+  }
+
+  private var entries: [Entry] = []
+  private(set) var now: TimeInterval = 0
+
+  func schedule(
+    after delay: TimeInterval,
+    _ work: @escaping @Sendable @MainActor () -> Void,
+  ) -> any SleepTimerJob {
+    let job = ManualJob()
+    entries.append(Entry(deadline: now + delay, job: job, work: work))
+    return job
+  }
+
+  /// Moves the virtual clock to `time`, firing every due job in deadline order.
+  /// Jobs run one at a time so a job that schedules or cancels another (the
+  /// fade landing before completion) sees the same ordering it would in
+  /// production.
+  func advance(to time: TimeInterval) {
+    now = time
+    while let next = entries
+      .filter({ !$0.job.isCancelled && $0.deadline <= now })
+      .min(by: { $0.deadline < $1.deadline })
+    {
+      entries.removeAll { $0.job === next.job }
+      next.work()
+    }
+  }
+}

package/ios/Tests/Support/TestTypes.swift

@@ -209,7 +209,7 @@ final class MockRetryHandling: RetryHandling {
   var attemptRetryDelayNs: UInt64 = 0
   var resetCallCount = 0
 
-  func isRetryable(_: Error?) -> Bool { isRetryableResult }
+  func isRetryable(_: Error?, httpStatusCode _: Int?) -> Bool { isRetryableResult }
   func attemptRetry(startFromCurrentTime _: Bool) async -> Bool {
     if attemptRetryDelayNs > 0 {
       try? await Task.sleep(nanoseconds: attemptRetryDelayNs)

package/ios/Tests/TabBarEntriesTests.swift

@@ -5,11 +5,11 @@ import Testing
 struct TabBarEntriesTests {
   private func tab(
     _ title: String, url: String, artwork: String? = nil,
-    artworkSource: ImageSource? = nil, artist: String? = nil
+    artworkSource: ImageSource? = nil, artist: String? = nil,
   ) -> Track {
     Track(
       id: url, url: url, title: title, artist: artist, artwork: artwork.map { .first($0) },
-      artworkSource: artworkSource
+      artworkSource: artworkSource,
     )
   }
 
@@ -22,7 +22,7 @@ struct TabBarEntriesTests {
     #expect(
       !TabBarEntries.same(
         [tab("Explore", url: "/explore")],
-        [tab("Verkennen", url: "/explore")]
+        [tab("Verkennen", url: "/explore")],
       ))
   }
 
@@ -30,7 +30,7 @@ struct TabBarEntriesTests {
     #expect(
       !TabBarEntries.same(
         [tab("Explore", url: "/explore")],
-        [tab("Explore", url: "/discover")]
+        [tab("Explore", url: "/discover")],
       ))
   }
 
@@ -38,7 +38,7 @@ struct TabBarEntriesTests {
     #expect(
       !TabBarEntries.same(
         [tab("Explore", url: "/explore", artwork: "sf:globe")],
-        [tab("Explore", url: "/explore", artwork: "sf:map")]
+        [tab("Explore", url: "/explore", artwork: "sf:map")],
       ))
   }
 
@@ -46,7 +46,7 @@ struct TabBarEntriesTests {
     #expect(
       !TabBarEntries.same(
         [tab("Explore", url: "/explore", artworkSource: ImageSource(uri: "https://a/1.png"))],
-        [tab("Explore", url: "/explore", artworkSource: ImageSource(uri: "https://a/2.png"))]
+        [tab("Explore", url: "/explore", artworkSource: ImageSource(uri: "https://a/2.png"))],
       ))
   }
 
@@ -65,7 +65,7 @@ struct TabBarEntriesTests {
     #expect(
       TabBarEntries.same(
         [tab("Explore", url: "/explore", artist: "a")],
-        [tab("Explore", url: "/explore", artist: "b")]
+        [tab("Explore", url: "/explore", artist: "b")],
       ))
   }
 }

package/ios/TrackPlayer.swift

@@ -463,6 +463,11 @@ class TrackPlayer {
 
   func destroy() {
     clear()
+    // An AVPlayer retains its time observers: one left registered is still attached when the
+    // player is released, and outlives this object.
+    playerTimeObserver.unregisterForBoundaryTimeEvents()
+    playerObserver.stopObserving()
+    stopObservingAVPlayerItem()
     remoteCommandController.disableAll()
   }
 
@@ -753,7 +758,7 @@ extension TrackPlayer {
         repeatMode: repeatMode.persistedString,
         shuffleEnabled: shuffleEnabled,
         playbackSpeed: rate,
-      )
+      ),
     )
   }