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

package/ios/Browser/SearchDrillIn.swift

@@ -1,44 +0,0 @@
-import Foundation
-
-/// A search result that may or may not be directly playable. `src` is the
-/// playable stream; `url` is a browsable container path. Abstracting these two
-/// fields keeps the drill-in decision free of the Nitro `Track` type so it can
-/// be unit-tested.
-protocol PlayableSearchItem {
-  var src: String? { get }
-  var url: String? { get }
-}
-
-enum SearchDrillIn {
-  /// Picks the playable items for a "play «X»" voice search.
-  ///
-  /// If the first result is browsable-only (a `url` container with no `src` — a
-  /// place/genre page), drills into it via `resolveChildren` and uses its
-  /// playable children, so we play the first station *inside* the page rather
-  /// than skipping the page for a later inline station. Falls back to the flat
-  /// playable results when the first result is already playable or the drill-in
-  /// yields nothing. Returns nil when nothing is playable.
-  static func playable<Item: PlayableSearchItem>(
-    from children: [Item],
-    resolveChildren: sending (String) async throws -> [Item],
-  ) async throws -> [Item]? {
-    guard !children.isEmpty else { return nil }
-
-    let candidates: [Item]
-    if let first = children.first, first.src == nil, let url = first.url {
-      let drilled = try await resolveChildren(url).filter { $0.src != nil }
-      candidates = drilled.isEmpty ? children : drilled
-    } else {
-      candidates = children
-    }
-
-    let playable = candidates.filter { $0.src != nil }
-    return playable.isEmpty ? nil : playable
-  }
-}
-
-// The real Nitro `Track` already carries `src`/`url`; conform it for the app
-// build. (The testable target builds without NitroModules and uses a stub item.)
-#if canImport(NitroModules)
-  extension Track: PlayableSearchItem {}
-#endif

package/ios/Browser/SectionScope.swift

@@ -1,35 +0,0 @@
-// Queue scope is the tapped section, not the whole page (ADR 0006): the
-// playback context a listener expects is the list they tapped in — a page
-// aggregating several sections must not leak next/previous across them.
-enum SectionScope {
-  enum Section {
-    /// The tapped id lives inside an image row's items.
-    case imageRow([ImageRowItem])
-    /// The contiguous `groupTitle` run around the tapped child (items with
-    /// no group title form runs of their own).
-    case run([Track])
-  }
-
-  /// The section of `children` containing the playable `trackId`, or nil
-  /// when the id is not found.
-  static func section(of children: [Track], containing trackId: String) -> Section? {
-    for child in children {
-      if let items = child.imageRow, items.contains(where: { $0.src == trackId }) {
-        return .imageRow(items)
-      }
-    }
-    guard let index = children.firstIndex(where: { $0.src == trackId }) else {
-      return nil
-    }
-    let group = children[index].groupTitle
-    var start = index
-    while start > 0, children[start - 1].groupTitle == group {
-      start -= 1
-    }
-    var end = index
-    while end + 1 < children.count, children[end + 1].groupTitle == group {
-      end += 1
-    }
-    return .run(Array(children[start ... end]))
-  }
-}

package/ios/Browser/TabBarEntries.swift

@@ -1,15 +0,0 @@
-/// Compares the tab-list fields the CarPlay tab bar actually renders.
-enum TabBarEntries {
-  /// Whether two tab lists produce identical tab-bar entries — title, url,
-  /// and the artwork inputs of `applyTabBarEntry`. Used to suppress
-  /// `tabsChanged` when a tabs re-query (e.g. from `invalidateAllContent()`)
-  /// resolves to the same entries, so an unchanged result never churns the
-  /// tab bar or resets its selection.
-  static func same(_ old: [Track]?, _ new: [Track]) -> Bool {
-    guard let old, old.count == new.count else { return false }
-    return zip(old, new).allSatisfy {
-      $0.title == $1.title && $0.url == $1.url && $0.artwork == $1.artwork
-        && $0.artworkSource?.uri == $1.artworkSource?.uri
-    }
-  }
-}

