react-native-audio-browser 0.2.0-next.8 → 0.2.0

package/ios/Tests/PlaybackStateMachineTests.swift

@@ -76,7 +76,7 @@ struct LoadSeekCompletedTests {
     for state in allStates where state != .loading {
       #expect(
         nextPlaybackState(from: state, on: .loadSeekCompleted) == nil,
-        "Expected nil from \(state), got non-nil",
+        "Expected nil from \(state), got non-nil"
       )
     }
   }
@@ -95,33 +95,24 @@ struct AVPlayerPausedTests {
     #expect(nextPlaybackState(from: .error, on: .avPlayerPaused(hasAsset: true)) == nil)
   }
 
-  /// After a natural end the play intent is cleared, so the call-site
-  /// `!playWhenReady` gate no longer swallows stray pause observations —
-  /// without this guard a late timeControlStatus pause would re-report
-  /// .ended as .paused. (hasAsset: false still maps to .none: an emptied
-  /// element after ended is "nothing loaded".)
-  @Test func fromEnded_hasAssetTrue_isSuppressed() {
-    #expect(nextPlaybackState(from: .ended, on: .avPlayerPaused(hasAsset: true)) == nil)
-  }
-
   @Test func hasAssetFalse_transitionsToNone() {
     // hasAsset: false → .none from any non-stopped state
     let nonStoppedStates = allStates.filter { $0 != .stopped }
     for state in nonStoppedStates {
       #expect(
         nextPlaybackState(from: state, on: .avPlayerPaused(hasAsset: false)) == PlaybackState.none,
-        "Expected .none from \(state) with hasAsset: false",
+        "Expected .none from \(state) with hasAsset: false"
       )
     }
   }
 
   @Test func hasAssetTrue_transitionsToPaused() {
-    // hasAsset: true → .paused from states that aren't stopped, error, or ended
-    let validStates = allStates.filter { $0 != .stopped && $0 != .error && $0 != .ended }
+    // hasAsset: true → .paused from states that aren't stopped or error
+    let validStates = allStates.filter { $0 != .stopped && $0 != .error }
     for state in validStates {
       #expect(
         nextPlaybackState(from: state, on: .avPlayerPaused(hasAsset: true)) == .paused,
-        "Expected .paused from \(state) with hasAsset: true",
+        "Expected .paused from \(state) with hasAsset: true"
       )
     }
   }
