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

package/ios/Player/MediaIntentCriteria.swift

@@ -1,139 +0,0 @@
-import Foundation
-
-/// Normalized "what did the user ask to play", derived from a media intent.
-/// Deliberately free of `Intents` types so the core (`HybridAudioBrowser`)
-/// never imports the Intents framework — the mapping lives in the
-/// `Intents`-aware `RNABMediaIntentHandler`.
-public struct MediaIntentCriteria: Sendable {
-  /// Media-reference axis (mirrors `INMediaReference`). `currentlyPlaying`
-  /// routes to native resume and never reaches the consumer; `my` routes to
-  /// the search source; `unknown` is the default.
-  public enum Reference: Sendable { case my, currentlyPlaying, unknown }
-
-  let query: String
-  let reference: Reference
-  let hasGenres: Bool
-  let hasMediaType: Bool
-  /// True when `query` is effectively the host app's own name. Siri turns
-  /// "Play «app»" into a search for a word in the app name — e.g. "Play Radio
-  /// Garden" arrives as mediaName "Garden" (+ radio mediaType). That's an
-  /// app-open/resume, not a station search.
-  let matchesAppName: Bool
-
-  // Structured search payload, mirroring the shared `SearchParams`. Plain
-  // Sendable strings so this type stays in the unit-testable target; the Nitro
-  // `SearchParams` is assembled in the funnel.
-  /// The container-vertical `SearchMode` name, or nil. Comes ONLY from the
-  /// intent's media type — never derived from which filter field is set.
-  let searchMode: String?
-  let genre: String?
-  let artist: String?
-  let album: String?
-  let title: String?
-  let playlist: String?
-
-  init(
-    query: String,
-    reference: Reference,
-    hasGenres: Bool,
-    hasMediaType: Bool,
-    matchesAppName: Bool,
-    searchMode: String? = nil,
-    genre: String? = nil,
-    artist: String? = nil,
-    album: String? = nil,
-    title: String? = nil,
-    playlist: String? = nil,
-  ) {
-    self.query = query
-    self.reference = reference
-    self.hasGenres = hasGenres
-    self.hasMediaType = hasMediaType
-    self.matchesAppName = matchesAppName
-    self.searchMode = searchMode
-    self.genre = genre
-    self.artist = artist
-    self.album = album
-    self.title = title
-    self.playlist = playlist
-  }
-
-  /// Resume vs search, by reference:
-  /// - `currentlyPlaying` → always resume ("play this" plays the active track)
-  /// - `my` → always search ("play my favorites" goes to the consumer)
-  /// - `unknown` → the no-criteria / app-name heuristic
-  var isResume: Bool {
-    switch reference {
-    case .currentlyPlaying: return true
-    case .my: return false
-    case .unknown:
-      let q = query.trimmingCharacters(in: .whitespacesAndNewlines)
-      // "Play «app»": no search term and no other filter → resume.
-      if q.isEmpty { return !hasGenres && !hasMediaType }
-      // "Play «app-name»": resume — unless a real filter signals a search.
-      return matchesAppName && !hasGenres
-    }
-  }
-
-  /// Builds criteria from the raw fields of a media-search intent. Pure (no
-  /// `Intents`/`Bundle` dependency) so the whole Siri-phrase → search decision
-  /// is unit-testable.
-  ///
-  /// `mediaTypeMode` is the already-collapsed `SearchMode` string for the
-  /// intent's container vertical (e.g. "station"/"podcast"/"song"), or nil for
-  /// a filter-only / unclassified type. `reference` is the mapped axis.
-  static func from(
-    mediaName: String?,
-    genreNames: [String],
-    artistName: String?,
-    albumName: String?,
-    mediaTypeMode: String?,
-    reference: Reference,
-    hasMediaType: Bool,
-    appName: String?,
-  ) -> MediaIntentCriteria {
-    let name = (mediaName ?? "").trimmingCharacters(in: .whitespacesAndNewlines)
-    let trimmedNonEmpty: (String?) -> String? = {
-      let t = ($0 ?? "").trimmingCharacters(in: .whitespacesAndNewlines)
-      return t.isEmpty ? nil : t
-    }
-
-    let genre = genreNames.isEmpty ? nil : genreNames.joined(separator: " ")
-    let artist = trimmedNonEmpty(artistName)
-    let album = trimmedNonEmpty(albumName)
-    // song/playlist carry their spoken name into a dedicated field.
-    let title = mediaTypeMode == "song" ? (name.isEmpty ? nil : name) : nil
-    let playlist = mediaTypeMode == "playlist" ? (name.isEmpty ? nil : name) : nil
-
-    // `query` is always populated so search works even before the API honours
-    // `mode`: prefer the spoken name, else fall back to a structured value.
-    let query = name.isEmpty ? (genre ?? artist ?? album ?? title ?? playlist ?? "") : name
-
-    return MediaIntentCriteria(
-      query: query,
-      reference: reference,
-      hasGenres: !genreNames.isEmpty,
-      hasMediaType: hasMediaType,
-      matchesAppName: queryMatchesAppName(query, appName: appName),
-      searchMode: mediaTypeMode, // mode is the vertical, verbatim — no derivation
-      genre: genre,
-      artist: artist,
-      album: album,
-      title: title,
-      playlist: playlist,
-    )
-  }
-
-  /// Whether `query` is effectively the host app's own name. Case- and
-  /// diacritic-insensitive.
-  private static func queryMatchesAppName(_ query: String, appName: String?) -> Bool {
-    guard let appName else { return false }
-    let normalize: (String) -> String = {
-      $0.folding(options: [.diacriticInsensitive, .caseInsensitive], locale: nil)
-        .trimmingCharacters(in: .whitespacesAndNewlines)
-    }
-    let q = normalize(query), a = normalize(appName)
-    guard !q.isEmpty, !a.isEmpty else { return false }
-    return a.contains(q) || q.contains(a)
-  }
-}