package/ios/CarPlay/CPInterfaceController+Safe.swift

@@ -1,126 +0,0 @@
-import CarPlay
-import os.log
-
-/// Logged, precondition-guarded wrappers around `CPInterfaceController`'s
-/// template-stack mutations.
-///
-/// Per the SDK header, an unsuccessful push/setRoot/present with a nil
-/// completion doesn't fail quietly — it throws an Objective-C exception (depth
-/// limit included) that takes down the whole app, not just the CarPlay scene;
-/// pushing a template that is already in the hierarchy raises regardless.
-/// Every stack mutation therefore goes through these helpers: the raise-prone
-/// preconditions are checked up front, the underlying call always gets a
-/// completion, and every failure is logged, with an optional caller completion
-/// for call sites that chain on the result.
-@MainActor
-extension CPInterfaceController {
-  private static let stackLogger = Logger(subsystem: "com.audiobrowser", category: "TemplateStack")
-
-  private static func name(of template: CPTemplate) -> String {
-    String(describing: type(of: template))
-  }
-
-  /// CarPlay's template-stack depth cap for audio apps. Not exposed by the SDK;
-  /// exceeding it raises `NSGenericException` ("Application exceeded the
-  /// hierarchy depth limit") synchronously — even through the completion-based
-  /// push — taking down the whole app, not just the CarPlay scene.
-  private static let maximumStackDepth = 5
-
-  /// Pushes `template`, skipping the raise cases (already in the hierarchy,
-  /// stack at the depth limit).
-  func safePush(_ template: CPTemplate, animated: Bool, completion: ((Bool, Error?) -> Void)? = nil) {
-    guard !templates.contains(where: { $0 === template }) else {
-      Self.stackLogger.warning("push skipped: \(Self.name(of: template)) is already in the stack")
-      completion?(false, nil)
-      return
-    }
-    guard templates.count < Self.maximumStackDepth else {
-      Self.stackLogger.error("push skipped: \(Self.name(of: template)) would exceed the depth limit (\(self.templates.count) templates)")
-      completion?(false, nil)
-      return
-    }
-    pushTemplate(template, animated: animated) { pushed, error in
-      if let error {
-        Self.stackLogger.error("pushTemplate \(Self.name(of: template)) failed: \(error.localizedDescription)")
-      }
-      completion?(pushed, error)
-    }
-  }
-
-  /// Pops the top template, skipping the raise case (nothing above the root).
-  func safePop(animated: Bool, completion: ((Bool, Error?) -> Void)? = nil) {
-    guard templates.count > 1 else {
-      Self.stackLogger.warning("pop skipped: already at the root template")
-      completion?(false, nil)
-      return
-    }
-    popTemplate(animated: animated) { popped, error in
-      if let error {
-        Self.stackLogger.error("popTemplate failed: \(error.localizedDescription)")
-      }
-      completion?(popped, error)
-    }
-  }
-
-  /// Pops back to `template`, skipping the raise case (not in the hierarchy).
-  /// A no-op success when it is already the top template.
-  func safePop(to template: CPTemplate, animated: Bool, completion: ((Bool, Error?) -> Void)? = nil) {
-    guard templates.contains(where: { $0 === template }) else {
-      Self.stackLogger.warning("pop(to:) skipped: \(Self.name(of: template)) is not in the stack")
-      completion?(false, nil)
-      return
-    }
-    guard topTemplate !== template else {
-      completion?(true, nil)
-      return
-    }
-    pop(to: template, animated: animated) { popped, error in
-      if let error {
-        Self.stackLogger.error("pop(to:) \(Self.name(of: template)) failed: \(error.localizedDescription)")
-      }
-      completion?(popped, error)
-    }
-  }
-
-  func safePopToRoot(animated: Bool, completion: ((Bool, Error?) -> Void)? = nil) {
-    popToRootTemplate(animated: animated) { popped, error in
-      if let error {
-        Self.stackLogger.error("popToRootTemplate failed: \(error.localizedDescription)")
-      }
-      completion?(popped, error)
-    }
-  }
-
-  func safeSetRoot(_ template: CPTemplate, animated: Bool, completion: ((Bool, Error?) -> Void)? = nil) {
-    setRootTemplate(template, animated: animated) { set, error in
-      if let error {
-        Self.stackLogger.error("setRootTemplate \(Self.name(of: template)) failed: \(error.localizedDescription)")
-      }
-      completion?(set, error)
-    }
-  }
-
-  func safePresent(_ template: CPTemplate, animated: Bool, completion: ((Bool, Error?) -> Void)? = nil) {
-    presentTemplate(template, animated: animated) { presented, error in
-      if let error {
-        Self.stackLogger.error("presentTemplate \(Self.name(of: template)) failed: \(error.localizedDescription)")
-      }
-      completion?(presented, error)
-    }
-  }
-
-  /// Dismisses the presented template, skipping when nothing is presented.
-  func safeDismiss(animated: Bool, completion: ((Bool, Error?) -> Void)? = nil) {
-    guard presentedTemplate != nil else {
-      Self.stackLogger.debug("dismiss skipped: no presented template")
-      completion?(false, nil)
-      return
-    }
-    dismissTemplate(animated: animated) { dismissed, error in
-      if let error {
-        Self.stackLogger.error("dismissTemplate failed: \(error.localizedDescription)")
-      }
-      completion?(dismissed, error)
-    }
-  }
-}

