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

package/ios/Player/QueueManager.swift

@@ -45,8 +45,15 @@ class QueueManager {
   /// The repeat mode for the queue. Plain property — no side effects.
   var repeatMode: RepeatMode = .off
 
-  /// Whether shuffle mode is enabled. Plain property — no side effects.
-  var shuffleEnabled: Bool = false
+  /// Whether shuffle mode is enabled.
+  var shuffleEnabled: Bool = false {
+    didSet {
+      // Re-pin on enable: the existing order has the current track wherever it happened to land,
+      // so without this, turning shuffle on near the end of the queue ends it right away.
+      guard shuffleEnabled, shuffleEnabled != oldValue else { return }
+      shuffleOrder.reshuffle(keepingFirst: currentIndex)
+    }
+  }
 
   // MARK: - Computed Properties
 
@@ -206,7 +213,7 @@ class QueueManager {
     currentIndex = clampedIndex
     queueSourcePath = sourcePath
     tracks = newTracks
-    shuffleOrder = ShuffleOrder(length: newTracks.count)
+    shuffleOrder = ShuffleOrder(length: newTracks.count, firstIndex: clampedIndex)
     return true
   }
 
@@ -218,11 +225,8 @@ class QueueManager {
     let wasEmpty = tracks.isEmpty
     let insertIndex = tracks.count
     tracks.append(contentsOf: newTracks)
+    if wasEmpty { return adoptInitialCurrent(initialIndex) }
     shuffleOrder.insert(at: insertIndex, count: newTracks.count)
-    if wasEmpty {
-      currentIndex = max(0, min(initialIndex, tracks.count - 1))
-      return true
-    }
     return false
   }
 
@@ -243,14 +247,31 @@ class QueueManager {
       currentIndex += newTracks.count
     }
     tracks.insert(contentsOf: newTracks, at: index)
+    if wasEmpty { return adoptInitialCurrent(0) }
     shuffleOrder.insert(at: index, count: newTracks.count)
-    if wasEmpty {
-      currentIndex = 0
-      return true
-    }
     return false
   }
 
+  /// The queue was empty: `index` becomes the current track AND leads the
+  /// shuffle order. One operation because the two must not be separable —
+  /// forgetting the second half is the bug this exists to prevent.
+  ///
+  /// `insert(at:count:)` drops new indices at *random* shuffle positions, so
+  /// without the pin the starting track can land last in the order, which reads
+  /// as `isLastInPlaybackOrder`: the queue "ends" (and fires
+  /// `playerDidEndQueue`) the moment the first track finishes. Pins
+  /// unconditionally, like `setQueue` — the order has to be sane whether or not
+  /// shuffle is on right now, since `shuffleEnabled`'s didSet only re-pins on
+  /// the off→on edge.
+  ///
+  /// Returns true, so callers can `return adoptInitialCurrent(…)` to report the
+  /// current track changed.
+  private func adoptInitialCurrent(_ index: Int) -> Bool {
+    currentIndex = max(0, min(index, tracks.count - 1))
+    shuffleOrder = ShuffleOrder(length: tracks.count, firstIndex: currentIndex)
+    return true
+  }
+
   /// Remove a track from the queue.
   /// Returns `true` if the current track changed.
   @discardableResult