package/ios/Player/PersistedPlaybackState.swift

@@ -1,11 +0,0 @@
-import Foundation
-
-/// A serialisable snapshot of the player's resumable state. Mirrors Android's
-/// `PlaybackStateStore.PersistedState`. `positionMs` is `nil` for live streams.
-struct PersistedPlaybackState: Codable {
-  let track: JsonTrack
-  let positionMs: Double?
-  let repeatMode: String
-  let shuffleEnabled: Bool
-  let playbackSpeed: Float
-}

package/ios/Player/PlaybackStateStore.swift

@@ -1,27 +0,0 @@
-import Foundation
-
-/// Persists the player's resumable state to UserDefaults so a cold-start
-/// "resume" intent can restore the last session without the JS runtime.
-/// Swift counterpart of Android's `PlaybackStateStore.kt`.
-final class PlaybackStateStore {
-  private let defaults: UserDefaults
-  private let key = "playbackState.v1"
-
-  init(defaults: UserDefaults = UserDefaults(suiteName: "com.audiobrowser.playback") ?? .standard) {
-    self.defaults = defaults
-  }
-
-  func save(_ state: PersistedPlaybackState) {
-    guard let data = try? JSONEncoder().encode(state) else { return }
-    defaults.set(data, forKey: key)
-  }
-
-  func load() -> PersistedPlaybackState? {
-    guard let data = defaults.data(forKey: key) else { return nil }
-    return try? JSONDecoder().decode(PersistedPlaybackState.self, from: data)
-  }
-
-  func clear() {
-    defaults.removeObject(forKey: key)
-  }
-}

package/ios/Player/PlaybackTimer.swift

