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

package/ios/Model/TrackPlayerError.swift

@@ -1,6 +1,6 @@
 import Foundation
 #if canImport(NitroModules)
-  import NitroModules
+import NitroModules
 #endif
 
 public enum TrackPlayerError: Error {
@@ -8,13 +8,8 @@ public enum TrackPlayerError: Error {
     case failedToLoadKeyValue
     case invalidSourceUrl(String)
     case notConnectedToInternet
-    /// DNS, connect, timeout or a dropped connection — we never reached the host.
-    case hostUnreachable
-    /// The server answered with a non-2xx status.
-    case httpStatus(Int)
     case playbackFailed
     case trackWasUnplayable
-    case playbackStalled
   }
 
   public enum QueueError: Error {
@@ -33,16 +28,10 @@ extension TrackPlayerError.PlaybackError: LocalizedError {
       "Invalid audio source URL: \(url)"
     case .notConnectedToInternet:
       "No internet connection"
-    case .hostUnreachable:
-      "Could not reach the stream host"
-    case let .httpStatus(status):
-      "Server responded with HTTP \(status)"
     case .playbackFailed:
       "Playback failed"
     case .trackWasUnplayable:
       "Track is not playable"
-    case .playbackStalled:
-      "Playback stalled"
     }
   }
 }
@@ -60,78 +49,25 @@ extension TrackPlayerError.QueueError: LocalizedError {
   }
 }
 
