react-native-audio-browser 0.2.0-next.27 → 0.2.0-next.29

package/ios/Player/PlaybackEffectHandler.swift

@@ -1,54 +0,0 @@
-#if canImport(NitroModules)
-  import NitroModules
-#endif
-
-/// Protocol through which PlaybackCoordinator triggers AVPlayer-specific operations.
-/// In production, TrackPlayer implements it. In tests, a mock does.
-@MainActor protocol PlaybackEffectHandler: AnyObject {
-  // Playback control
-  func startPlayback()
-  func pausePlayback()
-  func setTimePitchingAlgorithmForCurrentItem()
-
-  // Player volume (0-1); ramped by the sleep-timer fade
-  var volume: Float { get set }
-
-  // AVPlayer state queries
-  var currentTime: Double { get }
-  var duration: Double { get }
-  var bufferedPosition: Double { get }
-  var hasLoadedAsset: Bool { get }
-
-  // Item management
-  func clearCurrentItem()
-  func stopObservingCurrentItem()
-
-  // Track loading. The full `track` is threaded alongside `src` so the
-  // media-URL resolver can invoke the consumer's `media.resolve(track)`.
-  func loadTrack(src: String, track: Track)
-  /// Reloads the current track, re-running the media-URL resolver so a
-  /// short-lived/expired URL is refreshed rather than replayed.
-  func reloadTrack(startFromCurrentTime: Bool)
-  func unloadTrack()
-  func cancelMediaLoading()
-
-  // Seek operations
-  func seekToStart()
-  func replayCurrentTrack()
-
-  // Now Playing (behind protocol to avoid MediaPlayer import).
-  // Elapsed/rate/duration are published automatically by MPNowPlayingSession;
-  // only metadata and the explicit play/pause state flow through here.
-  func loadNowPlayingMetadata(for track: Track)
-  func clearNowPlaying()
-  /// Reflects play/pause intent in the now-playing center. Auto-publishing fills
-  /// the info dict but not the explicit playback state CarPlay reads for its button.
-  func updateNowPlayingState(playWhenReady: Bool)
-
-  // Remote commands (behind protocol to avoid MediaPlayer import)
-  func updateRemoteRepeatMode(_ mode: RepeatMode)
-  func updateRemoteShuffleMode(_ enabled: Bool)
-  /// Greys out the remote/CarPlay next/previous buttons when the queue has no
-  /// next/previous track to skip to.
-  func updateSkipAvailability(canNext: Bool, canPrevious: Bool)
-}

package/ios/Player/PlaybackErrorHandler.swift