@@ -281,8 +302,18 @@ class QueueManager {
     let insertion = min(newTracks.count, toIndex)
     newTracks.insert(track, at: insertion)
     tracks = newTracks
+    // Carry the moved track's shuffle position across the move. `insert(at:count:)`
+    // would drop it at a RANDOM position instead — reordering the queue would then
+    // silently reorder shuffled playback, and moving the playing track could land it
+    // last in the order, ending the queue at the next track boundary with tracks
+    // still unplayed (the failure `adoptInitialCurrent` guards against elsewhere).
+    // `remove` shifts every later position down by one, so re-inserting at the
+    // captured position restores the exact prior order.
+    let shufflePosition = shuffleOrder.shufflePosition(of: fromIndex)
     shuffleOrder.remove(from: fromIndex, to: fromIndex + 1)
-    shuffleOrder.insert(at: insertion, count: 1)
+    shuffleOrder.insert(
+      at: insertion, atShufflePosition: shufflePosition ?? shuffleOrder.count,
+    )
     // The pointer follows the playing track; its identity never changes on a
     // move, so no caller needs to reload (returning true reloads).
     if currentIndex == fromIndex {
@@ -310,7 +341,9 @@ class QueueManager {
   // MARK: - Other Mutations
 
   /// Replace the track at a specific index.
-  func replace(_ index: Int, _ track: Track) {
+  /// Throws like every other index-taking mutation here, rather than trapping.
+  func replace(_ index: Int, _ track: Track) throws {
+    try throwIfIndexInvalid(index: index)
     tracks[index] = track
   }
 

package/ios/Player/RetryManager.swift

@@ -1,3 +1,4 @@
+import AVFoundation
 import Foundation
 #if canImport(NitroModules)
   import NitroModules
@@ -122,30 +123,90 @@ class RetryManager {
 
   // MARK: - Error Classification
 
-  func isRetryable(_ error: Error?) -> Bool {
+  /// HTTP statuses worth another attempt, beyond the 500–599 range checked in
+  /// `isRetryable`. Android's `RetryLoadErrorHandlingPolicy` shares 408/429 but
+  /// enumerates only 500/502/503/504 of the 5xx range, so uncommon 5xx codes
+  /// (501, 505…) retry here and not there.
+  private static let retryableHTTPStatusCodes: Set<Int> = [408, 429]
+
+  /// AVFoundation failures a retry cannot fix: the media is unusable rather
+  /// than the transport unreliable. Everything not listed falls through to
+  /// retry — `AVErrorUnknown` especially, which is the wrapper AVFoundation
+  /// puts around opaque CoreMedia transport failures.
+  private static let fatalAVErrorCodes: Set<Int> = [
+    AVError.fileFormatNotRecognized.rawValue,
+    AVError.failedToParse.rawValue,
+    AVError.decodeFailed.rawValue,
+    AVError.contentIsProtected.rawValue,
+    AVError.contentIsNotAuthorized.rawValue,
+  ]
+
+  /// Whether another attempt could plausibly succeed.
+  ///
+  /// Mirrors Android's `classifyError`, including its default: an unrecognized
+  /// failure is treated as *transient* and retried, bounded by the retry
+  /// budgets, rather than being terminal. Defaulting the other way made
+  /// `retry: true` largely inert on iOS, because AVFoundation reports most
+  /// stream failures as opaque `CoreMediaErrorDomain` / `AVFoundationErrorDomain`
+  /// errors rather than `URLError`.
+  ///
+  /// - Parameter httpStatusCode: The status from the item's error log, when the
+  ///   caller has one. `AVPlayerItem.error` never carries it — a 404 arrives as
+  ///   an opaque CoreMedia error — so this is the only reliable HTTP signal and
+  ///   it outranks the error itself.
+  func isRetryable(_ error: Error?, httpStatusCode: Int?) -> Bool {
+    if let status = httpStatusCode {
+      let retryable = Self.retryableHTTPStatusCodes.contains(status) || (500 ... 599).contains(status)
+      logger.debug("HTTP \(status) \(retryable ? "is" : "not") retryable")
+      return retryable
+    }
+
     guard let error else { return false }
 
-    if let urlError = error as? URLError {
-      switch urlError.code {
-      // Transient network errors - safe to retry
-      case .timedOut,
-           .networkConnectionLost,
-           .notConnectedToInternet,
-           .cannotConnectToHost,
-           .cannotFindHost,
-           .dnsLookupFailed:
-        logger.debug("URLError is retryable: code=\(urlError.code.rawValue)")
-        return true
-      default:
-        logger.debug("URLError not retryable: code=\(urlError.code.rawValue)")
+    // Walk the underlying-error chain: AVFoundation routinely wraps the real
+    // cause (a URLError, or a CoreMedia code) in an AVError.
+    for candidate in Self.errorChain(error) {
+      if let urlError = candidate as? URLError {
+        switch urlError.code {
+        // Transient network errors - safe to retry
+        case .timedOut,
+             .networkConnectionLost,
+             .notConnectedToInternet,
+             .cannotConnectToHost,
+             .cannotFindHost,
+             .dnsLookupFailed:
+          logger.debug("URLError is retryable: code=\(urlError.code.rawValue)")
+          return true
+        default:
+          logger.debug("URLError not retryable: code=\(urlError.code.rawValue)")
+          return false
+        }
+      }
+
+      let nsError = candidate as NSError
+      if nsError.domain == AVFoundationErrorDomain,
+         Self.fatalAVErrorCodes.contains(nsError.code)
+      {
+        logger.debug("AVError not retryable: code=\(nsError.code)")
         return false
       }
     }
 
-    // Unknown errors - don't retry
     let nsError = error as NSError
-    logger.debug("Error not retryable: domain=\(nsError.domain), code=\(nsError.code)")
-    return false
+    logger.debug("Treating as transient: domain=\(nsError.domain), code=\(nsError.code)")
+    return true
+  }
+
+  /// The error and its `NSUnderlyingError` ancestors, outermost first.
+  private static func errorChain(_ error: Error) -> [Error] {
+    var chain: [Error] = []
+    var current: Error? = error
+    // Bounded: a malformed cycle must not spin here.
+    while let error = current, chain.count < 8 {
+      chain.append(error)
+      current = (error as NSError).userInfo[NSUnderlyingErrorKey] as? Error
+    }
+    return chain
   }
 
   // MARK: - Retry Management
@@ -170,7 +231,8 @@ class RetryManager {
       return "max retry duration (\(maxRetryDuration)s)"
     }
     if !hasPlayed, isOnline, let start = firstOnlineRetryTime,
-       now.timeIntervalSince(start) >= firstConnectMaxRetryDuration {
+       now.timeIntervalSince(start) >= firstConnectMaxRetryDuration
+    {
       return "first-connect retry duration (\(firstConnectMaxRetryDuration)s)"
     }
     return nil

package/ios/Player/SeekCompletionHandler.swift

@@ -1,3 +1,5 @@
-@MainActor protocol SeekCompletionHandler: AnyObject {
+// Sendable so LoadSeekCoordinator can carry a delegate into AVPlayer's
+// @Sendable seek completion closure; @MainActor is what keeps that sound.
+@MainActor protocol SeekCompletionHandler: AnyObject, Sendable {
   func handleSeekCompleted(to seconds: Double, didFinish: Bool)
 }

package/ios/Player/ShuffleOrder.swift

@@ -39,6 +39,16 @@ struct ShuffleOrder {
     indexInShuffled = Self.buildIndexInShuffled(from: shuffled)
   }
 
+  /// Creates a shuffle order for the given length with `firstIndex` pinned to shuffle position 0.
+  ///
+  /// Playback starts on that track, so leaving it wherever the permutation put it would end the
+  /// queue as soon as it is reached — on average after half the queue, and immediately whenever it
+  /// lands last.
+  init(length: Int, firstIndex: Int) {
+    self.init(length: length)
+    reshuffle(keepingFirst: firstIndex)
+  }
+
   /// Creates a shuffle order with pre-defined indices
   init(shuffledIndices: [Int]) {
     shuffled = shuffledIndices
@@ -91,6 +101,13 @@ struct ShuffleOrder {
     return indexInShuffled[index] == 0
   }
 
+  /// The item's position in the shuffle order, or nil when it has none.
+  func shufflePosition(of index: Int) -> Int? {
+    guard index >= 0, index < indexInShuffled.count else { return nil }
+    let position = indexInShuffled[index]
+    return position >= 0 ? position : nil
+  }
+
   // MARK: - Mutation
 
   /// Inserts items at random positions in the shuffle order
@@ -115,6 +132,22 @@ struct ShuffleOrder {
     indexInShuffled = Self.buildIndexInShuffled(from: shuffled)
   }
 
+  /// Inserts one item at `insertionIndex`, placing it at an explicit shuffle
+  /// position rather than a random one.
+  ///
+  /// Used by a queue `move`, which permutes positions but not identities: the
+  /// item already had a place in the playback order, and re-randomising it
+  /// silently reorders playback. For the *playing* track it can drop it at the
+  /// end of the order, which then reads as `isLastInPlaybackOrder` — the queue
+  /// reports itself over at the next track end, with tracks still unplayed.
+  mutating func insert(at insertionIndex: Int, atShufflePosition position: Int) {
+    for i in 0 ..< shuffled.count where shuffled[i] >= insertionIndex {
+      shuffled[i] += 1
+    }
+    shuffled.insert(insertionIndex, at: min(max(0, position), shuffled.count))
+    indexInShuffled = Self.buildIndexInShuffled(from: shuffled)
+  }
+
   /// Removes items in the specified range from the shuffle order
   mutating func remove(from indexFrom: Int, to indexToExclusive: Int) {
     let removeCount = indexToExclusive - indexFrom

package/ios/Player/SleepTimerHandling.swift

@@ -12,4 +12,17 @@ import Foundation
   @discardableResult func clear() -> Bool
   func onTrackChanged()
   func onTrackPlayedToEnd()
+
+  // Consumer-facing surface — HybridAudioBrowser drives these through
+  // TrackPlayer, so they belong here rather than behind a concrete downcast.
+
+  /// Invoked when the timer state changes (set, cleared, completed).
+  var onChanged: ((SleepTimerState) -> Void)? { get set }
+  /// The current timer state, or nil when no timer is active.
+  func get() -> SleepTimerState?
+  /// Sets a time-based timer, optionally fading out over the last
+  /// `fadeDuration` seconds.
+  func set(seconds: TimeInterval, fadeDuration: TimeInterval?)
+  /// Sets the timer to stop playback when the current track ends.
+  func setToEndOfTrack()
 }

package/ios/RemoteCommand/RemoteCommandCallbacks.swift

@@ -0,0 +1,47 @@
+#if canImport(NitroModules)
+  import NitroModules
+#endif
+
+/// The callbacks `RemoteCommandController` invokes when the system delivers a
+/// remote command (lock screen, Control Center, CarPlay, headset).
+///
+/// Split out of `TrackPlayerCallbacks` — which the controller does not otherwise
+/// use — so the controller depends only on what it calls. `TrackPlayerCallbacks`
+/// extends this protocol, so conformers implement both at once.
+@MainActor protocol RemoteCommandCallbacks: AnyObject {
+  /// Called when play is triggered remotely.
+  func remotePlay()
+
+  /// Called when pause is triggered remotely.
+  func remotePause()
+
+  /// Called when stop is triggered remotely.
+  func remoteStop()
+
+  /// Called when toggle play/pause is triggered remotely.
+  func remotePlayPause()
+
+  /// Called when next is triggered remotely.
+  func remoteNext()
+
+  /// Called when previous is triggered remotely.
+  func remotePrevious()
+
+  /// Called when jump forward is triggered remotely.
+  func remoteJumpForward(interval: Double)
+
+  /// Called when jump backward is triggered remotely.
+  func remoteJumpBackward(interval: Double)
+
+  /// Called when seek is triggered remotely.
+  func remoteSeek(position: Double)
+
+  /// Called when repeat mode change is triggered remotely (CarPlay/lock screen).
+  func remoteChangeRepeatMode(mode: RepeatMode)
+
+  /// Called when shuffle mode change is triggered remotely (CarPlay/lock screen).
+  func remoteChangeShuffleMode(enabled: Bool)
+
+  /// Called when playback rate change is triggered remotely (CarPlay/lock screen).
+  func remoteChangePlaybackRate(rate: Float)
+}

package/ios/RemoteCommand/RemoteCommandController.swift

@@ -46,7 +46,7 @@ class RemoteCommandController {
   private let logger = Logger(subsystem: "com.audiobrowser", category: "RemoteCommandController")
   private var center: MPRemoteCommandCenter
 
-  weak var callbacks: TrackPlayerCallbacks?
+  weak var callbacks: RemoteCommandCallbacks?
 
   var commandTargetPointers: [String: Any] = [:]
   private var enabledCommands: [RemoteCommand] = []
@@ -72,7 +72,7 @@ class RemoteCommandController {
    */
   init(
     remoteCommandCenter: MPRemoteCommandCenter = MPRemoteCommandCenter.shared(),
-    callbacks: TrackPlayerCallbacks? = nil,
+    callbacks: RemoteCommandCallbacks? = nil,
   ) {
     center = remoteCommandCenter
     self.callbacks = callbacks
@@ -112,13 +112,16 @@ class RemoteCommandController {
   }
 
   func enable(commands: [RemoteCommand]) {
-    let commandsToDisable = enabledCommands.filter { command in
-      !commands.contains(command)
-    }
+    let commandsToDisable = RemoteCommand.commandsToDisable(
+      enabled: enabledCommands, replacedBy: commands,
+    )
 
     enabledCommands = commands
-    commands.forEach { self.enable(command: $0) }
+    // Disable first. The key diff already makes the two sets disjoint, so this
+    // is belt-and-braces: it keeps a disable from tearing down a command the
+    // enable pass just configured should the two ever overlap again.
     disable(commands: commandsToDisable)
+    commands.forEach { self.enable(command: $0) }
   }
 
   func disable(commands: [RemoteCommand]) {
@@ -278,24 +281,59 @@ class RemoteCommandController {
 
   // MARK: - Handlers
 
-  lazy var handlePlayCommand: RemoteCommandHandler = handlePlayCommandDefault
-  lazy var handlePauseCommand: RemoteCommandHandler = handlePauseCommandDefault
-  lazy var handleStopCommand: RemoteCommandHandler = handleStopCommandDefault
-  lazy var handleTogglePlayPauseCommand: RemoteCommandHandler =
-    handleTogglePlayPauseCommandDefault
-  lazy var handleSkipForwardCommand: RemoteCommandHandler = handleSkipForwardCommandDefault
-  lazy var handleSkipBackwardCommand: RemoteCommandHandler = handleSkipBackwardDefault
-  lazy var handleChangePlaybackPositionCommand: RemoteCommandHandler =
-    handleChangePlaybackPositionCommandDefault
-  lazy var handleNextTrackCommand: RemoteCommandHandler = handleNextTrackCommandDefault
-  lazy var handlePreviousTrackCommand: RemoteCommandHandler =
-    handlePreviousTrackCommandDefault
-  lazy var handleChangeRepeatModeCommand: RemoteCommandHandler =
-    handleChangeRepeatModeCommandDefault
-  lazy var handleChangeShuffleModeCommand: RemoteCommandHandler =
-    handleChangeShuffleModeCommandDefault
-  lazy var handleChangePlaybackRateCommand: RemoteCommandHandler =
-    handleChangePlaybackRateCommandDefault
+  // Each default is wrapped in a `[weak self]` closure rather than assigned as a
+  // bare method reference (`= handlePlayCommandDefault`): an unapplied instance
+  // method curries to `{ [self] in self.method($0) }`, which strongly captures
+  // self. Stored back onto self, that is a permanent cycle — `enable(command:)`
+  // forces every lazy init, so the controller would never deallocate, leaking one
+  // per player instance across JS reloads and re-setups.
+  lazy var handlePlayCommand: RemoteCommandHandler = { [weak self] event in
+    self?.handlePlayCommandDefault(event: event) ?? .commandFailed
+  }
+
+  lazy var handlePauseCommand: RemoteCommandHandler = { [weak self] event in
+    self?.handlePauseCommandDefault(event: event) ?? .commandFailed
+  }
+
+  lazy var handleStopCommand: RemoteCommandHandler = { [weak self] event in
+    self?.handleStopCommandDefault(event: event) ?? .commandFailed
+  }
+
+  lazy var handleTogglePlayPauseCommand: RemoteCommandHandler = { [weak self] event in
+    self?.handleTogglePlayPauseCommandDefault(event: event) ?? .commandFailed
+  }
+
+  lazy var handleSkipForwardCommand: RemoteCommandHandler = { [weak self] event in
+    self?.handleSkipForwardCommandDefault(event: event) ?? .commandFailed
+  }
+
+  lazy var handleSkipBackwardCommand: RemoteCommandHandler = { [weak self] event in
+    self?.handleSkipBackwardDefault(event: event) ?? .commandFailed
+  }
+
+  lazy var handleChangePlaybackPositionCommand: RemoteCommandHandler = { [weak self] event in
+    self?.handleChangePlaybackPositionCommandDefault(event: event) ?? .commandFailed
+  }
+
+  lazy var handleNextTrackCommand: RemoteCommandHandler = { [weak self] event in
+    self?.handleNextTrackCommandDefault(event: event) ?? .commandFailed
+  }
+
+  lazy var handlePreviousTrackCommand: RemoteCommandHandler = { [weak self] event in
+    self?.handlePreviousTrackCommandDefault(event: event) ?? .commandFailed
+  }
+
+  lazy var handleChangeRepeatModeCommand: RemoteCommandHandler = { [weak self] event in
+    self?.handleChangeRepeatModeCommandDefault(event: event) ?? .commandFailed
+  }
+
+  lazy var handleChangeShuffleModeCommand: RemoteCommandHandler = { [weak self] event in
+    self?.handleChangeShuffleModeCommandDefault(event: event) ?? .commandFailed
+  }
+
+  lazy var handleChangePlaybackRateCommand: RemoteCommandHandler = { [weak self] event in
+    self?.handleChangePlaybackRateCommandDefault(event: event) ?? .commandFailed
+  }
 
   private func handlePlayCommandDefault(event _: MPRemoteCommandEvent)
     -> MPRemoteCommandHandlerStatus

package/ios/Tests/BrowserPathHelperTests.swift

@@ -74,6 +74,56 @@ import Testing
   #expect(result == "/items?a=1&m=2&z=3")
 }
 
+// MARK: - build
+
+@Test func buildAppendsTrackIdWithQuestionMark() {
+  let result = BrowserPathHelper.build(parentPath: "/library", trackId: "song.mp3")
+  #expect(result == "/library?__trackId=song.mp3")
+}
+
+@Test func buildAppendsTrackIdWithAmpersandWhenParentHasQuery() {
+  let result = BrowserPathHelper.build(parentPath: "/search?q=jazz", trackId: "song.mp3")
+  #expect(result == "/search?q=jazz&__trackId=song.mp3")
+}
+
+@Test func buildRoundTripsSrcWithQueryParams() {
+  // A src carrying its own query string (signed CDN URL) must survive the
+  // build → extract/strip round-trip: an unescaped `&` splits the src into
+  // stray query params, truncating the trackId and polluting the parent path.
+  let src = "https://cdn.example.com/stream.mp3?token=abc&exp=1699999999"
+  let url = BrowserPathHelper.build(parentPath: "/library", trackId: src)
+  #expect(BrowserPathHelper.extractTrackId(url) == src)
+  #expect(BrowserPathHelper.stripTrackId(url) == "/library")
+}
+
+@Test func buildRoundTripsSrcWithEqualsAndPlus() {
+  let src = "https://cdn.example.com/a+b.mp3?sig=x=y"
+  let url = BrowserPathHelper.build(parentPath: "/library", trackId: src)
+  #expect(BrowserPathHelper.extractTrackId(url) == src)
+  #expect(BrowserPathHelper.stripTrackId(url) == "/library")
+}
+
+@Test func buildStampsTheIndexAndRoundTripsIt() {
+  let src = "https://cdn.example.com/stream.mp3?token=abc&exp=1"
+  let url = BrowserPathHelper.build(parentPath: "/library", trackId: src, index: 3)
+  #expect(BrowserPathHelper.extractTrackId(url) == src)
+  #expect(BrowserPathHelper.extractIndex(url) == 3)
+  #expect(BrowserPathHelper.stripTrackId(url) == "/library")
+}
+
+// MARK: - extractIndex
+
+@Test func extractIndexReturnsNilWithoutAStampedIndex() {
+  let url = BrowserPathHelper.build(parentPath: "/library", trackId: "song.mp3")
+  #expect(BrowserPathHelper.extractIndex(url) == nil)
+}
+
+@Test func extractIndexReturnsNilForNonContextualOrMalformedIndex() {
+  #expect(BrowserPathHelper.extractIndex("/library") == nil)
+  #expect(BrowserPathHelper.extractIndex("/library?__trackId=song.mp3&__index=x") == nil)
+  #expect(BrowserPathHelper.extractIndex("/library?__trackId=song.mp3&__index=-1") == nil)
+}
+
 // MARK: - stripTrackId
 
 @Test func stripTrackIdRemovesTrackParam() {
@@ -116,23 +166,3 @@ import Testing
 @Test func isContextualReturnsTrueWithAmpersandSeparator() {
   #expect(BrowserPathHelper.isContextual("/lib?q=1&__trackId=x") == true)
 }
-
-// MARK: - containsSegment
-
-@Test func containsSegmentMatchesFullSegments() {
-  let path = "/listen/amsterdam-funk-channel/Gw0LGB8j"
-  #expect(BrowserPathHelper.containsSegment(path, "Gw0LGB8j"))
-  #expect(BrowserPathHelper.containsSegment(path, "amsterdam-funk-channel"))
-  #expect(BrowserPathHelper.containsSegment(path, "listen"))
-  #expect(BrowserPathHelper.containsSegment("/listen/x/Gw0LGB8j?hl=en", "Gw0LGB8j"))
-  #expect(BrowserPathHelper.containsSegment("/listen/x/Gw0LGB8j#frag", "Gw0LGB8j"))
-}
-
-@Test func containsSegmentRejectsPartialAndMissing() {
-  let path = "/listen/amsterdam-funk-channel/Gw0LGB8j"
-  #expect(!BrowserPathHelper.containsSegment(path, "Gw0LGB8"))
-  #expect(!BrowserPathHelper.containsSegment(path, "funk"))
-  #expect(!BrowserPathHelper.containsSegment(path, "msterdam-funk-channe"))
-  #expect(!BrowserPathHelper.containsSegment(path, "NopeNope"))
-  #expect(!BrowserPathHelper.containsSegment(path, ""))
-}