package/ios/CarPlay/ImageRowItem+CarPlay.swift

@@ -1,19 +0,0 @@
-import Foundation
-import NitroModules
-
-// MARK: - ImageRowItem → Track Conversion
-
-extension ImageRowItem {
-  /// Creates a minimal Track from an ImageRowItem for reuse with item selection and artwork loading.
-  /// A `src`-bearing item becomes a playable track (thumbnail tap plays it); otherwise the
-  /// track only navigates via `url`.
-  func toTrack() -> Track {
-    Track(
-      id: id, url: url, src: src, artwork: artwork.map { .first($0) },
-      artworkSource: artworkSource, request: request,
-      artworkCarPlayTinted: nil, title: title, subtitle: nil, artist: artist,
-      albumUrl: albumUrl, album: album, description: nil, genre: nil, duration: nil, style: nil,
-      childrenStyle: nil, favorited: nil, groupTitle: nil, live: live, imageRow: nil,
-    )
-  }
-}

package/ios/CarPlay/RNABMediaAddHandler.swift

@@ -1,75 +0,0 @@
-import Foundation
-import Intents
-import os.log
-
-/// In-app `INAddMediaIntent` handler — "Hey Siri, add this to my favorites."
-/// Adding to the user's collection maps onto the library-managed favorite state
-/// of the **currently playing** track via `setActiveTrackFavorited` — the same
-/// path as the CarPlay favorite button and the `INUpdateMediaAffinityIntent`
-/// "like", so it flips the now-playing heart and fires `onFavoriteChanged` for
-/// the consumer to persist. No extra config beyond the `favorite` capability.
-///
-/// We expose a single flat favorites collection (no named playlists), so the
-/// destination always resolves to the user's library. Adding a *named* item
-/// that isn't currently playing needs the structured-intent consumer callback
-/// and is out of scope here — like the named play-by-search case.
-///
-/// Internal (keeps Intents types out of the generated header), exposed to the
-/// ObjC runtime via `@objc(RNABMediaAddHandler)` and vended from
-/// `RNABAudioBrowser.handlerForIntent(_:)`.
-@objc(RNABMediaAddHandler)
-class RNABMediaAddHandler: NSObject, INAddMediaIntentHandling {
-  private static let logger = Logger(subsystem: "com.audiobrowser", category: "MediaAddHandler")
-
-  func handle(
-    intent _: INAddMediaIntent,
-    completion: @escaping @Sendable (INAddMediaIntentResponse) -> Void,
-  ) {
-    Self.logger.info("Add media — favorite current track")
-
-    Task { @MainActor in
-      // "Add" targets the current track; if nothing is playing there's nothing
-      // to add, so the assistant reports failure rather than a silent no-op.
-      guard let browser = HybridAudioBrowser.shared,
-            browser.getPlayer()?.currentTrack != nil
-      else {
-        completion(INAddMediaIntentResponse(code: .failure, userActivity: nil))
-        return
-      }
-
-      // Add = favorite the currently-playing track (same path as the CarPlay
-      // favorite button / affinity "like"): flips the now-playing heart and
-      // fires `onFavoriteChanged` so the consumer persists it — no extra handler.
-      do {
-        try browser.setActiveTrackFavorited(favorited: true)
-        completion(INAddMediaIntentResponse(code: .success, userActivity: nil))
-      } catch {
-        completion(INAddMediaIntentResponse(code: .failure, userActivity: nil))
-      }
-    }
-  }
-
-  // Siri runs a resolve phase before `handle`; without a resolution method it
-  // errors ("Unable to find implementation of resolution method"). These are
-  // *optional* @objc protocol methods, so pin the exact selectors SiriKit
-  // dispatches to (otherwise they aren't exposed and are "not found"). We act on
-  // the currently-playing track / our single library, so pass both through.
-  @objc(resolveMediaItemsForAddMedia:withCompletion:)
-  func resolveMediaItems(
-    for intent: INAddMediaIntent,
-    with completion: @escaping ([INAddMediaMediaItemResolutionResult]) -> Void,
-  ) {
-    let name = intent.mediaSearch?.mediaName ?? ""
-    let item = INMediaItem(identifier: name, title: name, type: .unknown, artwork: nil)
-    completion([.success(with: item)])
-  }
-
-  @objc(resolveMediaDestinationForAddMedia:withCompletion:)
-  func resolveMediaDestination(
-    for _: INAddMediaIntent,
-    with completion: @escaping (INAddMediaMediaDestinationResolutionResult) -> Void,
-  ) {
-    // One flat favorites collection — always the user's library, no playlists.
-    completion(.success(with: INMediaDestination.library))
-  }
-}