@@ -1,175 +0,0 @@
-import AVFoundation
-import Foundation
-import os.log
-
-/// Abstracts RetryManager for testability.
-@MainActor public protocol RetryHandling: AnyObject {
-  /// False when the configured policy is `disabled` — every error is then terminal.
-  var isEnabled: Bool { get }
-  /// Whether the current load has produced audio — selects the retry budget.
-  var hasPlayed: Bool { get set }
-  func isRetryable(_ error: Error?, httpStatusCode: Int?) -> Bool
-  func attemptRetry(startFromCurrentTime: Bool) async -> Bool
-  func reset()
-}
-
-/// Distinguishes playback failures from media-load failures.
-/// Each context carries the retry strategy and the fallback error classification.
-public enum PlaybackErrorContext {
-  /// AVPlayer/AVPlayerItem status failure — retry from current time, fallback `.playbackFailed`.
-  case playback
-  /// MediaLoader key-value load failure — retry from start, fallback `.failedToLoadKeyValue`.
-  case mediaLoad
-
-  var startFromCurrentTime: Bool {
-    switch self {
-    case .playback: true
-    case .mediaLoad: false
-    }
-  }
-
-  var fallbackError: TrackPlayerError.PlaybackError {
-    switch self {
-    case .playback: .playbackFailed
-    case .mediaLoad: .failedToLoadKeyValue
-    }
-  }
-}
-
-/// Consolidates error retry/classification logic previously duplicated between
-/// `handlePlaybackFailure` and `mediaLoaderDidFailWithRetryableError`.
-@MainActor public class PlaybackErrorHandler {
-  private let logger = Logger(subsystem: "com.audiobrowser", category: "PlaybackErrorHandler")
-
-  var onError: ((TrackPlayerError.PlaybackError) -> Void)?
-  /// A failure the retry loop is still working on. Fired when a retry is
-  /// scheduled, before its backoff elapses, so UIs can show the cause while
-  /// the playback state stays non-terminal. `onError` still fires if the
-  /// retries give up.
-  var onRetryingError: ((TrackPlayerError.PlaybackError) -> Void)?
-  private(set) var pendingRetryTask: Task<Void, Never>?
-  private let retryHandler: any RetryHandling
-
-  init(retryHandler: any RetryHandling) {
-    self.retryHandler = retryHandler
-  }
-
-  func handleError(_ error: Error?, context: PlaybackErrorContext, httpStatusCode: Int? = nil) {
-    if let error {
-      let nsError = error as NSError
-      logger.error("[\(String(describing: context))] failure: domain=\(nsError.domain), code=\(nsError.code), localizedDescription=\(error.localizedDescription)")
-    } else {
-      logger.error("[\(String(describing: context))] failure with nil error")
-    }
-
-    if retryHandler.isEnabled, retryHandler.isRetryable(error, httpStatusCode: httpStatusCode) {
-      onRetryingError?(PlaybackErrorHandler.classify(
-        error: error, fallback: context.fallbackError, httpStatusCode: httpStatusCode,
-      ))
-      pendingRetryTask?.cancel()
-      pendingRetryTask = Task { [weak self] in
-        guard let self else { return }
-        let retried = await retryHandler.attemptRetry(startFromCurrentTime: context.startFromCurrentTime)
-        // Cancelled (track change / stop): stay silent — attemptRetry returns
-        // false on a cancelled wait, and surfacing that would flip the new
-        // track or a deliberate stop to .error. The canceller owns the handle.
-        if Task.isCancelled { return }
-        if !retried {
-          let classified = PlaybackErrorHandler.classify(error: error, fallback: context.fallbackError, httpStatusCode: httpStatusCode)
-          self.onError?(classified)
-        }
-        // Clear the handle: session release is gated on no pending retry.
-        pendingRetryTask = nil
-      }
-      return
-    }
-
-    logger.warning("Error not retryable, surfacing \(String(describing: context.fallbackError))")
-    let classified = PlaybackErrorHandler.classify(error: error, fallback: context.fallbackError, httpStatusCode: httpStatusCode)
-    onError?(classified)
-  }
-
-  func cancelPendingRetry() {
-    pendingRetryTask?.cancel()
-    pendingRetryTask = nil
-  }
-
-  func resetRetry() {
-    cancelPendingRetry()
-    retryHandler.reset()
-  }
-
-  /// A restart from a terminal error begins a new load of the same track:
-  /// fresh budgets and unproven playback, so the user's tap yields a visible
-  /// first-connect retry window instead of a single silent attempt — the same
-  /// behavior as re-selecting the track (ADR 0004).
-  func resetForNewLoad() {
-    resetRetry()
-    retryHandler.hasPlayed = false
-  }
-
-  /// Classifies an error into the narrowest case the evidence supports, so JS
-  /// receives a real `kind` rather than a context fallback.
-  ///
-  /// Order matters: a transport failure means we never got a response, so it
-  /// outranks any status left in the item's error log. AVFoundation reports
-  /// HTTP failures as opaque CoreMedia errors, which is why `httpStatusCode`
-  /// is passed in separately by the caller rather than read off `error`.
-  public static func classify(
-    error: Error?,
-    fallback: TrackPlayerError.PlaybackError,
-    httpStatusCode: Int? = nil,
-  ) -> TrackPlayerError.PlaybackError {
-    // `as?` bridges plain `NSError`s in `NSURLErrorDomain` too, which is the
-    // form AVFoundation usually hands back.
-    if let urlError = error as? URLError {
-      switch urlError.code {
-      case .notConnectedToInternet:
-        return .notConnectedToInternet
-      case .timedOut,
-           .cannotFindHost,
-           .cannotConnectToHost,
-           .networkConnectionLost,
-           .dnsLookupFailed,
-           .secureConnectionFailed:
-        return .hostUnreachable
-      default:
-        break
-      }
-    }
-
-    if let httpStatusCode, !(200 ... 299).contains(httpStatusCode) {
-      return .httpStatus(httpStatusCode)
-    }
-
-    if isUnplayableMedia(error) {
-      return .trackWasUnplayable
-    }
-
-    return fallback
-  }
-
-  /// Picks the HTTP status out of an `AVPlayerItem` error log's status codes.
-  ///
-  /// `errorStatusCode` is a mixed space — negative OSStatus values share it
-  /// with HTTP statuses — so only in-range values count, and the newest wins:
-  /// a live stream reconnects, and older entries describe earlier attempts.
-  public static func httpStatusCode(fromErrorStatusCodes codes: [Int]) -> Int? {
-    codes.last { (100 ... 599).contains($0) }
-  }
-
-  /// The stream was fetched but cannot be decoded — unknown container,
-  /// unsupported codec, or a decoder that refused it.
-  private static func isUnplayableMedia(_ error: Error?) -> Bool {
-    guard let nsError = error as NSError? else { return false }
-    guard nsError.domain == AVFoundationErrorDomain else { return false }
-    return [
-      AVError.fileFormatNotRecognized,
-      AVError.failedToParse,
-      AVError.decoderNotFound,
-      AVError.decoderTemporarilyUnavailable,
-      AVError.formatUnsupported,
-      AVError.contentIsUnavailable,
-    ].contains { $0.rawValue == nsError.code }
-  }
-}

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/PlayingStateManager.swift