@@ -1,61 +0,0 @@
-import Foundation
-#if canImport(NitroModules)
-  import NitroModules
-#endif
-
-/// A playback-gated repeating timer. Runs `onTick` every `interval` seconds while
-/// the current playback state satisfies `isActive`. `interval == nil` (or <= 0)
-/// means stopped — that is the single off-switch.
-@MainActor
-final class PlaybackTimer {
-  // nonisolated(unsafe) for deinit cleanup — Timer must be invalidated to break
-  // the RunLoop retain, and deinit is always nonisolated in Swift 6.
-  private nonisolated(unsafe) var timer: Timer?
-  private var interval: TimeInterval?
-  private var active = false
-  private let isActive: (PlaybackState) -> Bool
-  private let onTick: () -> Void
-
-  init(isActive: @escaping (PlaybackState) -> Bool, onTick: @escaping () -> Void) {
-    self.isActive = isActive
-    self.onTick = onTick
-  }
-
-  deinit {
-    timer?.invalidate()
-  }
-
-  func setInterval(_ interval: TimeInterval?) {
-    let normalized = (interval ?? 0) > 0 ? interval : nil
-    if normalized == self.interval { return }
-    self.interval = normalized
-    stop() // restart with the new interval on the next reconcile
-    reconcile()
-  }
-
-  func onPlaybackStateChanged(_ state: PlaybackState) {
-    active = isActive(state)
-    reconcile()
-  }
-
-  private func reconcile() {
-    if let interval, active {
-      start(interval)
-    } else {
-      stop()
-    }
-  }
-
-  private func start(_ interval: TimeInterval) {
-    guard timer == nil else { return }
-    timer = Timer.scheduledTimer(withTimeInterval: interval, repeats: true) {
-      [weak self] _ in
-      MainActor.assumeIsolated { self?.onTick() }
-    }
-  }
-
-  private func stop() {
-    timer?.invalidate()
-    timer = nil
-  }
-}

package/ios/Player/VolumeFader.swift

@@ -1,77 +0,0 @@
-import Foundation
-
-/// Ramps the player volume down over a duration (sleep-timer fade).
-/// The gain follows a squared curve: loudness perception is logarithmic, so a
-/// linear gain ramp sounds like a late cutoff rather than a fade.
-@MainActor
-final class VolumeFader {
-  private static let stepInterval: TimeInterval = 0.05
-
-  private let getVolume: () -> Float
-  private let setVolume: (Float) -> Void
-  // nonisolated(unsafe) for deinit cleanup — deinit is always nonisolated in Swift 6.
-  private nonisolated(unsafe) var timer: Timer?
-
-  /// Volume captured when the fade started; restored after the fade resolves.
-  /// Non-nil from fade start until cancel/completion, even once the ramp has
-  /// reached silence.
-  private(set) var originalVolume: Float?
-
-  var isActive: Bool { originalVolume != nil }
-
-  init(getVolume: @escaping () -> Float, setVolume: @escaping (Float) -> Void) {
-    self.getVolume = getVolume
-    self.setVolume = setVolume
-  }
-
-  func start(duration: TimeInterval) {
-    // If a fade is already running, keep its captured volume as the baseline —
-    // the current (partially faded) volume is not the value to restore.
-    let baseVolume = originalVolume ?? getVolume()
-    cancel(restoringVolume: false)
-    originalVolume = baseVolume
-    guard duration > 0 else { return }
-
-    let startDate = Date()
-    let timer = Timer(timeInterval: Self.stepInterval, repeats: true) { [weak self] _ in
-      MainActor.assumeIsolated {
-        guard let self else { return }
-        let progress = min(1, Date().timeIntervalSince(startDate) / duration)
-        let remaining = Float(1 - progress)
-        self.setVolume(baseVolume * remaining * remaining)
-        if progress >= 1 {
-          self.timer?.invalidate()
-          self.timer = nil
-        }
-      }
-    }
-    self.timer = timer
-    RunLoop.main.add(timer, forMode: .common)
-  }
-
-  /// Stops the ramp. With `restoringVolume` the pre-fade volume is put back
-  /// immediately (cancellation); without it the caller restores after pausing
-  /// (completion path — restoring first would let full-volume audio slip out).
-  func cancel(restoringVolume: Bool) {
-    timer?.invalidate()
-    timer = nil
-    guard let originalVolume else { return }
-    self.originalVolume = nil
-    if restoringVolume { setVolume(originalVolume) }
-  }
-
-  /// Resolves the fade around a halting action: stops the ramp, runs `halt`,
-  /// then restores the pre-fade volume — in that order, because restoring
-  /// before halting would let full-volume audio slip out. The restore is
-  /// skipped when no fade was running.
-  func resolve(around halt: () -> Void) {
-    let preFadeVolume = originalVolume
-    cancel(restoringVolume: false)
-    halt()
-    if let preFadeVolume { setVolume(preFadeVolume) }
-  }
-
-  deinit {
-    timer?.invalidate()
-  }
-}