package/ios/CarPlay/RNABMediaAffinityHandler.swift

@@ -1,69 +0,0 @@
-import Foundation
-import Intents
-import os.log
-
-/// In-app `INUpdateMediaAffinityIntent` handler — "Hey Siri, I like / don't like
-/// this." Maps the affinity onto the library-managed favorite state of the
-/// **currently playing** track via `setActiveTrackFavorited` — the same path as
-/// the CarPlay favorite button — so it flips the now-playing heart and fires
-/// `onFavoriteChanged` for the consumer to persist. Like → favorited, dislike →
-/// unfavorited. No extra config beyond the `favorite` capability.
-///
-/// Internal (keeps Intents types out of the generated header), exposed to the
-/// ObjC runtime via `@objc(RNABMediaAffinityHandler)` and vended from
-/// `RNABAudioBrowser.handlerForIntent(_:)`.
-///
-/// Affinity for a *named* item ("I like «station»") is out of scope here — that
-/// needs the structured-intent consumer callback.
-@objc(RNABMediaAffinityHandler)
-class RNABMediaAffinityHandler: NSObject, INUpdateMediaAffinityIntentHandling {
-  private static let logger = Logger(subsystem: "com.audiobrowser", category: "MediaAffinityHandler")
-
-  func handle(
-    intent: INUpdateMediaAffinityIntent,
-    completion: @escaping @Sendable (INUpdateMediaAffinityIntentResponse) -> Void,
-  ) {
-    let affinity = intent.affinityType
-    Self.logger.info("Update media affinity — type=\(affinity.rawValue)")
-
-    Task { @MainActor in
-      // Affinity targets the current track; if nothing is playing there's nothing
-      // to like, so the assistant reports failure rather than a silent no-op.
-      guard let browser = HybridAudioBrowser.shared,
-            browser.getPlayer()?.currentTrack != nil
-      else {
-        completion(INUpdateMediaAffinityIntentResponse(code: .failure, userActivity: nil))
-        return
-      }
-
-      // Map affinity onto the library-managed favorite state (same path as the
-      // CarPlay favorite button): flips the now-playing heart and fires
-      // `onFavoriteChanged` so the consumer persists it — no extra handler.
-      switch affinity {
-      case .like:
-        try? browser.setActiveTrackFavorited(favorited: true)
-      case .dislike:
-        try? browser.setActiveTrackFavorited(favorited: false)
-      default:
-        completion(INUpdateMediaAffinityIntentResponse(code: .failure, userActivity: nil))
-        return
-      }
-      completion(INUpdateMediaAffinityIntentResponse(code: .success, userActivity: nil))
-    }
-  }
-
-  // Siri runs a resolve phase before `handle`; without a resolution method it
-  // errors ("Unable to find implementation of resolution method"). This is an
-  // *optional* @objc protocol method, so pin the exact selector SiriKit dispatches
-  // to (otherwise it isn't exposed and is "not found"). We act on the currently
-  // playing track regardless, so pass the spoken item straight through.
-  @objc(resolveMediaItemsForUpdateMediaAffinity:withCompletion:)
-  func resolveMediaItems(
-    for intent: INUpdateMediaAffinityIntent,
-    with completion: @escaping ([INUpdateMediaAffinityMediaItemResolutionResult]) -> Void,
-  ) {
-    let name = intent.mediaSearch?.mediaName ?? ""
-    let item = INMediaItem(identifier: name, title: name, type: .unknown, artwork: nil)
-    completion([.success(with: item)])
-  }
-}