-// MARK: - Cross-platform Classification
+#if canImport(NitroModules)
+// MARK: - Nitro PlaybackError Conversion
 
 public extension TrackPlayerError.PlaybackError {
-  /// The platform-specific identifier, for diagnostics only. Consumers branch
-  /// on `kind`; this is what they log.
-  var code: String {
-    switch self {
-    case .failedToLoadKeyValue: "failed-to-load"
-    case .invalidSourceUrl: "invalid-source-url"
-    case .notConnectedToInternet: "not-connected-to-internet"
-    case .hostUnreachable: "host-unreachable"
-    case .httpStatus: "http-status"
-    case .playbackFailed: "playback-failed"
-    case .trackWasUnplayable: "track-unplayable"
-    case .playbackStalled: "playback-stalled"
-    }
-  }
-
-  /// The normalized classification handed to JS. Android derives the same set
-  /// from its ExoPlayer codes, so app-side copy can switch on this alone.
-  var kind: PlaybackErrorKind {
-    switch self {
-    case .notConnectedToInternet: .offline
-    case .hostUnreachable: .unreachable
-    case let .httpStatus(status): TrackPlayerError.PlaybackError.kind(forHttpStatus: status)
-    // A missing or malformed source URL is a broken stream from the listener's
-    // side — same outcome as an undecodable one.
-    case .invalidSourceUrl, .trackWasUnplayable: .unplayable
-    case .playbackStalled: .stalled
-    // Context fallbacks: the underlying error carried nothing we could classify.
-    case .failedToLoadKeyValue, .playbackFailed: .unknown
-    }
-  }
-
-  /// The HTTP status behind this error, when it came from a server response.
-  var statusCode: Int? {
-    if case let .httpStatus(status) = self { return status }
-    return nil
-  }
-
-  static func kind(forHttpStatus status: Int) -> PlaybackErrorKind {
-    switch status {
-    case 404, 410: .notFound
-    case 500 ... 599: .serverError
-    // Every other 4xx is the server refusing us — auth, geo-blocking, a
-    // rate limit. All of them mean "you can't have this stream", not "retry".
-    case 400 ... 499: .rejected
-    default: .unknown
+  /// Converts to Nitro PlaybackError for JS callbacks
+  func toNitroError() -> PlaybackError {
+    let code = switch self {
+    case .failedToLoadKeyValue:
+      "failed_to_load"
+    case .invalidSourceUrl:
+      "invalid_source_url"
+    case .notConnectedToInternet:
+      "not_connected_to_internet"
+    case .playbackFailed:
+      "playback_failed"
+    case .trackWasUnplayable:
+      "track_unplayable"
     }
+    return PlaybackError(code: code, message: errorDescription ?? "Unknown error")
   }
 }
-
-// MARK: - Nitro PlaybackError Conversion
-
-// Internal, not public: the stub `PlaybackError` struct is internal, and every
-// caller of this lives in the module.
-extension TrackPlayerError.PlaybackError {
-  /// Converts to Nitro PlaybackError for JS callbacks.
-  ///
-  /// Deliberately not behind `#if canImport(NitroModules)`: the stub struct in
-  /// `NitroTypeStubs` mirrors the generated one field for field, so this single
-  /// definition compiles in both worlds and the tests exercise the shipped
-  /// converter rather than a copy of it.
-  /// `retrying` marks an advisory error the retry loop is still working on
-  /// (surfaced with a non-terminal playback state); terminal errors leave it nil.
-  func toNitroError(retrying: Bool = false) -> PlaybackError {
-    PlaybackError(
-      kind: kind,
-      code: code,
-      message: errorDescription ?? "Unknown error",
-      statusCode: statusCode.map(Double.init),
-      retrying: retrying ? true : nil,
-    )
-  }
-}
+#endif

package/ios/NowPlayingInfo/NowPlayingInfoCenter.swift

@@ -0,0 +1,9 @@
+import Foundation
+import MediaPlayer
+
+protocol NowPlayingInfoCenter {
+  var nowPlayingInfo: [String: Any]? { get set }
+  var playbackState: MPNowPlayingPlaybackState { get set }
+}
+
+extension MPNowPlayingInfoCenter: NowPlayingInfoCenter {}

package/ios/NowPlayingInfo/NowPlayingInfoController.swift

@@ -8,162 +8,184 @@ extension MPRemoteCommandCenter: @retroactive @unchecked Sendable {}
 
 /// Controller for managing Now Playing info.
 ///
-/// A `MPNowPlayingSession` bound to the linked AVPlayer publishes now-playing info
-/// automatically: the system derives elapsed time, playback rate, and duration from
-/// the player, so the per-second clock stays out of our code (it extrapolates the
-/// scrubber). We supply the two things automatic publishing does NOT provide:
-/// metadata (title/artist/artwork), attached to `AVPlayerItem.nowPlayingInfo` (the
-/// supported channel under automatic publishing); and the explicit `playbackState`
-/// that CarPlay / Control Center read for their play/pause button (see `setPlaybackState`).
+/// On iOS 16+, uses `MPNowPlayingSession` with `automaticallyPublishNowPlayingInfo` to let the system
+/// automatically update elapsed time, playback rate, and duration. We still manually set metadata
+/// (title, artist, artwork) which the automatic publishing doesn't handle.
+///
+/// On iOS 15.x, falls back to manual `MPNowPlayingInfoCenter` updates for all properties.
 @MainActor
 class NowPlayingInfoController {
   private let logger = Logger(subsystem: "com.audiobrowser", category: "NowPlayingInfoController")
 
+  private(set) var infoCenter: NowPlayingInfoCenter
   private var _info: [String: Any] = [:]
 
-  /// Last play/pause state pushed to the session's center, to skip redundant writes.
-  private var _playbackState: MPNowPlayingPlaybackState?
+  /// Wrapper for MPNowPlayingSession (iOS 16+) to avoid @available on stored property
+  private var _nowPlayingSession: Any?
 
-  /// The session bound to the linked AVPlayer; held so it stays alive while publishing.
-  private var nowPlayingSession: MPNowPlayingSession?
+  /// The linked AVPlayer (iOS 16+)
+  private weak var _linkedPlayer: AVPlayer?
 
-  /// The linked AVPlayer — metadata is attached to its current item.
-  private weak var linkedPlayer: AVPlayer?
+  /// Whether automatic publishing is currently active (iOS 16+ with linked player)
+  private var isAutomaticPublishingEnabled: Bool = false
 
-  /// The current remote command center - the session's while linked, else the shared one.
+  /// The current remote command center - either the session's (iOS 16+) or shared
   private(set) var remoteCommandCenter: MPRemoteCommandCenter = .shared()
 
-  required init() {}
+  /// The current Now Playing info dictionary
+  var info: [String: Any] { _info }
+
+  required init() {
+    infoCenter = MPNowPlayingInfoCenter.default()
+  }
 
-  /// Callback invoked when the remote command center changes (session created/destroyed).
+  required init(infoCenter: NowPlayingInfoCenter) {
+    self.infoCenter = infoCenter
+  }
+
+  /// Callback invoked when the remote command center changes (iOS 16+ session created/destroyed)
   var onRemoteCommandCenterChanged: ((MPRemoteCommandCenter) -> Void)?
 
-  /// Binds an AVPlayer to a new auto-publishing `MPNowPlayingSession`.
+  /// Links an AVPlayer to enable automatic Now Playing publishing on iOS 16+.
+  /// On older iOS versions, this is a no-op.
+  ///
+  /// When linked:
+  /// - System automatically updates elapsed time, playback rate, and duration
+  /// - Metadata (title, artist, artwork) is set via `AVPlayerItem.nowPlayingInfo`
+  /// - The session's `remoteCommandCenter` must be used for remote commands
   ///
-  /// - Important: This creates an `MPNowPlayingSession` with its own `remoteCommandCenter`;
-  ///   the `onRemoteCommandCenterChanged` callback is invoked with the new command center.
+  /// - Important: On iOS 16+, this creates an `MPNowPlayingSession` with its own `remoteCommandCenter`.
+  ///   The `onRemoteCommandCenterChanged` callback will be invoked with the new command center.
   func linkPlayer(_ player: AVPlayer) {
-    logger.notice("Linking AVPlayer to MPNowPlayingSession for automatic publishing")
+    if #available(iOS 16.0, *) {
+      logger.info("Linking AVPlayer to MPNowPlayingSession for automatic publishing")
 
-    linkedPlayer = player
+      _linkedPlayer = player
 
-    let session = MPNowPlayingSession(players: [player])
-    nowPlayingSession = session
-    _playbackState = nil // new center starts at .unknown; force the next write
-    remoteCommandCenter = session.remoteCommandCenter
+      let session = MPNowPlayingSession(players: [player])
+      _nowPlayingSession = session
 
-    session.automaticallyPublishesNowPlayingInfo = true
+      remoteCommandCenter = session.remoteCommandCenter
 
-    session.becomeActiveIfPossible { success in
-      self.logger.notice("MPNowPlayingSession becomeActiveIfPossible: \(success)")
-    }
+      session.automaticallyPublishesNowPlayingInfo = true
 
-    onRemoteCommandCenterChanged?(remoteCommandCenter)
-  }
+      session.becomeActiveIfPossible { success in
+        self.logger.info("MPNowPlayingSession becomeActiveIfPossible: \(success)")
+      }
 
-  /// Re-requests now-playing activation for the linked session.
-  ///
-  /// `linkPlayer` runs at player setup, before the audio session is active, and the
-  /// system can decline the election at that point. Without a later re-request the
-  /// session stays unfeatured until actual audio output elects the app through the
-  /// system's own path — which never happens when the first-ever load fails (a cold
-  /// start onto a dead stream showed no now-playing surface at all). Call whenever
-  /// the audio session (re)activates; no-op while already active.
-  func reactivateSessionIfNeeded() {
-    guard let session = nowPlayingSession, !session.isActive else { return }
-    logger.notice("MPNowPlayingSession inactive (canBecomeActive: \(session.canBecomeActive)) — re-requesting activation")
-    session.becomeActiveIfPossible { success in
-      self.logger.notice("MPNowPlayingSession re-activation: \(success)")
+      isAutomaticPublishingEnabled = true
+      onRemoteCommandCenterChanged?(remoteCommandCenter)
+    } else {
+      logger.debug("linkPlayer: iOS 16+ required for automatic publishing, using manual updates")
     }
   }
 
-  /// Unlinks the AVPlayer, tearing down the session and restoring the shared command center.
+  /// Unlinks the AVPlayer, disabling automatic publishing.
   func unlinkPlayer() {
-    logger.info("Unlinking AVPlayer from MPNowPlayingSession")
+    if #available(iOS 16.0, *) {
+      logger.info("Unlinking AVPlayer from MPNowPlayingSession")
+
+      _linkedPlayer = nil
 
-    linkedPlayer = nil
-    nowPlayingSession?.automaticallyPublishesNowPlayingInfo = false
-    nowPlayingSession = nil
-    _playbackState = nil
+      if let session = _nowPlayingSession as? MPNowPlayingSession {
+        session.automaticallyPublishesNowPlayingInfo = false
+      }
+      _nowPlayingSession = nil
+      isAutomaticPublishingEnabled = false
 
-    remoteCommandCenter = MPRemoteCommandCenter.shared()
-    onRemoteCommandCenterChanged?(remoteCommandCenter)
+      remoteCommandCenter = MPRemoteCommandCenter.shared()
+      onRemoteCommandCenterChanged?(remoteCommandCenter)
+    }
   }
 
-  /// Keys the session derives from the player itself — we never set these manually,
-  /// the system owns elapsed/duration/rate.
+  /// Keys that are automatically published by MPNowPlayingSession on iOS 16+.
+  /// When automatic publishing is enabled, we skip setting these manually.
   private static let autoPublishedKeys: Set<String> = [
     MPNowPlayingInfoPropertyElapsedPlaybackTime,
     MPMediaItemPropertyPlaybackDuration,
     MPNowPlayingInfoPropertyPlaybackRate,
   ]
 
-  /// Whether a new value matches what's already in `_info` — used to avoid
-  /// re-publishing unchanged metadata. Compares the comparable scalar types we
-  /// store (title/artist/album strings, isLiveStream); non-comparable values
-  /// (e.g. artwork) are treated as changed.
-  private func valueUnchanged(_ key: String, _ newValue: Any?) -> Bool {
-    switch (_info[key], newValue) {
-    case (nil, nil): true
-    case let (a as String, b as String): a == b
-    case let (a as Bool, b as Bool): a == b
-    case let (a as NSNumber, b as NSNumber): a == b
-    default: false
-    }
+  /// Returns true if the key is auto-published and automatic publishing is enabled
+  private func shouldSkipKey(_ key: String) -> Bool {
+    isAutomaticPublishingEnabled && Self.autoPublishedKeys.contains(key)
   }
 
-  /// Sets key-values and immediately updates Now Playing.
-  /// Playback-dynamics keys (elapsed/duration/rate) are owned by the session and skipped.
+  /// Sets key-values and immediately updates the Now Playing Info Center.
+  /// When automatic publishing is enabled (iOS 16+), playback-related keys are skipped.
   func set(keyValues: [NowPlayingInfoKeyValue]) {
-    var changed = false
-    for kv in keyValues where !Self.autoPublishedKeys.contains(kv.key) && !valueUnchanged(kv.key, kv.value) {
-      _info[kv.key] = kv.value
-      changed = true
+    for kv in keyValues {
+      if !shouldSkipKey(kv.key) {
+        _info[kv.key] = kv.value
+      }
     }
-    if changed { performUpdate() }
+    performUpdate()
   }
 
-  /// Sets a single key-value and immediately updates Now Playing.
+  /// Sets key-values without updating the Now Playing Info Center.
+  /// Useful for batching multiple updates - call update() when ready to commit.
+  /// When automatic publishing is enabled (iOS 16+), playback-related keys are skipped.
+  func setWithoutUpdate(keyValues: [NowPlayingInfoKeyValue]) {
+    for kv in keyValues {
+      if !shouldSkipKey(kv.key) {
+        _info[kv.key] = kv.value
+      }
+    }
+  }
+
+  /// Sets a single key-value and immediately updates the Now Playing Info Center.
+  /// When automatic publishing is enabled (iOS 16+), playback-related keys are skipped.
   func set(keyValue: NowPlayingInfoKeyValue) {
-    guard !Self.autoPublishedKeys.contains(keyValue.key), !valueUnchanged(keyValue.key, keyValue.value) else { return }
-    _info[keyValue.key] = keyValue.value
+    if !shouldSkipKey(keyValue.key) {
+      _info[keyValue.key] = keyValue.value
+      performUpdate()
+    }
+  }
+
+  /// Explicitly updates the Now Playing Info Center with the current info.
+  /// Use after calling setWithoutUpdate() to commit batched changes.
+  func update() {
     performUpdate()
   }
 
-  /// Attaches metadata to the current item — the supported channel under automatic publishing.
-  /// While no item exists (the media URL resolve is still in flight), publishes to the
-  /// session's center directly so the Now Playing surface isn't blank between load
-  /// intent and item creation; the item channel takes over via `prepareItem`.
+  /// Pushes the current info to the appropriate Now Playing target.
+  ///
+  /// On iOS 16+ with automatic publishing:
+  /// - Sets metadata on `AVPlayerItem.nowPlayingInfo`
+  /// - Skips elapsed time and duration (system handles these)
+  ///
+  /// On iOS 15.x or without automatic publishing:
+  /// - Sets all info on `MPNowPlayingInfoCenter.default().nowPlayingInfo`
   private func performUpdate() {
-    if let item = linkedPlayer?.currentItem {
-      item.nowPlayingInfo = _info
+    if #available(iOS 16.0, *), isAutomaticPublishingEnabled {
+      _linkedPlayer?.currentItem?.nowPlayingInfo = _info
     } else {
-      nowPlayingSession?.nowPlayingInfoCenter.nowPlayingInfo = _info
+      infoCenter.nowPlayingInfo = _info
     }
   }
 
-  /// Prepares an AVPlayerItem with stored metadata before it becomes current, so the
-  /// session has metadata from the moment the item starts playing.
-  /// Call this before `replaceCurrentItem(with:)`.
+  /// Prepares an AVPlayerItem with stored metadata before it becomes current.
+  /// Call this before `replaceCurrentItem(with:)` so the item has metadata from the start.
   func prepareItem(_ item: AVPlayerItem) {
-    item.nowPlayingInfo = _info
+    if #available(iOS 16.0, *), isAutomaticPublishingEnabled {
+      item.nowPlayingInfo = _info
+    }
   }
 
-  /// Clears all Now Playing info.
+  /// Clears all Now Playing info
   func clear() {
     _info = [:]
-    linkedPlayer?.currentItem?.nowPlayingInfo = nil
-    nowPlayingSession?.nowPlayingInfoCenter.nowPlayingInfo = nil
+
+    // With automatic publishing, the session handles clearing when the player stops
+    // Without automatic publishing, we need to clear MPNowPlayingInfoCenter manually
+    if !isAutomaticPublishingEnabled {
+      infoCenter.nowPlayingInfo = nil
+    }
   }
 
-  /// Sets the play/pause state CarPlay / Control Center show for their transport
-  /// button. Automatic publishing fills the info dict (metadata/elapsed/rate) but
-  /// not the explicit `playbackState`, so the coordinator pushes the user's
-  /// play/pause intent here on intent/state changes.
-  func setPlaybackState(playing: Bool) {
-    let state: MPNowPlayingPlaybackState = playing ? .playing : .paused
-    guard state != _playbackState else { return }
-    _playbackState = state
-    nowPlayingSession?.nowPlayingInfoCenter.playbackState = state
+  /// Sets the playback state (required for CarPlay Now Playing to show correct play/pause state)
+  func setPlaybackState(_ state: MPNowPlayingPlaybackState) {
+    logger.debug("setPlaybackState: \(state.rawValue)")
+    infoCenter.playbackState = state
   }
 }

package/ios/Observer/PlayerItemNotificationObserver.swift

@@ -12,16 +12,13 @@ import Foundation
 
   private let onDidPlayToEndTime: @MainActor () -> Void
   private let onFailedToPlayToEndTime: @MainActor (Error?) -> Void
-  private let onPlaybackStalled: @MainActor () -> Void
 
   init(
     onDidPlayToEndTime: @escaping @MainActor () -> Void,
     onFailedToPlayToEndTime: @escaping @MainActor (Error?) -> Void,
-    onPlaybackStalled: @escaping @MainActor () -> Void,
   ) {
     self.onDidPlayToEndTime = onDidPlayToEndTime
     self.onFailedToPlayToEndTime = onFailedToPlayToEndTime
-    self.onPlaybackStalled = onPlaybackStalled
   }
 
   /**
@@ -36,7 +33,7 @@ import Foundation
     isObserving = true
     notificationCenter.addObserver(
       self,
-      selector: #selector(avItemDidPlayToEndTime(_:)),
+      selector: #selector(avItemDidPlayToEndTime),
       name: NSNotification.Name.AVPlayerItemDidPlayToEndTime,
       object: avItem,
     )
@@ -46,12 +43,6 @@ import Foundation
       name: NSNotification.Name.AVPlayerItemFailedToPlayToEndTime,
       object: avItem,
     )
-    notificationCenter.addObserver(
-      self,
-      selector: #selector(avItemPlaybackStalled(_:)),
-      name: NSNotification.Name.AVPlayerItemPlaybackStalled,
-      object: avItem,
-    )
   }
 
   /**
@@ -71,49 +62,18 @@ import Foundation
       name: NSNotification.Name.AVPlayerItemFailedToPlayToEndTime,
       object: observingAVItem,
     )
-    notificationCenter.removeObserver(
-      self,
-      name: NSNotification.Name.AVPlayerItemPlaybackStalled,
-      object: observingAVItem,
-    )
     self.observingAVItem = nil
     isObserving = false
   }
 
-  @objc private nonisolated func avItemDidPlayToEndTime(_ notification: Notification) {
-    let identity = (notification.object as? AVPlayerItem).map(ObjectIdentifier.init)
-    Task { @MainActor in
-      guard self.isObserving(identity) else { return }
-      self.onDidPlayToEndTime()
-    }
+  @objc nonisolated private func avItemDidPlayToEndTime() {
+    Task { @MainActor in self.onDidPlayToEndTime() }
   }
 
-  @objc private nonisolated func avItemFailedToPlayToEndTime(_ notification: Notification) {
+  @objc nonisolated private func avItemFailedToPlayToEndTime(_ notification: Notification) {
     // Extract the error from the notification's userInfo
     // AVPlayerItemFailedToPlayToEndTimeErrorKey contains the actual error
     let error = notification.userInfo?[AVPlayerItemFailedToPlayToEndTimeErrorKey] as? Error
-    let identity = (notification.object as? AVPlayerItem).map(ObjectIdentifier.init)
-    Task { @MainActor in
-      guard self.isObserving(identity) else { return }
-      self.onFailedToPlayToEndTime(error)
-    }
-  }
-
-  // Fired when the item's buffer empties mid-playback. iOS exposes no
-  // rebuffer-vs-initial signal otherwise, and AVPlayer can stay parked in
-  // `.waitingToPlayAtSpecifiedRate` after data returns — the listener nudges it.
-  @objc private nonisolated func avItemPlaybackStalled(_ notification: Notification) {
-    let identity = (notification.object as? AVPlayerItem).map(ObjectIdentifier.init)
-    Task { @MainActor in
-      guard self.isObserving(identity) else { return }
-      self.onPlaybackStalled()
-    }
-  }
-
-  /// True when `identity` still names the observed item. Notifications are posted off the main
-  /// thread, so the main-actor hop can land after the observer switched items — without this
-  /// check the old item's late delivery (e.g. a stale failure) reaches the new item's handlers.
-  private func isObserving(_ identity: ObjectIdentifier?) -> Bool {
-    identity != nil && observingAVItem.map(ObjectIdentifier.init) == identity
+    Task { @MainActor in self.onFailedToPlayToEndTime(error) }
   }
 }

package/ios/Observer/PlayerItemPropertyObserver.swift

@@ -47,38 +47,22 @@ extension AVTimedMetadataGroup: @retroactive @unchecked Sendable {}
     observations = [
       avItem.observe(\.duration, options: [.new]) { [weak self] item, _ in
         let seconds = item.duration.seconds
-        let identity = ObjectIdentifier(item)
-        Task { @MainActor in
-          guard let self, self.isObserving(identity) else { return }
-          self.onDurationUpdate(seconds)
-        }
+        Task { @MainActor in self?.onDurationUpdate(seconds) }
       },
       avItem.observe(\.loadedTimeRanges, options: [.new]) { [weak self] item, _ in
         if let duration = item.loadedTimeRanges.first?.timeRangeValue.duration {
           let seconds = duration.seconds
-          let identity = ObjectIdentifier(item)
-          Task { @MainActor in
-            guard let self, self.isObserving(identity) else { return }
-            self.onDurationUpdate(seconds)
-          }
+          Task { @MainActor in self?.onDurationUpdate(seconds) }
         }
       },
       avItem.observe(\.isPlaybackLikelyToKeepUp, options: [.new]) { [weak self] item, _ in
         let isLikely = item.isPlaybackLikelyToKeepUp
-        let identity = ObjectIdentifier(item)
-        Task { @MainActor in
-          guard let self, self.isObserving(identity) else { return }
-          self.onPlaybackLikelyToKeepUpUpdate(isLikely)
-        }
+        Task { @MainActor in self?.onPlaybackLikelyToKeepUpUpdate(isLikely) }
       },
       avItem.observe(\.status, options: [.new]) { [weak self] item, _ in
         let status = item.status
         let error = item.error
-        let identity = ObjectIdentifier(item)
-        Task { @MainActor in
-          guard let self, self.isObserving(identity) else { return }
-          self.onStatusChange(status, error)
-        }
+        Task { @MainActor in self?.onStatusChange(status, error) }
       },
     ]
 
@@ -99,13 +83,6 @@ extension AVTimedMetadataGroup: @retroactive @unchecked Sendable {}
     observingAVItem = nil
     currentMetadataOutput = nil
   }
-
-  /// True when `identity` still names the observed item. KVO fires off the main thread, so
-  /// the main-actor hop can land after the observer switched items — without this check a
-  /// stale delivery (e.g. the old item's `.failed`) is attributed to the freshly loaded one.
-  private func isObserving(_ identity: ObjectIdentifier) -> Bool {
-    observingAVItem.map(ObjectIdentifier.init) == identity
-  }
 }
 
 extension PlayerItemPropertyObserver: AVPlayerItemMetadataOutputPushDelegate {