@@ -129,10 +120,8 @@ struct AVPlayerPausedTests {
 
 // MARK: - bufferingSufficient
 
-@Suite("bufferingSufficient — suppressed from terminal states and .playing")
+@Suite("bufferingSufficient — suppressed from .playing and .ended")
 struct BufferingSufficientTests {
-  private let suppressedStates: [PlaybackState] = [.playing, .ended, .stopped, .error]
-
   @Test func fromPlaying_isSuppressed() {
     #expect(nextPlaybackState(from: .playing, on: .bufferingSufficient) == nil)
   }
@@ -144,25 +133,11 @@ struct BufferingSufficientTests {
     #expect(nextPlaybackState(from: .ended, on: .bufferingSufficient) == nil)
   }
 
-  /// stop() seeks non-live tracks back to 0 with the asset still loaded, so the
-  /// buffer refill flips playbackLikelyToKeepUp right after stopping. Leaving
-  /// .stopped would both surface a wrong state and skip the reload-on-play path
-  /// (which only triggers from .stopped/.error).
-  @Test func fromStopped_isSuppressed() {
-    #expect(nextPlaybackState(from: .stopped, on: .bufferingSufficient) == nil)
-  }
-
-  /// Recovery from .error always goes through a reload (→ .loading); a direct
-  /// jump to .ready would clear playbackError without recovering anything.
-  @Test func fromError_isSuppressed() {
-    #expect(nextPlaybackState(from: .error, on: .bufferingSufficient) == nil)
-  }
-
   @Test func fromOtherStates_transitionsToReady() {
-    for state in allStates where !suppressedStates.contains(state) {
+    for state in allStates where state != .playing && state != .ended {
       #expect(
         nextPlaybackState(from: state, on: .bufferingSufficient) == .ready,
-        "Expected .ready from \(state)",
+        "Expected .ready from \(state)"
       )
     }
   }

package/ios/Tests/QueueManagerTests.swift

@@ -390,16 +390,16 @@ struct AddAtTests {
     #expect(try q.addAt([], at: 0) == false)
   }
 
-  @Test func singleExistingTrack_insertBeforeCurrent_shifts() throws {
+  @Test func singleExistingTrack_insertBeforeCurrent_doesNotShift() throws {
     let q = QueueManager()
     q.setQueue(tracks("a"))
+    // guard `tracks.count > 1` is false (count is 1), so currentIndex is NOT shifted.
+    // The original track moves to index 1 but currentIndex stays 0.
     let changed = try q.addAt(tracks("x"), at: 0)
     #expect(changed == false)
-    // The pointer follows the playing track — the old `tracks.count > 1`
-    // guard silently swapped currentTrack to the inserted track while the
-    // player kept playing the old one.
-    #expect(q.currentIndex == 1)
-    #expect(q.currentTrack?.id == "a")
+    #expect(q.currentIndex == 0)
+    // currentTrack is now "x" (the inserted track), not "a"
+    #expect(q.currentTrack?.id == "x")
   }
 
   @Test func atExactCurrentIndex_shiftsCurrentIndex() throws {
@@ -524,17 +524,13 @@ struct RemoveTests {
 @Suite("move()")
 @MainActor
 struct MoveTests {
-  // A move never changes which track is current — the pointer follows the
-  // track, and no move returns true (true triggers a reload at the caller,
-  // which would restart playback on a reorder).
-
-  @Test func currentTrack_pointerFollows() throws {
+  @Test func currentTrack_returnsTrue_updatesIndex() throws {
     let q = QueueManager()
     q.setQueue(tracks("a", "b", "c"), initialIndex: 0)
     let changed = try q.move(fromIndex: 0, toIndex: 2)
-    #expect(changed == false)
+    #expect(changed == true)
     #expect(q.currentIndex == 2)
-    #expect(q.currentTrack?.id == "a")
+    #expect(q.tracks[2].id == "a")
   }
 
   @Test func nonCurrent_returnsFalse() throws {
@@ -552,37 +548,26 @@ struct MoveTests {
     }
   }
 
-  @Test func nonCurrent_acrossCurrent_keepsPointerOnSameTrack() throws {
+  @Test func nonCurrent_acrossCurrent_doesNotAdjustIndex() throws {
     let q = QueueManager()
     q.setQueue(tracks("a", "b", "c"), initialIndex: 1)
+    // Move track from before current to after current.
+    // currentIndex is NOT adjusted (only adjusted when fromIndex == currentIndex).
     let changed = try q.move(fromIndex: 0, toIndex: 2)
     #expect(changed == false)
-    // [a,b,c] → [b,c,a]; "b" is now index 0.
-    #expect(q.currentTrack?.id == "b")
-    #expect(q.currentIndex == 0)
-  }
-
-  @Test func nonCurrent_acrossCurrentBackwards_keepsPointerOnSameTrack() throws {
-    let q = QueueManager()
-    q.setQueue(tracks("a", "b", "c"), initialIndex: 1)
-    let changed = try q.move(fromIndex: 2, toIndex: 0)
-    #expect(changed == false)
-    // [a,b,c] → [c,a,b]; "b" is now index 2.
-    #expect(q.currentTrack?.id == "b")
-    #expect(q.currentIndex == 2)
+    #expect(q.currentIndex == 1)
+    // After remove(0): [b, c], insert at min(2,2)=2: [b, c, a]
+    // currentIndex 1 now points to "c", not "b"
+    #expect(q.currentTrack?.id == "c")
   }
 
-  @Test func toIndexBeyondCount_clampsPointerToo() throws {
+  @Test func toIndexBeyondCount_clampsToEnd() throws {
     let q = QueueManager()
     q.setQueue(tracks("a", "b", "c"), initialIndex: 0)
     let changed = try q.move(fromIndex: 0, toIndex: 99)
-    #expect(changed == false)
+    #expect(changed == true)
     // remove(0): [b, c], insert at min(2, 99)=2: [b, c, a]
     #expect(q.tracks[2].id == "a")
-    // The unclamped assignment left currentIndex at 99 → currentTrack nil →
-    // a reorder unloaded playback.
-    #expect(q.currentIndex == 2)
-    #expect(q.currentTrack?.id == "a")
   }
 
   @Test func invalidFromIndex_throws() {
@@ -621,23 +606,6 @@ struct ClearTests {
     let q = QueueManager()
     #expect(q.clear() == false)
   }
-
-  /// clear() and removeUpcomingTracks() were the only mutations not
-  /// maintaining the shuffle order — a stale order over a rebuilt queue
-  /// navigates to phantom indices, nil-ing currentTrack and unloading
-  /// playback mid-session.
-  @Test func clear_alsoClearsShuffleOrder() {
-    let q = QueueManager()
-    q.shuffleEnabled = true
-    q.setQueue(tracks("a", "b", "c", "d", "e"))
-
-    q.clear()
-
-    #expect(q.shuffleOrder.shuffled.isEmpty)
-
-    _ = try? q.addAt(tracks("x", "y"), at: 0)
-    #expect(q.shuffleOrder.shuffled.count == q.tracks.count)
-  }
 }
 
 // MARK: - Other: replace, removeUpcomingTracks
@@ -652,16 +620,6 @@ struct OtherMutationTests {
     #expect(q.tracks[1].id == "B")
   }
 
-  @Test func removeUpcomingTracks_alsoTrimsShuffleOrder() {
-    let q = QueueManager()
-    q.shuffleEnabled = true
-    q.setQueue(tracks("a", "b", "c", "d", "e"), initialIndex: 1)
-
-    q.removeUpcomingTracks()
-
-    #expect(q.shuffleOrder.shuffled.count == q.tracks.count)
-  }
-
   @Test func removeUpcomingTracks_keepsCurrentAndBefore() {
     let q = QueueManager()
     q.setQueue(tracks("a", "b", "c", "d"), initialIndex: 1)
@@ -920,92 +878,3 @@ struct DelegateTests {
     #expect(spy.calls.isEmpty)
   }
 }
-
-// MARK: - canNext / canPrevious
-
-@Suite("canNext / canPrevious")
-@MainActor
-struct SkipAvailabilityTests {
-  @Test func emptyQueue_bothFalse() {
-    let q = QueueManager()
-    #expect(q.canNext == false)
-    #expect(q.canPrevious == false)
-  }
-
-  @Test func singleTrack_repeatOff_bothFalse() {
-    let q = QueueManager()
-    q.setQueue(tracks("a"))
-    #expect(q.canNext == false)
-    #expect(q.canPrevious == false)
-  }
-
-  @Test func singleTrack_repeatQueue_bothFalse() {
-    let q = QueueManager()
-    q.setQueue(tracks("a"))
-    q.repeatMode = .queue
-    #expect(q.canNext == false)
-    #expect(q.canPrevious == false)
-  }
-
-  @Test func firstOfMany_nextOnly() {
-    let q = QueueManager()
-    q.setQueue(tracks("a", "b", "c"), initialIndex: 0)
-    #expect(q.canNext == true)
-    #expect(q.canPrevious == false)
-  }
-
-  @Test func middleOfMany_both() {
-    let q = QueueManager()
-    q.setQueue(tracks("a", "b", "c"), initialIndex: 1)
-    #expect(q.canNext == true)
-    #expect(q.canPrevious == true)
-  }
-
-  @Test func lastOfMany_repeatOff_previousOnly() {
-    let q = QueueManager()
-    q.setQueue(tracks("a", "b", "c"), initialIndex: 2)
-    #expect(q.canNext == false)
-    #expect(q.canPrevious == true)
-  }
-
-  @Test func lastOfMany_repeatQueue_bothTrue() {
-    let q = QueueManager()
-    q.setQueue(tracks("a", "b", "c"), initialIndex: 2)
-    q.repeatMode = .queue
-    #expect(q.canNext == true) // wraps to first
-    #expect(q.canPrevious == true)
-  }
-
-  @Test func firstOfMany_repeatQueue_bothTrue() {
-    let q = QueueManager()
-    q.setQueue(tracks("a", "b", "c"), initialIndex: 0)
-    q.repeatMode = .queue
-    #expect(q.canNext == true)
-    #expect(q.canPrevious == true) // wraps to last
-  }
-
-  // Shuffle wraps the playback order unconditionally (even with repeat off), so
-  // next()/previous() always move when count > 1 — canNext/canPrevious must
-  // agree at the shuffle-order boundaries, not grey out.
-  @Test func shuffleEnd_repeatOff_canNextTrue() {
-    let q = QueueManager()
-    q.setQueue(tracks("a", "b", "c", "d"))
-    q.shuffleEnabled = true
-    q.repeatMode = .off
-    while !q.isLastInPlaybackOrder {
-      _ = q.next()
-    } // advance to last in shuffle order
-    #expect(q.canNext == true) // next() wraps to the first shuffle position
-  }
-
-  @Test func shuffleStart_repeatOff_canPreviousTrue() {
-    let q = QueueManager()
-    q.setQueue(tracks("a", "b", "c", "d"))
-    q.shuffleEnabled = true
-    q.repeatMode = .off
-    while !q.previousTracks.isEmpty {
-      _ = q.previous()
-    } // back to first in shuffle order
-    #expect(q.canPrevious == true) // previous() wraps to the last shuffle position
-  }
-}

package/ios/Tests/ResolvedTrackCopyingTests.swift

@@ -4,7 +4,7 @@ import Testing
 
 private func makeResolvedTrack(
   url: String = "/test",
-  title: String = "Test Track",
+  title: String = "Test Track"
 ) -> ResolvedTrack {
   ResolvedTrack(
     url: url,
@@ -26,7 +26,7 @@ private func makeResolvedTrack(
     favorited: nil,
     groupTitle: nil,
     live: nil,
-    imageRow: nil,
+    imageRow: nil
   )
 }
 
@@ -35,9 +35,8 @@ private func makeFullResolvedTrack() -> ResolvedTrack {
     url: "/original",
     children: [Track(id: "t1", url: "/t1")],
     carPlaySiriListButton: .top,
-    id: "original-id",
     src: "src.mp3",
-    artwork: .first("art.jpg"),
+    artwork: "art.jpg",
     artworkSource: ImageSource(uri: "resolved-art.jpg"),
     artworkCarPlayTinted: true,
     title: "Original Title",
@@ -52,7 +51,7 @@ private func makeFullResolvedTrack() -> ResolvedTrack {
     favorited: true,
     groupTitle: "Group A",
     live: false,
-    imageRow: [ImageRowItem(title: "Row 1")],
+    imageRow: [ImageRowItem(title: "Row 1")]
   )
 }
 
@@ -96,16 +95,10 @@ private func makeFullResolvedTrack() -> ResolvedTrack {
   #expect(copy.src == "new-src.mp3")
 }
 
-@Test func copyingOverridesId() {
-  let original = makeResolvedTrack()
-  let copy = original.copying(id: "new-id")
-  #expect(copy.id == "new-id")
-}
-
 @Test func copyingOverridesArtwork() {
   let original = makeResolvedTrack()
-  let copy = original.copying(artwork: .some(.first("new-art.jpg")))
-  #expect(copy.artwork?.url == "new-art.jpg")
+  let copy = original.copying(artwork: "new-art.jpg")
+  #expect(copy.artwork == "new-art.jpg")
 }
 
 @Test func copyingOverridesArtworkSource() {
@@ -210,7 +203,7 @@ private func makeFullResolvedTrack() -> ResolvedTrack {
     title: "Updated Title",
     artist: "New Artist",
     duration: 240.0,
-    favorited: true,
+    favorited: true
   )
   #expect(copy.url == "/updated")
   #expect(copy.title == "Updated Title")
@@ -234,7 +227,7 @@ private func makeFullResolvedTrack() -> ResolvedTrack {
   #expect(copy.children?.count == 1)
   #expect(copy.carPlaySiriListButton == .top)
   #expect(copy.src == "src.mp3")
-  #expect(copy.artwork?.url == "art.jpg")
+  #expect(copy.artwork == "art.jpg")
   #expect(copy.artworkSource == ImageSource(uri: "resolved-art.jpg"))
   #expect(copy.artworkCarPlayTinted == true)
   #expect(copy.subtitle == "Original Subtitle")

package/ios/Tests/Support/TestTypes.swift

@@ -1,8 +1,8 @@
 // This file is intentionally empty — mock types live in
 // Model/NitroTypeStubs.swift (part of the AudioBrowserTestable target).
 
-@testable import AudioBrowserTestable
 import AVFoundation
+@testable import AudioBrowserTestable
 
 /// Creates an AVMetadataItem with the specified properties for testing.
 func makeMetadataItem(
@@ -10,7 +10,7 @@ func makeMetadataItem(
   commonKey: AVMetadataKey? = nil,
   keySpace: AVMetadataKeySpace? = nil,
   key: String? = nil,
-  value: String,
+  value: String
 ) -> AVMetadataItem {
   let item = AVMutableMetadataItem()
   if let identifier {
@@ -41,9 +41,6 @@ final class MockPlaybackEffectHandler: PlaybackEffectHandler {
   func pausePlayback() { pausePlaybackCallCount += 1 }
   func setTimePitchingAlgorithmForCurrentItem() { setTimePitchCallCount += 1 }
 
-  // Player volume
-  var volume: Float = 1
-
   // AVPlayer state queries
   var currentTime: Double = 0
   var duration: Double = 0
@@ -59,16 +56,11 @@ final class MockPlaybackEffectHandler: PlaybackEffectHandler {
 
   // Track loading
   var loadTrackCalls: [String] = []
-  var loadTrackTracks: [Track] = []
   var reloadTrackCalls: [Bool] = []
   var unloadTrackCallCount = 0
   var cancelMediaLoadingCallCount = 0
 
-  func loadTrack(src: String, track: Track) {
-    loadTrackCalls.append(src)
-    loadTrackTracks.append(track)
-  }
-
+  func loadTrack(src: String) { loadTrackCalls.append(src) }
   func reloadTrack(startFromCurrentTime: Bool) { reloadTrackCalls.append(startFromCurrentTime) }
   func unloadTrack() { unloadTrackCallCount += 1 }
   func cancelMediaLoading() { cancelMediaLoadingCallCount += 1 }
@@ -81,18 +73,27 @@ final class MockPlaybackEffectHandler: PlaybackEffectHandler {
   func replayCurrentTrack() { replayCurrentTrackCallCount += 1 }
 
   // Now Playing
-  var loadNowPlayingMetadataCalls: [Track] = []
-  var clearNowPlayingCallCount = 0
+  var updateNowPlayingValuesCalls: [(duration: Double, rate: Float, currentTime: Double)] = []
   var updateNowPlayingStateCalls: [Bool] = []
+  var loadNowPlayingMetadataCalls: [(track: Track, rate: Float)] = []
+  var resetNowPlayingValuesCallCount = 0
+  var clearNowPlayingCallCount = 0
+  var setNowPlayingCurrentTimeCalls: [Double] = []
 
-  func loadNowPlayingMetadata(for track: Track) {
-    loadNowPlayingMetadataCalls.append(track)
+  func updateNowPlayingValues(duration: Double, rate: Float, currentTime: Double) {
+    updateNowPlayingValuesCalls.append((duration, rate, currentTime))
   }
-
-  func clearNowPlaying() { clearNowPlayingCallCount += 1 }
   func updateNowPlayingState(playWhenReady: Bool) {
     updateNowPlayingStateCalls.append(playWhenReady)
   }
+  func loadNowPlayingMetadata(for track: Track, rate: Float) {
+    loadNowPlayingMetadataCalls.append((track, rate))
+  }
+  func resetNowPlayingValues() { resetNowPlayingValuesCallCount += 1 }
+  func clearNowPlaying() { clearNowPlayingCallCount += 1 }
+  func setNowPlayingCurrentTime(seconds: Double) {
+    setNowPlayingCurrentTimeCalls.append(seconds)
+  }
 
   // Remote commands
   var updateRemoteRepeatModeCalls: [RepeatMode] = []
@@ -101,15 +102,9 @@ final class MockPlaybackEffectHandler: PlaybackEffectHandler {
   func updateRemoteRepeatMode(_ mode: RepeatMode) {
     updateRemoteRepeatModeCalls.append(mode)
   }
-
   func updateRemoteShuffleMode(_ enabled: Bool) {
     updateRemoteShuffleModeCalls.append(enabled)
   }
-
-  var updateSkipAvailabilityCalls: [(canNext: Bool, canPrevious: Bool)] = []
-  func updateSkipAvailability(canNext: Bool, canPrevious: Bool) {
-    updateSkipAvailabilityCalls.append((canNext, canPrevious))
-  }
 }
 
 // MARK: - Mock PlaybackCoordinatorCallbacks
@@ -126,56 +121,37 @@ final class MockPlaybackCoordinatorCallbacks: PlaybackCoordinatorCallbacks {
   var repeatModeChanges: [RepeatModeChangedEvent] = []
   var shuffleEnabledChanges: [Bool] = []
   var errorEvents: [PlaybackErrorEvent] = []
-  var playbackIntervalFiredCount = 0
-  var releaseSessionCount = 0
 
   func playerDidChangePlayback(_ playback: Playback) {
     playbackChanges.append(playback)
   }
-
   func playerDidChangeActiveTrack(_ event: PlaybackActiveTrackChangedEvent) {
     activeTrackChanges.append(event)
   }
-
   func playerDidUpdateProgress(_ event: PlaybackProgressUpdatedEvent) {
     progressUpdates.append(event)
   }
-
-  func playerDidFirePlaybackInterval() {
-    playbackIntervalFiredCount += 1
-  }
-
   func playerDidChangePlayWhenReady(_ playWhenReady: Bool) {
     playWhenReadyChanges.append(playWhenReady)
   }
-
   func playerDidChangePlayingState(_ state: PlayingState) {
     playingStateChanges.append(state)
   }
-
   func playerDidEndQueue(_ event: PlaybackQueueEndedEvent) {
     queueEndedEvents.append(event)
   }
-
   func playerDidChangeQueue(_ tracks: [Track]) {
     queueChanges.append(tracks)
   }
-
   func playerDidChangeRepeatMode(_ event: RepeatModeChangedEvent) {
     repeatModeChanges.append(event)
   }
-
   func playerDidChangeShuffleEnabled(_ enabled: Bool) {
     shuffleEnabledChanges.append(enabled)
   }
-
   func playerDidError(_ event: PlaybackErrorEvent) {
     errorEvents.append(event)
   }
-
-  func playerShouldReleaseSession() {
-    releaseSessionCount += 1
-  }
 }
 
 // MARK: - Mock SleepTimerHandling
@@ -183,16 +159,8 @@ final class MockPlaybackCoordinatorCallbacks: PlaybackCoordinatorCallbacks {
 @MainActor
 final class MockSleepTimerHandling: SleepTimerHandling {
   var onComplete: (() -> Void)?
-  var onFadeStart: ((_ duration: TimeInterval) -> Void)?
-  var onFadeCancel: (() -> Void)?
   var trackChangedCallCount = 0
   var trackPlayedToEndCallCount = 0
-  var clearCallCount = 0
-
-  @discardableResult func clear() -> Bool {
-    clearCallCount += 1
-    return true
-  }
 
   func onTrackChanged() { trackChangedCallCount += 1 }
   func onTrackPlayedToEnd() { trackPlayedToEndCallCount += 1 }
@@ -202,20 +170,11 @@ final class MockSleepTimerHandling: SleepTimerHandling {
 
 @MainActor
 final class MockRetryHandling: RetryHandling {
-  var isEnabled = true
-  var hasPlayed = false
   var isRetryableResult = false
   var attemptRetryResult = false
-  var attemptRetryDelayNs: UInt64 = 0
   var resetCallCount = 0
 
-  func isRetryable(_: Error?) -> Bool { isRetryableResult }
-  func attemptRetry(startFromCurrentTime _: Bool) async -> Bool {
-    if attemptRetryDelayNs > 0 {
-      try? await Task.sleep(nanoseconds: attemptRetryDelayNs)
-    }
-    return attemptRetryResult
-  }
-
+  func isRetryable(_ error: Error?) -> Bool { isRetryableResult }
+  func attemptRetry(startFromCurrentTime: Bool) async -> Bool { attemptRetryResult }
   func reset() { resetCallCount += 1 }
 }

package/ios/Tests/TrackSelectorTests.swift

@@ -7,8 +7,8 @@ import Testing
 @MainActor
 private final class BrowserMock: TrackSelectionBrowser {
   var trackLoadHandlerResult = false
-  var expandQueueResult: (tracks: [Track], selectedIndex: Int)?
-  var expandQueueError: Error?
+  var expandQueueResult: (tracks: [Track], selectedIndex: Int)? = nil
+  var expandQueueError: Error? = nil
 
   // Record calls for verification
   var trackLoadEvents: [TrackLoadEvent] = []
@@ -31,7 +31,7 @@ private final class BrowserMock: TrackSelectionBrowser {
 @MainActor
 private final class PlayerMock: TrackSelectionPlayer {
   var tracks: [Track] = []
-  var queueSourcePath: String?
+  var queueSourcePath: String? = nil
 }
 
 private enum MockError: Error {
@@ -57,7 +57,7 @@ struct BrowsableTrackTests {
     let (selector, _, player) = makeSelector()
     let track = Track(id: "t1", url: "/some/path")
     let result = await selector.select(track: track, player: player)
-    guard case let .browse(url) = result else {
+    guard case .browse(let url) = result else {
       Issue.record("expected .browse, got \(result)")
       return
     }
@@ -90,11 +90,11 @@ struct PlayableTrackTests {
     let (selector, browser, player) = makeSelector()
     let track = Track(id: "t1", src: "https://example.com/audio.mp3")
     let result = await selector.select(track: track, player: player)
-    guard case let .play(intent) = result else {
+    guard case .play(let intent) = result else {
       Issue.record("expected .play, got \(result)")
       return
     }
-    guard case let .loadTrack(loaded) = intent else {
+    guard case .loadTrack(let loaded) = intent else {
       Issue.record("expected .loadTrack, got \(intent)")
       return
     }
@@ -135,11 +135,11 @@ struct ContextualUrlQueueReuseTests {
 
     let track = Track(id: "t1", url: contextualUrl, src: trackSrc)
     let result = await selector.select(track: track, player: player)
-    guard case let .play(intent) = result else {
+    guard case .play(let intent) = result else {
       Issue.record("expected .play, got \(result)")
       return
     }
-    guard case let .skipTo(index) = intent else {
+    guard case .skipTo(let index) = intent else {
       Issue.record("expected .skipTo, got \(intent)")
       return
     }
@@ -189,11 +189,11 @@ struct ContextualUrlExpansionTests {
 
     let track = Track(id: "t1", url: contextualUrl, src: trackSrc)
     let result = await selector.select(track: track, player: player)
-    guard case let .play(intent) = result else {
+    guard case .play(let intent) = result else {
       Issue.record("expected .play, got \(result)")
       return
     }
-    guard case let .setQueue(tracks, startIndex, sourcePath) = intent else {
+    guard case .setQueue(let tracks, let startIndex, let sourcePath) = intent else {
       Issue.record("expected .setQueue, got \(intent)")
       return
     }
@@ -213,7 +213,7 @@ struct ContextualUrlExpansionTests {
 
     browser.expandQueueResult = (
       tracks: [Track(id: "a", src: "song.mp3")],
-      selectedIndex: 0,
+      selectedIndex: 0
     )
 
     let track = Track(id: "t1", url: contextualUrl, src: trackSrc)
@@ -234,11 +234,11 @@ struct ContextualUrlExpansionTests {
 
     let track = Track(id: "t1", url: contextualUrl, src: trackSrc)
     let result = await selector.select(track: track, player: player)
-    guard case let .play(intent) = result else {
+    guard case .play(let intent) = result else {
       Issue.record("expected .play, got \(result)")
       return
     }
-    guard case let .loadTrack(loaded) = intent else {
+    guard case .loadTrack(let loaded) = intent else {
       Issue.record("expected .loadTrack, got \(intent)")
       return
     }
@@ -255,11 +255,11 @@ struct ContextualUrlExpansionTests {
 
     let track = Track(id: "t1", url: contextualUrl, src: trackSrc)
     let result = await selector.select(track: track, player: player)
-    guard case let .play(intent) = result else {
+    guard case .play(let intent) = result else {
       Issue.record("expected .play, got \(result)")
       return
     }
-    guard case let .loadTrack(loaded) = intent else {
+    guard case .loadTrack(let loaded) = intent else {
       Issue.record("expected .loadTrack, got \(intent)")
       return
     }