package/ios/Extension/PlayerCapabilities+Favorite.swift

@@ -1,20 +0,0 @@
-import Foundation
-
-extension PlayerCapabilities {
-  /// Resolved favorite match mode, or `nil` when favoriting is disabled.
-  ///
-  /// `false`/unset → `nil`; `true` → `.exact`; `{ match }` → that match.
-  var favoriteMatch: FavoritesMatchMode? {
-    switch favorite {
-    case .none:
-      nil
-    case let .some(.first(enabled)):
-      enabled ? .exact : nil
-    case let .some(.second(config)):
-      config.match
-    }
-  }
-
-  /// Whether the favorite/like control is enabled.
-  var favoriteEnabled: Bool { favoriteMatch != nil }
-}

package/ios/Extension/RequestConfig+Copying.swift

@@ -1,31 +0,0 @@
-import NitroModules
-
-extension RequestConfig {
-  /// Returns a copy of this RequestConfig with only the specified fields changed.
-  ///
-  /// `RequestConfig` is a C++-backed Nitro struct whose fields are get-only, so
-  /// "mutation" means rebuilding via the initializer. Uses double-optional
-  /// (`T??`) so callers can distinguish omitted (keep), `.some(nil)` (clear),
-  /// and `.some(value)` (set).
-  func copying(
-    method: HttpMethod?? = nil,
-    path: String?? = nil,
-    baseUrl: String?? = nil,
-    headers: [String: String]?? = nil,
-    query: [String: String]?? = nil,
-    body: String?? = nil,
-    contentType: String?? = nil,
-    userAgent: String?? = nil,
-  ) -> RequestConfig {
-    RequestConfig(
-      method: method ?? self.method,
-      path: path ?? self.path,
-      baseUrl: baseUrl ?? self.baseUrl,
-      headers: headers ?? self.headers,
-      query: query ?? self.query,
-      body: body ?? self.body,
-      contentType: contentType ?? self.contentType,
-      userAgent: userAgent ?? self.userAgent,
-    )
-  }
-}

package/ios/Extension/Variant+Artwork.swift