@@ -1,33 +0,0 @@
-import Foundation
-#if canImport(NitroModules)
-  import NitroModules
-#endif
-
-/// Manages the playing state (playing and buffering flags) and notifies when they change.
-@MainActor
-class PlayingStateManager {
-  private(set) var playing: Bool = false
-  private(set) var buffering: Bool = false
-
-  private let onChange: (PlayingState) -> Void
-
-  init(onChange: @escaping (PlayingState) -> Void) {
-    self.onChange = onChange
-  }
-
-  func update(playWhenReady: Bool, state: PlaybackState) {
-    let newPlaying =
-      playWhenReady && !(state == .error || state == .ended || state == .none || state == .stopped)
-    let newBuffering = playWhenReady && (state == .loading || state == .buffering)
-
-    if newPlaying != playing || newBuffering != buffering {
-      playing = newPlaying
-      buffering = newBuffering
-      onChange(PlayingState(playing: playing, buffering: buffering))
-    }
-  }
-
-  func toPlayingState() -> PlayingState {
-    PlayingState(playing: playing, buffering: buffering)
-  }
-}

package/ios/Player/RetryManager.swift

@@ -1,384 +0,0 @@
-import AVFoundation
-import Foundation
-#if canImport(NitroModules)
-  import NitroModules
-#endif
-import os.log
-
-/// Abstracts `NetworkMonitor` so tests can fake connectivity. Sendable because
-/// the network-restore race reads it from a task-group child.
-protocol NetworkStatusProviding: AnyObject, Sendable {
-  var isOnline: Bool { get }
-}
-
-/// Manages retry logic for media load errors with exponential backoff.
-/// Similar to Android's RetryLoadErrorHandlingPolicy.
-///
-/// Two duration budgets apply, chosen by whether the current load has ever
-/// produced audio (`hasPlayed`): a short first-connect budget — a stream that
-/// fails before ever playing is usually dead, and the listener is actively
-/// waiting for a verdict — and the full recovery budget for a stream that
-/// played and then dropped (tunnels, handovers, encoder restarts). The short
-/// budget counts only online time, so a station tapped in a tunnel still gets
-/// its online seconds once connectivity returns.
-///
-/// When a network monitor is provided and the device is offline, the retry will
-/// trigger immediately when connectivity is restored instead of waiting for the
-/// full backoff delay.
-@MainActor
-class RetryManager {
-  private let logger = Logger(subsystem: "com.audiobrowser", category: "RetryManager")
-
-  enum Policy {
-    case disabled
-    case infinite
-    case limited(maxRetries: Int)
-  }
-
-  private static let defaultMaxRetryDurationMs: Double = 120_000 // 2 minutes
-  private static let defaultFirstConnectMaxRetryDurationMs: Double = 12_000
-
-  /// Prevents surprising playback resumption after long periods offline.
-  private var maxRetryDuration: TimeInterval = defaultMaxRetryDurationMs / 1000
-
-  /// Bounds retries of a load that has never produced audio, while online.
-  private var firstConnectMaxRetryDuration: TimeInterval = defaultFirstConnectMaxRetryDurationMs / 1000
-
-  /// True once the current load has produced audio; selects between the
-  /// first-connect and recovery budgets. Set by the owner when audio starts and
-  /// cleared by the owner when a new track loads — deliberately NOT cleared in
-  /// `reset()`, which the healthy-playback budget refill also calls mid-play.
-  var hasPlayed = false
-
-  /// First failure observed while online for the current load — the
-  /// first-connect budget's clock. Never set while offline, and wiped by any
-  /// offline observation, so an offline stretch cannot burn the short budget:
-  /// the clock restarts at the next failure observed online.
-  private var firstOnlineRetryTime: Date?
-
-  private var policy: Policy = .disabled
-  private var attemptCount = 0
-  private var firstRetryTime: Date?
-
-  weak var networkMonitor: (any NetworkStatusProviding)?
-  /// True only while a scheduled retry is parked polling for connectivity to return. Exposed so the
-  /// player's stall-driven reconnect can defer to an in-flight error retry (which owns its own
-  /// reload) and avoid a double load.
-  private(set) var isWaitingForNetwork = false
-  /// Invalidates in-flight retries when reset() is called (e.g. track change)
-  private var generation: Int = 0
-
-  var shouldRetry: () -> Bool = { true }
-  var onRetry: ((Bool) -> Void)?
-
-  var isEnabled: Bool {
-    if case .disabled = policy { return false }
-    return true
-  }
-
-  // MARK: - Configuration
-
-  func updatePolicy(from config: Variant_Bool_RetryConfig?) {
-    guard let config else {
-      policy = .disabled
-      maxRetryDuration = Self.defaultMaxRetryDurationMs / 1000
-      firstConnectMaxRetryDuration = Self.defaultFirstConnectMaxRetryDurationMs / 1000
-      logger.debug("Retry policy: disabled")
-      return
-    }
-
-    switch config {
-    case let .first(enabled):
-      policy = enabled ? .infinite : .disabled
-      maxRetryDuration = Self.defaultMaxRetryDurationMs / 1000
-      firstConnectMaxRetryDuration = Self.defaultFirstConnectMaxRetryDurationMs / 1000
-      logger.debug("Retry policy: \(enabled ? "infinite" : "disabled")")
-    case let .second(retryConfig):
-      let durationMs = retryConfig.maxRetryDurationMs ?? Self.defaultMaxRetryDurationMs
-      maxRetryDuration = durationMs / 1000
-      let firstConnectMs = retryConfig.firstConnectMaxRetryDurationMs
-        ?? Self.defaultFirstConnectMaxRetryDurationMs
-      firstConnectMaxRetryDuration = firstConnectMs / 1000
-      // No attempt cap = retry indefinitely, bounded only by the duration.
-      if let maxRetries = retryConfig.maxRetries.map(Int.init) {
-        policy = .limited(maxRetries: maxRetries)
-        logger.debug("Retry policy: limited to \(maxRetries) retries, max duration \(self.maxRetryDuration)s")
-      } else {
-        policy = .infinite
-        logger.debug("Retry policy: infinite, max duration \(self.maxRetryDuration)s")
-      }
-    }
-  }
-
-  // MARK: - Exponential Backoff
-
-  /// Delays: 1s -> 1.5s -> 2.3s -> 3.4s -> 5s (capped)
-  private func calculateDelaySeconds() -> Double {
-    let baseDelay = 1.0
-    let multiplier = 1.5
-    let maxDelay = 5.0
-
-    return min(baseDelay * pow(multiplier, Double(attemptCount)), maxDelay)
-  }
-
-  // MARK: - Error Classification
-
-  /// 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 }
-
-    // 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
-      }
-    }
-
-    let nsError = error as NSError
-    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
-
-  func reset() {
-    attemptCount = 0
-    firstRetryTime = nil
-    firstOnlineRetryTime = nil
-    isWaitingForNetwork = false
-    generation += 1
-    logger.debug("Retry count reset (generation \(self.generation))")
-  }
-
-  private var isOnline: Bool { networkMonitor?.isOnline ?? true }
-
-  /// A description of the exhausted budget, or nil while budget remains.
-  /// The recovery duration bounds everything (including offline waits); the
-  /// first-connect duration additionally bounds never-played loads, online only.
-  private func exhaustedBudget() -> String? {
-    let now = Date()
-    if let start = firstRetryTime, now.timeIntervalSince(start) >= maxRetryDuration {
-      return "max retry duration (\(maxRetryDuration)s)"
-    }
-    if !hasPlayed, isOnline, let start = firstOnlineRetryTime,
-       now.timeIntervalSince(start) >= firstConnectMaxRetryDuration
-    {
-      return "first-connect retry duration (\(firstConnectMaxRetryDuration)s)"
-    }
-    return nil
-  }
-
-  func attemptRetry(startFromCurrentTime: Bool) async -> Bool {
-    if case .disabled = policy {
-      logger.debug("Retry disabled, not retrying")
-      return false
-    }
-
-    guard shouldRetry() else {
-      logger.debug("shouldRetry returned false, not retrying")
-      return false
-    }
-
-    if case let .limited(maxRetries) = policy {
-      if attemptCount >= maxRetries {
-        logger.info("Max retries (\(maxRetries)) exceeded, giving up")
-        return false
-      }
-    }
-
-    if firstRetryTime == nil {
-      firstRetryTime = Date()
-    }
-    if isOnline {
-      if firstOnlineRetryTime == nil { firstOnlineRetryTime = Date() }
-    } else {
-      // Seeing the device offline restarts the first-connect clock: a station
-      // that lost connectivity mid-budget gets its full online seconds again
-      // after restoration, instead of the offline gap counting against it.
-      firstOnlineRetryTime = nil
-    }
-
-    // Check if we've been retrying too long (prevents surprising resumption
-    // after long offline periods, and grants dead-on-arrival streams a fast verdict)
-    if let budget = exhaustedBudget() {
-      logger.info("\(budget) exceeded, giving up")
-      return false
-    }
-
-    let delaySeconds = calculateDelaySeconds()
-    let currentGeneration = generation
-    logger.info("Scheduling retry after \(delaySeconds)s")
-
-    // Race between: backoff delay OR network restored (if offline)
-    let waitCancelled = await waitForDelayOrNetworkRestored(delaySeconds: delaySeconds)
-
-    if waitCancelled {
-      logger.debug("Retry wait cancelled")
-      return false
-    }
-
-    // Check if reset() was called while we were waiting
-    guard generation == currentGeneration else {
-      logger.debug("Retry invalidated by reset (generation changed)")
-      return false
-    }
-
-    // Cancellation can land after the sleep completed — without this check a
-    // replaced retry (new error right as the old backoff expires) still fires
-    // onRetry, double-reloading and burning the attempt count twice.
-    guard !Task.isCancelled else { return false }
-
-    guard shouldRetry() else {
-      logger.debug("shouldRetry returned false after delay, cancelling retry")
-      return false
-    }
-
-    // Re-check the budgets — we may have waited a long time for network restoration
-    if let budget = exhaustedBudget() {
-      logger.info("\(budget) exceeded after waiting, giving up")
-      return false
-    }
-
-    attemptCount += 1
-    logger.info("Executing retry #\(self.attemptCount)")
-    onRetry?(startFromCurrentTime)
-    return true
-  }
-
-  // MARK: - Network-Aware Waiting
-
-  /// Returns true if cancelled, false if ready to retry.
-  private func waitForDelayOrNetworkRestored(delaySeconds: Double) async -> Bool {
-    let isOffline = !(networkMonitor?.isOnline ?? true)
-
-    guard isOffline, let monitor = networkMonitor else {
-      do {
-        let nanoseconds = UInt64(delaySeconds * 1_000_000_000)
-        try await Task.sleep(nanoseconds: nanoseconds)
-        return false
-      } catch {
-        return true // Cancelled
-      }
-    }
-
-    logger.debug("Device is offline, will retry immediately when connectivity is restored")
-
-    return await withTaskGroup(of: Bool.self, returning: Bool.self) { group in
-      group.addTask {
-        do {
-          let nanoseconds = UInt64(delaySeconds * 1_000_000_000)
-          try await Task.sleep(nanoseconds: nanoseconds)
-          return false
-        } catch {
-          return true
-        }
-      }
-
-      group.addTask { [weak self] in
-        await self?.waitForNetworkRestored(monitor: monitor) ?? true
-      }
-
-      let result = await group.next() ?? true
-      group.cancelAll()
-      return result
-    }
-  }
-
-  /// Returns false when network is restored, true if cancelled.
-  @MainActor
-  private func waitForNetworkRestored(monitor: any NetworkStatusProviding) async -> Bool {
-    if monitor.isOnline {
-      return false
-    }
-
-    isWaitingForNetwork = true
-    defer { isWaitingForNetwork = false }
-
-    logger.debug("Device is offline, polling for network restoration")
-
-    while !monitor.isOnline {
-      do {
-        try await Task.sleep(nanoseconds: 500_000_000) // 0.5s poll
-      } catch {
-        return true // Task cancelled
-      }
-    }
-
-    logger.info("Network restored, accelerating retry")
-    return false
-  }
-}
-
-// MARK: - RetryHandling
-
-extension RetryManager: RetryHandling {}

package/ios/Player/SeekCompletionHandler.swift

@@ -1,5 +0,0 @@
-// 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)
-}