package/ios/RemoteCommand/RemoteCommandCallbacks.swift

@@ -1,47 +0,0 @@
-#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/Tests/AirPlayStallJudgementTests.swift

@@ -1,52 +0,0 @@
-import Testing
-
-@testable import AudioBrowserTestable
-
-@Suite("AirPlayStallJudgement")
-struct AirPlayStallJudgementTests {
-  /// The exact transition Pocket Casts recovers from: over AirPlay, AVPlayer
-  /// drops .waitingToPlayAtSpecifiedRate(.noItemToPlay) → .paused while still
-  /// meant to play. That, and only that, should nudge.
-  private func judge(
-    previous: PlayerTimeControlStatus? = .waitingToPlayAtSpecifiedRate,
-    current: PlayerTimeControlStatus = .paused,
-    reasonWasNoItemToPlay: Bool = true,
-    isAirPlay: Bool = true,
-    playWhenReady: Bool = true,
-  ) -> AirPlayStallJudgement {
-    AirPlayStallJudgement(
-      previous: previous,
-      current: current,
-      previousWaitingReasonWasNoItemToPlay: reasonWasNoItemToPlay,
-      isAirPlay: isAirPlay,
-      playWhenReady: playWhenReady,
-    )
-  }
-
-  @Test func exactTransition_nudges() {
-    #expect(judge().shouldNudge)
-  }
-
-  @Test func notAirPlay_doesNotNudge() {
-    #expect(!judge(isAirPlay: false).shouldNudge)
-  }
-
-  @Test func notPlayWhenReady_doesNotNudge() {
-    #expect(!judge(playWhenReady: false).shouldNudge)
-  }
-
-  @Test func previousNotWaiting_doesNotNudge() {
-    #expect(!judge(previous: .playing).shouldNudge)
-    #expect(!judge(previous: nil).shouldNudge)
-  }
-
-  @Test func currentNotPaused_doesNotNudge() {
-    #expect(!judge(current: .playing).shouldNudge)
-    #expect(!judge(current: .waitingToPlayAtSpecifiedRate).shouldNudge)
-  }
-
-  @Test func reasonNotNoItemToPlay_doesNotNudge() {
-    // A normal stall (.toMinimizeStalls etc.) landing in paused isn't the bug.
-    #expect(!judge(reasonWasNoItemToPlay: false).shouldNudge)
-  }
-}

package/ios/Tests/EndOfTrackJudgementTests.swift

@@ -1,35 +0,0 @@
-import Testing
-
-@testable import AudioBrowserTestable
-
-@Suite("EndOfTrackJudgement")
-struct EndOfTrackJudgementTests {
-  // Live streams are infinite — an end-of-item is always a dropped connection,
-  // never a real end, regardless of the reported position/duration.
-  @Test func live_isAlwaysStalled() {
-    #expect(EndOfTrackJudgement(isLive: true, currentTime: 0, duration: 0).outcome == .stalled)
-    #expect(EndOfTrackJudgement(isLive: true, currentTime: 100, duration: 100).outcome == .stalled)
-    #expect(EndOfTrackJudgement(isLive: true, currentTime: 5, duration: .nan).outcome == .stalled)
-  }
-
-  // On-demand reaching the end is a genuine finish.
-  @Test func onDemand_atEnd_isEnded() {
-    #expect(EndOfTrackJudgement(isLive: false, currentTime: 300, duration: 300).outcome == .ended)
-  }
-
-  // Within the 5% tail still counts as a real finish (decoder rarely lands exactly).
-  @Test func onDemand_withinFivePercentOfEnd_isEnded() {
-    #expect(EndOfTrackJudgement(isLive: false, currentTime: 291, duration: 300).outcome == .ended)
-  }
-
-  // More than 5% short of the end → a mid-stream stall reported as EOF.
-  @Test func onDemand_wellShortOfEnd_isStalled() {
-    #expect(EndOfTrackJudgement(isLive: false, currentTime: 120, duration: 300).outcome == .stalled)
-  }
-
-  // Unknown/indefinite duration can't be validated — trust the notification.
-  @Test func onDemand_indefiniteDuration_isEnded() {
-    #expect(EndOfTrackJudgement(isLive: false, currentTime: 0, duration: .nan).outcome == .ended)
-    #expect(EndOfTrackJudgement(isLive: false, currentTime: 0, duration: 0).outcome == .ended)
-  }
-}