@@ -1,49 +0,0 @@
-import Foundation
-
-/// Reading the `artwork` union, which is either one URL or a URL per appearance.
-///
-/// Nitro surfaces it as `.first(String)` / `.second(ArtworkVariants)`. Call
-/// sites want one of two things — the URL to display, or both URLs so a
-/// `UIImageAsset` can adapt without re-fetching — so those are the only
-/// accessors here, and nothing below the boundary repeats the unwrap.
-///
-/// Deliberately Foundation-only: this is part of the SPM testable target, which
-/// also builds for macOS, so it cannot reach for `UIUserInterfaceStyle` to name
-/// an appearance. Picking between the two URLs is CarPlay's job anyway — it
-/// registers both and lets UIKit choose.
-extension Variant_String_ArtworkVariants {
-  /// Both URLs, when the track ships a pair; `nil` for a single URL, which
-  /// needs no per-appearance handling.
-  var variants: ArtworkVariants? {
-    switch self {
-    case .first: nil
-    case let .second(variants): variants
-    }
-  }
-
-  /// The URL to use where appearance is unknown or does not apply — now-playing
-  /// metadata, JS-facing values, the artwork transform pipeline.
-  ///
-  /// Resolves a pair to its dark URL. CarPlay dark is the common case, Android
-  /// Auto is dark-only, and it is what a single-URL track would have shipped
-  /// anyway — so a caller that cannot express appearance gets the same image it
-  /// got before pairs existed.
-  var url: String {
-    switch self {
-    case let .first(url): url
-    case let .second(variants): variants.dark
-    }
-  }
-}
-
-extension Variant_String_ArtworkVariants: Equatable {
-  /// Needed by `TabBarEntries.same`, and by the synthesised `Track: Equatable`
-  /// in the test stubs; the generated enum declares no conformance itself.
-  public static func == (lhs: Self, rhs: Self) -> Bool {
-    switch (lhs, rhs) {
-    case let (.first(l), .first(r)): l == r
-    case let (.second(l), .second(r)): l.light == r.light && l.dark == r.dark
-    default: false
-    }
-  }
-}

package/ios/NowPlayingInfo/SilentAudioPrimer.swift

@@ -1,73 +0,0 @@
-import AVFoundation
-import Foundation
-import os.log
-
-/// Renders a fraction of a second of generated silence through the app's audio session.
-///
-/// iOS elects an app onto the system now-playing surfaces (lock screen, Control
-/// Center, the CarPlay now-playing template) only once its audio session actually
-/// renders output. Published metadata alone never surfaces — and the explicit
-/// `MPNowPlayingInfoCenter.playbackState` write is dropped on iOS without a private
-/// entitlement (`com.apple.mediaremote.set-playback-state`), so there is no
-/// declarative way in. When the very first load of a session fails, no audio ever
-/// renders and the failure line + transport controls have nowhere to appear.
-/// Rendering one burst of silence satisfies the election rule; the session's
-/// already-published info (station + failure line) then displays.
-///
-/// The samples are zeros: inaudible by construction, no volume tricks involved.
-@MainActor
-final class SilentAudioPrimer {
-  private let logger = Logger(subsystem: "com.audiobrowser", category: "SilentAudioPrimer")
-
-  private static let duration: TimeInterval = 0.3
-
-  /// Held while playing so the player isn't deallocated mid-render.
-  private var player: AVAudioPlayer?
-
-  func prime() {
-    guard player == nil else { return }
-    guard let wav = Self.silentWav else { return }
-    do {
-      let player = try AVAudioPlayer(data: wav)
-      self.player = player
-      logger.notice("Priming now-playing election with \(Self.duration)s of silence")
-      player.play()
-      DispatchQueue.main.asyncAfter(deadline: .now() + Self.duration + 0.2) { [weak self] in
-        self?.player = nil
-      }
-    } catch {
-      logger.error("Failed to create silent primer player: \(error.localizedDescription)")
-    }
-  }
-
-  /// A minimal mono 16-bit PCM WAV of silence. 8 kHz keeps it a few KB — the
-  /// content is zeros, so fidelity is irrelevant.
-  private static let silentWav: Data? = makeSilentWav()
-
-  private static func makeSilentWav() -> Data? {
-    let sampleRate = 8000
-    let sampleCount = Int(Double(sampleRate) * duration)
-    let dataSize = sampleCount * 2 // 16-bit mono
-    var data = Data(capacity: 44 + dataSize)
-
-    func append(_ string: String) { data.append(contentsOf: Array(string.utf8)) }
-    func append32(_ value: Int) { withUnsafeBytes(of: UInt32(value).littleEndian) { data.append(contentsOf: $0) } }
-    func append16(_ value: Int) { withUnsafeBytes(of: UInt16(value).littleEndian) { data.append(contentsOf: $0) } }
-
-    append("RIFF")
-    append32(36 + dataSize)
-    append("WAVE")
-    append("fmt ")
-    append32(16) // PCM fmt chunk size
-    append16(1) // linear PCM
-    append16(1) // mono
-    append32(sampleRate)
-    append32(sampleRate * 2) // byte rate
-    append16(2) // block align
-    append16(16) // bits per sample
-    append("data")
-    append32(dataSize)
-    data.append(contentsOf: [UInt8](repeating: 0, count: dataSize))
-    return data
-  }
-}

package/ios/Player/AirPlayStallJudgement.swift

@@ -1,25 +0,0 @@
-/// Pure decision for the AirPlay "silently stuck" recovery, kept free of
-/// AVFoundation so it can be unit-tested off-device.
-///
-/// Over AirPlay, AVPlayer can drop `.waitingToPlayAtSpecifiedRate` (reason
-/// `.noItemToPlay`) → `.paused` while the app still intends to play, leaving
-/// playback stuck/silent with no error. Re-issuing `play()` on exactly that
-/// transition recovers it. Scoped narrowly to AirPlay so it never nudges a
-/// legitimate pause on the local route.
-struct AirPlayStallJudgement {
-  let previous: PlayerTimeControlStatus?
-  let current: PlayerTimeControlStatus
-  /// Whether the previous waiting state's reason was specifically
-  /// `.noItemToPlay` (the AirPlay-stall signature, not a normal rebuffer).
-  let previousWaitingReasonWasNoItemToPlay: Bool
-  let isAirPlay: Bool
-  let playWhenReady: Bool
-
-  var shouldNudge: Bool {
-    isAirPlay
-      && playWhenReady
-      && current == .paused
-      && previous == .waitingToPlayAtSpecifiedRate
-      && previousWaitingReasonWasNoItemToPlay
-  }
-}

package/ios/Player/EndOfTrackJudgement.swift

@@ -1,32 +0,0 @@
-import Foundation
-
-/// Whether an `AVPlayerItemDidPlayToEndTime` notification represents a genuine
-/// end of the track, or a stall masquerading as one.
-enum EndOfTrackOutcome: Equatable {
-  /// Genuine end — advance the queue / complete.
-  case ended
-  /// Not a real end (a dropped live stream, or a mid-stream buffer exhaustion
-  /// reported as EOF) — recover instead of advancing.
-  case stalled
-}
-
-/// Pure decision for how to treat an end-of-item notification, kept free of
-/// AVFoundation so it can be unit-tested off-device. iOS surfaces a dropped
-/// connection on a live stream — and sometimes a mid-stream buffer underrun —
-/// as a "played to end", which would otherwise stop the station or skip the
-/// track.
-struct EndOfTrackJudgement {
-  let isLive: Bool
-  let currentTime: Double
-  let duration: Double
-
-  var outcome: EndOfTrackOutcome {
-    // Live streams are infinite; an end-of-item here is a dropped connection.
-    if isLive { return .stalled }
-    // Indefinite/unknown duration — can't validate the position, trust iOS.
-    guard duration.isFinite, duration > 0 else { return .ended }
-    // More than 5% short of the end → a stall reported as EOF, not a real finish.
-    if currentTime + duration * 0.05 < duration { return .stalled }
-    return .ended
-  }
-}