package/ios/Tests/JsonModelsTests.swift

@@ -1,58 +0,0 @@
-@testable import AudioBrowserTestable
-import Foundation
-import Testing
-
-@Suite("JsonTrack.request")
-struct JsonTrackRequestTests {
-  @Test func decodesRequestOntoTrack() throws {
-    let json = """
-    { "title": "X", "src": "/s", "request": { "userAgent": "UA-X",
-      "headers": { "Referer": "https://e.example" }, "query": { "t": "1" } } }
-    """.data(using: .utf8)!
-    let jsonTrack = try JSONDecoder().decode(JsonTrack.self, from: json)
-    let track = jsonTrack.toNitro()
-    #expect(track.request?.userAgent == "UA-X")
-    #expect(track.request?.headers?["Referer"] == "https://e.example")
-    #expect(track.request?.query?["t"] == "1")
-  }
-}
-
-@Suite("JsonTrack.artwork")
-struct JsonTrackArtworkTests {
-  @Test func decodesASingleUrl() throws {
-    let json = #"{ "title": "X", "artwork": "https://e.example/a.png" }"#.data(using: .utf8)!
-    let track = try JSONDecoder().decode(JsonTrack.self, from: json).toNitro()
-    #expect(track.artwork == .first("https://e.example/a.png"))
-  }
-
-  @Test func decodesAPerAppearancePair() throws {
-    let json = """
-    { "title": "X", "artwork": { "light": "https://e.example/l.png", "dark": "https://e.example/d.png" } }
-    """.data(using: .utf8)!
-    let track = try JSONDecoder().decode(JsonTrack.self, from: json).toNitro()
-    #expect(track.artwork?.variants?.light == "https://e.example/l.png")
-    #expect(track.artwork?.variants?.dark == "https://e.example/d.png")
-    // Callers that cannot express appearance get the dark one.
-    #expect(track.artwork?.url == "https://e.example/d.png")
-  }
-
-  @Test func decodesAPairNestedInChildren() throws {
-    // The shape that shipped broken: a container decodes its children eagerly,
-    // so one unparseable row rejected the whole page rather than losing an image.
-    let json = """
-    { "url": "/favorites", "title": "Favorites", "children": [
-      { "title": "Playlist", "artwork": { "light": "https://e.example/l.png", "dark": "https://e.example/d.png" } }
-    ] }
-    """.data(using: .utf8)!
-    let resolved = try JSONDecoder().decode(JsonResolvedTrack.self, from: json).toNitro()
-    #expect(resolved.children?.first?.artwork?.variants?.dark == "https://e.example/d.png")
-  }
-
-  @Test func roundTripsBothShapes() throws {
-    for artwork: JsonArtwork in [.single("a.png"), .variants(light: "l.png", dark: "d.png")] {
-      let encoded = try JSONEncoder().encode(JsonTrack(title: "X", artwork: artwork))
-      let decoded = try JSONDecoder().decode(JsonTrack.self, from: encoded)
-      #expect(decoded.artwork == artwork)
-    }
-  }
-}

package/ios/Tests/MediaIntentCriteriaTests.swift

@@ -1,170 +0,0 @@
-import Testing
-
-@testable import AudioBrowserTestable
-
-@Suite("MediaIntentCriteria")
-struct MediaIntentCriteriaTests {
-  @Test func emptyEverything_isResume() {
-    let c = MediaIntentCriteria(query: "", reference: .unknown, hasGenres: false, hasMediaType: false, matchesAppName: false)
-    #expect(c.isResume)
-  }
-
-  @Test func whitespaceQuery_isResume() {
-    let c = MediaIntentCriteria(query: "   ", reference: .unknown, hasGenres: false, hasMediaType: false, matchesAppName: false)
-    #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)
-    // even with a stray query/filter, "play this" is a resume
-    #expect(MediaIntentCriteria(query: "jazz", reference: .currentlyPlaying, hasGenres: true, hasMediaType: true, matchesAppName: false).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)
-  }
-
-  @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)
-  }
-
-  @Test func queryNamesApp_isResume() {
-    let c = MediaIntentCriteria(query: "Garden", reference: .unknown, hasGenres: false, hasMediaType: true, matchesAppName: true)
-    #expect(c.isResume)
-  }
-
-  @Test func queryNamesApp_withGenre_isNotResume() {
-    #expect(!MediaIntentCriteria(query: "Garden", reference: .unknown, hasGenres: true, hasMediaType: false, matchesAppName: true).isResume)
-  }
-
-  @Test func queryNotApp_isNotResume() {
-    #expect(!MediaIntentCriteria(query: "jazz", reference: .unknown, hasGenres: false, hasMediaType: false, matchesAppName: false).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,
-    )
-  }
-
-  // MARK: resume vs search
-
-  @Test func playAppName_resumes() {
-    let c = from(mediaName: "Garden", hasMediaType: true)
-    #expect(c.query == "Garden")
-    #expect(c.matchesAppName)
-    #expect(c.isResume)
-  }
-
-  @Test func emptyIntent_resumes() {
-    let c = from()
-    #expect(c.query == "")
-    #expect(c.isResume)
-  }
-
-  @Test func playMyFavorites_searches() {
-    let c = from(reference: .my)
-    #expect(!c.isResume)
-    #expect(c.reference == .my)
-  }
-
-  @Test func stationName_searches() {
-    let c = from(mediaName: "KCRW")
-    #expect(c.query == "KCRW")
-    #expect(!c.matchesAppName)
-    #expect(!c.isResume)
-    #expect(c.searchMode == nil)
-  }
-
-  // MARK: mode comes ONLY from mediaTypeMode (no field-derivation)
-
-  // "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)
-    #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"])
-    #expect(c.query == "classic rock")
-    #expect(c.genre == "classic rock")
-    #expect(c.searchMode == nil)
-  }
-
-  @Test func artist_isFilterNotMode() {
-    let c = from(artistName: "Michael Jackson")
-    #expect(c.query == "Michael Jackson")
-    #expect(c.searchMode == nil)
-    #expect(c.artist == "Michael Jackson")
-    #expect(!c.isResume)
-  }
-
-  @Test func albumAndArtist_areFiltersNotMode() {
-    let c = from(mediaName: "Thriller", artistName: "Michael Jackson", albumName: "Thriller")
-    #expect(c.searchMode == nil)
-    #expect(c.album == "Thriller")
-    #expect(c.artist == "Michael Jackson")
-    #expect(!c.query.isEmpty)
-  }
-
-  // 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")
-    #expect(c.query == "Billie Jean")
-    #expect(c.searchMode == "song")
-    #expect(c.title == "Billie Jean")
-    #expect(c.playlist == nil)
-  }
-
-  @Test func playlist_viaMediaTypeMode_setsPlaylist() {
-    let c = from(mediaName: "Workout", mediaTypeMode: "playlist")
-    #expect(c.query == "Workout")
-    #expect(c.searchMode == "playlist")
-    #expect(c.playlist == "Workout")
-    #expect(c.title == nil)
-  }
-
-  // "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)
-    #expect(c.searchMode == "station")
-    #expect(c.genre == "jazz")
-  }
-
-  @Test func podcast_setsMode() {
-    let c = from(mediaName: "Serial", mediaTypeMode: "podcast", hasMediaType: true)
-    #expect(c.searchMode == "podcast")
-    #expect(c.query == "Serial")
-  }
-
-  @Test func plainName_hasNoStructuredFields() {
-    let c = from(mediaName: "KCRW")
-    #expect(c.searchMode == nil)
-    #expect(c.genre == nil)
-    #expect(c.artist == nil)
-    #expect(c.album == nil)
-  }
-}