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

package/src/web/TrackPlayer/PlayingStateFactory.ts

@@ -5,7 +5,7 @@ import type { PlaybackState, PlayingState } from '../../features'
  * player's intent (`playWhenReady`) and its current {@link PlaybackState}.
  *
  * A faithful port of the native derivations (android `PlayingStateFactory.derive`,
- * ios `PlayingStateManager.update`) so all platforms agree on what "playing" and
+ * ios `Player.playingState`) so all platforms agree on what "playing" and
  * "buffering" mean for the now-playing UI.
  */
 export function derivePlayingState(

package/ios/Bridge.h

@@ -1,8 +0,0 @@
-//
-//  Bridge.h
-//  audio-browser
-//
-//  Created by puckey on 10/12/2025
-//
-
-#pragma once

package/ios/Browser/MediaResolveComposer.swift

@@ -1,114 +0,0 @@
-import Foundation
-
-/// Pure, Nitro-free composition logic for the media `resolve` layer.
-///
-/// The two pieces that need testing in isolation from the Nitro bridge are:
-///  1. the variant unwrap — `resolve(track)` returns a `RequestConfig` either
-///     synchronously (`.first`) or via a `Promise` (`.second`); both arms must
-///     yield the same `RequestConfig`; and
-///  2. the merge — the resolved config is layered over the base with
-///     override-wins per field (and per-key dict merge for headers/query).
-///
-/// Production (`BrowserManager+URLResolution.swift`) builds the Nitro
-/// `RequestConfig` values and calls into `MediaResolveComposer.merge` /
-/// `.unwrap`; the SPM test target exercises the same functions against the
-/// stub `RequestConfigLike` value type. Keeping the logic here (rather than in
-/// the Nitro-only extension) is what makes it reachable from tests.
-enum MediaResolveComposer {
-  /// A minimal field set mirroring `RequestConfig`, used so the merge logic can
-  /// be expressed once and shared between the Nitro types and the test stub.
-  struct RequestConfigLike: Equatable {
-    var method: String?
-    var path: String?
-    var baseUrl: String?
-    var headers: [String: String]?
-    var query: [String: String]?
-    var body: String?
-    var contentType: String?
-    var userAgent: String?
-
-    init(
-      method: String? = nil,
-      path: String? = nil,
-      baseUrl: String? = nil,
-      headers: [String: String]? = nil,
-      query: [String: String]? = nil,
-      body: String? = nil,
-      contentType: String? = nil,
-      userAgent: String? = nil,
-    ) {
-      self.method = method
-      self.path = path
-      self.baseUrl = baseUrl
-      self.headers = headers
-      self.query = query
-      self.body = body
-      self.contentType = contentType
-      self.userAgent = userAgent
-    }
-  }
-
-  /// The unwrapped result of a `resolve(track)` variant.
-  enum ResolveVariant<Config> {
-    /// `.first` — a synchronous config.
-    case sync(Config)
-    /// `.second` — a config delivered via an async closure (a Promise in prod).
-    case async(() async throws -> Config)
-  }
-
-  /// Unwraps a sync/async config into a concrete config, awaiting the async arm
-  /// if needed. (Production no longer uses a Nitro variant — `resolve`/`resolveSync`
-  /// are separate fields — but this stays as a pure, testable composition helper.)
-  static func unwrap<Config>(_ variant: ResolveVariant<Config>) async throws -> Config {
-    switch variant {
-    case let .sync(config):
-      config
-    case let .async(makeConfig):
-      try await makeConfig()
-    }
-  }
-
-  /// Run-both resolve composition: the async-resolved config first, then the
-  /// sync-resolved merged over it (sync winning) via `combine`. `nil` when neither
-  /// produced a config. Generic so it is shared verbatim by production (Nitro
-  /// `RequestConfig` + `mergeRequestConfig`) and tests (`RequestConfigLike` +
-  /// `merge`) — one implementation, exercised on both sides.
-  static func composeResolved<C>(
-    async asyncResolved: C?,
-    sync syncResolved: C?,
-    combine: (C, C) -> C,
-  ) -> C? {
-    switch (asyncResolved, syncResolved) {
-    case (nil, nil): nil
-    case let (value?, nil): value
-    case let (nil, value?): value
-    case let (a?, s?): combine(a, s)
-    }
-  }
-
-  /// Override-wins per-field merge. Headers and query merge per-key (override
-  /// key wins). Matches `BrowserManager.mergeRequestConfig`.
-  static func merge(base: RequestConfigLike, override: RequestConfigLike) -> RequestConfigLike {
-    RequestConfigLike(
-      method: override.method ?? base.method,
-      path: override.path ?? base.path,
-      baseUrl: override.baseUrl ?? base.baseUrl,
-      headers: mergeDicts(base.headers, override.headers),
-      query: mergeDicts(base.query, override.query),
-      body: override.body ?? base.body,
-      contentType: override.contentType ?? base.contentType,
-      userAgent: override.userAgent ?? base.userAgent,
-    )
-  }
-
-  /// Per-key dict merge with override-wins; nil-safe (returns the non-nil side,
-  /// or nil when both are nil). Matches `BrowserManager.mergeDicts`.
-  static func mergeDicts(_ base: [String: String]?, _ override: [String: String]?) -> [String: String]? {
-    switch (base, override) {
-    case (nil, nil): nil
-    case let (base?, nil): base
-    case let (nil, override?): override
-    case let (base?, override?): base.merging(override) { _, new in new }
-    }
-  }
-}

package/ios/NowPlayingInfo/MediaItemProperty.swift

@@ -1,78 +0,0 @@
-import Foundation
-@preconcurrency import MediaPlayer
-
-/**
- Enum representing MPMediaItemProperties.
- Docs for each property is taken from [Apple docs](https://developer.apple.com/documentation/mediaplayer/mpmediaitem/general_media_item_property_keys)
- */
-enum MediaItemProperty: NowPlayingInfoKeyValue {
-  /**
-   The performing artist(s) for a media item—which may vary from the primary artist for the album that a media item belongs to.
-
-   For example, if the album artist is “Joseph Fable,” the artist for one of the songs in the album may be “Joseph Fable featuring Thomas Smithson”. Value is an NSString object.
-   */
-  case artist(String?)
-
-  /**
-   The title (or name) of the media item.
-
-   This property is unrelated to the MPMediaItemPropertyAlbumTitle property. Value is an NSString object.
-   */
-  case title(String?)
-
-  /**
-   The title of an album.
-
-   This property contains the album title, such as “Live On Mars”, as opposed to the title of an individual song on the album, such as “Crater Dance (radio edit)” (which you specify using the MPMediaItemPropertyTitle property). Value is an NSString object.
-   */
-  case albumTitle(String?)
-
-  /**
-   The playback duration of the media item.
-   Value is an NSNumber object representing a duration in seconds as an TimeInterval.
-   */
-  case duration(TimeInterval?)
-
-  /**
-   The artwork image for the media item.
-   */
-  case artwork(MPMediaItemArtwork?)
-
-  var key: String {
-    switch self {
-    case .artist:
-      MPMediaItemPropertyArtist
-
-    case .title:
-      MPMediaItemPropertyTitle
-
-    case .albumTitle:
-      MPMediaItemPropertyAlbumTitle
-
-    case .duration:
-      MPMediaItemPropertyPlaybackDuration
-
-    case .artwork:
-      MPMediaItemPropertyArtwork
-    }
-  }
-
-  var value: Any? {
-    switch self {
-    case let .artist(artist):
-      artist
-
-    case let .title(title):
-      title
-
-    case let .albumTitle(title):
-      title
-
-    case let .duration(duration):
-      duration != nil ? NSNumber(floatLiteral: duration!) : nil
-
-    case let .artwork(artwork):
-      artwork
-    }
-  }
-}

package/ios/NowPlayingInfo/NowPlayingInfoKeyValue.swift

@@ -1,6 +0,0 @@
-import Foundation
-
-protocol NowPlayingInfoKeyValue {
-  var key: String { get }
-  var value: Any? { get }
-}

package/ios/NowPlayingInfo/NowPlayingInfoProperty.swift

@@ -1,220 +0,0 @@
-import Foundation
-@preconcurrency import MediaPlayer
-
-/**
- Enum representing MPNowPlayingInfoProperties.
- Docs for each property is taken from [Apple docs](https://developer.apple.com/documentation/mediaplayer/mpnowplayinginfocenter/additional_metadata_properties).
- */
-enum NowPlayingInfoProperty: NowPlayingInfoKeyValue {
-  /**
-   The identifier of the collection the now playing item belongs to.
-   The identifier can be an album, artist, playlist, etc.
-   */
-  case collectionIdentifier(String?)
-
-  /**
-   The available language option groups for the now playing item.
-   Value is an array of MPNowPlayingInfoLanguageOptionGroup items. Only one language option in a given group can be played at a time.
-   */
-  case availableLanguageOptions([MPNowPlayingInfoLanguageOptionGroup]?)
-
-  /**
-   The URL pointing to the now playing item's underlying asset.
-   This constant is used by the system UI when video thumbnails or audio waveform visualizations are applicable.
-   */
-  case assetUrl(URL?)
-
-  /**
-   The total number of chapters in the now-playing item.
-   Value is an NSNumber object configured as an NSUInteger.
-   */
-  case chapterCount(UInt64?)
-
-  /**
-   The number corresponding to the chapter currently being played.
-   Value is an NSNumber object configured as an NSUInteger. Chapter numbering uses zero-based indexing. If you want the first chapter in the now-playing item to be displayed as “Chapter 1,” for example, set the chapter number to 0.
-   */
-  case chapterNumber(UInt64?)
-
-  /**
-   The currently active language options for the now playing item.
-   Value is an array of MPNowPlayingInfoLanguageOption items.
-   */
-  case currentLanguageOptions([MPNowPlayingInfoLanguageOption]?)
-
-  /**
-   The default playback rate for the now playing item.
-   Value is an NSNumber object configured as a double. Set this property if your app is playing a media item at a playback rate other than 1.0 as its default rate.
-   */
-  case defaultPlaybackRate(Double?)
-
-  /**
-   The elapsed time of the now playing item, in seconds.
-   Value is an NSNumber object configured as a double. Elapsed time is automatically calculated, by the system, from the previously provided elapsed time and the playback rate. Do not update this property frequently—it is not necessary
-   */
-  case elapsedPlaybackTime(Double?)
-
-  /**
-   The opaque identifier that uniquely identifies the now playing item, even through app relaunches.
-   This is only used to reference the item to the now playing app and can be in any format.
-   */
-  case externalContentIdentifier(Any?)
-
-  /**
-   The opaque identifier that uniquely identifies the profile the now playing item is played from, even through app relaunches.
-   This is only used to reference the profile to the now playing app and can be in any format.
-   */
-  case externalUserProfileIdentifier(Any?)
-
-  /**
-   Denotes whether the now playing item is a live stream.
-   Value is an NSNumber object configured as a boolean. A value of 1.0 indicates the now playing item is a live stream.
-   */
-  case isLiveStream(Bool?)
-
-  /**
-   The media type of the now playing item.
-   Value is an NSNumber object configured as a MPNowPlayingInfoMediaType.
-   */
-  case mediaType(MPNowPlayingInfoMediaType?)
-
-  /**
-   The current progress of the now playing item.
-   Value is an NSNumber object configured as a float. A value of 0.0 indicates the item has not been watched while a value of 1.0 indicates the item has been fully watched. This is a high-level indicator. Use MPNowPlayingInfoPropertyElapsedPlaybackTime for fine-detailed information on how much of the item has been watched.
-   */
-  case playbackProgress(Float?)
-
-  /**
-   The total number of items in the app’s playback queue.
-   Value is an NSNumber object configured as an NSUInteger.
-   */
-  case playbackQueueCount(UInt64?)
-
-  /**
-   The index of the now-playing item in the app’s playback queue.
-   Value is an NSNumber object configured as an NSUInteger. The playback queue uses zero-based indexing. If you want the first item in the queue to be displayed as “item 1 of 10,” for example, set the item’s index to 0.
-   */
-  case playbackQueueIndex(UInt64?)
-
-  /**
-   The playback rate of the now-playing item, with a value of 1.0 indicating the normal playback rate.
-   Value is an NSNumber object configured as a double. The default value is 1.0. A playback rate value of 2.0 means twice the normal playback rate; a piece of media played at this rate would take half as long to play to completion. A value of 0.5 means half the normal playback rate; a piece of media played at this rate would take twice as long to play to completion.
-   */
-  case playbackRate(Double?)
-
-  /**
-   The service provider associated with the now-playing item.
-   Value is a unique NSString that identifies the service provider for the now-playing item. If the now-playing item belongs to a channel or subscription service, this key can be used to coordinate various types of now-playing content from the service provider.
-   */
-  case serviceIdentifier(String?)
-
-  var key: String {
-    switch self {
-    case .collectionIdentifier:
-      MPNowPlayingInfoCollectionIdentifier
-
-    case .availableLanguageOptions:
-      MPNowPlayingInfoPropertyAvailableLanguageOptions
-
-    case .assetUrl:
-      MPNowPlayingInfoPropertyAssetURL
-
-    case .chapterCount:
-      MPNowPlayingInfoPropertyChapterCount
-
-    case .chapterNumber:
-      MPNowPlayingInfoPropertyChapterNumber
-
-    case .currentLanguageOptions:
-      MPNowPlayingInfoPropertyCurrentLanguageOptions
-
-    case .defaultPlaybackRate:
-      MPNowPlayingInfoPropertyDefaultPlaybackRate
-
-    case .elapsedPlaybackTime:
-      MPNowPlayingInfoPropertyElapsedPlaybackTime
-
-    case .externalContentIdentifier:
-      MPNowPlayingInfoPropertyExternalContentIdentifier
-
-    case .externalUserProfileIdentifier:
-      MPNowPlayingInfoPropertyExternalUserProfileIdentifier
-
-    case .isLiveStream:
-      MPNowPlayingInfoPropertyIsLiveStream
-
-    case .mediaType:
-      MPNowPlayingInfoPropertyMediaType
-
-    case .playbackProgress:
-      MPNowPlayingInfoPropertyPlaybackProgress
-
-    case .playbackQueueCount:
-      MPNowPlayingInfoPropertyPlaybackQueueCount
-
-    case .playbackQueueIndex:
-      MPNowPlayingInfoPropertyPlaybackQueueIndex
-
-    case .playbackRate:
-      MPNowPlayingInfoPropertyPlaybackRate
-
-    case .serviceIdentifier:
-      MPNowPlayingInfoPropertyServiceIdentifier
-    }
-  }
-
-  var value: Any? {
-    switch self {
-    case let .collectionIdentifier(identifier):
-      identifier
-
-    case let .availableLanguageOptions(options):
-      options
-
-    case let .assetUrl(url):
-      url
-
-    case let .chapterCount(count):
-      count != nil ? NSNumber(value: count!) : nil
-
-    case let .chapterNumber(number):
-      number != nil ? NSNumber(value: number!) : nil
-
-    case let .currentLanguageOptions(options):
-      options
-
-    case let .defaultPlaybackRate(rate):
-      rate != nil ? NSNumber(floatLiteral: rate!) : nil
-
-    case let .elapsedPlaybackTime(time):
-      time != nil ? NSNumber(floatLiteral: time!) : nil
-
-    case let .externalContentIdentifier(id):
-      id
-
-    case let .externalUserProfileIdentifier(id):
-      id
-
-    case let .isLiveStream(status):
-      status
-
-    case let .mediaType(type):
-      type != nil ? NSNumber(value: type!.rawValue) : nil
-
-    case let .playbackProgress(progress):
-      progress != nil ? NSNumber(value: progress!) : nil
-
-    case let .playbackQueueCount(count):
-      count != nil ? NSNumber(value: count!) : nil
-
-    case let .playbackQueueIndex(index):
-      index != nil ? NSNumber(value: index!) : nil
-
-    case let .playbackRate(rate):
-      rate != nil ? NSNumber(floatLiteral: rate!) : nil
-
-    case let .serviceIdentifier(id):
-      id != nil ? NSString(string: id!) : nil
-    }
-  }
-}

package/ios/Observer/PlayerItemNotificationObserver.swift

@@ -1,119 +0,0 @@
-import AVFoundation
-import Foundation
-
-/**
- Observes player item notifications and invokes callbacks passed at initialization.
- */
-@MainActor class PlayerItemNotificationObserver {
-  private let notificationCenter: NotificationCenter = .default
-
-  private(set) weak var observingAVItem: AVPlayerItem?
-  private(set) var isObserving: Bool = false
-
-  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
-  }
-
-  /**
-   Will start observing notifications from an AVPlayerItem.
-
-   - parameter avItem: The AVPlayerItem to observe.
-   - important: Cannot observe more than one item at a time.
-   */
-  func startObserving(item avItem: AVPlayerItem) {
-    stopObservingCurrentItem()
-    observingAVItem = avItem
-    isObserving = true
-    notificationCenter.addObserver(
-      self,
-      selector: #selector(avItemDidPlayToEndTime(_:)),
-      name: NSNotification.Name.AVPlayerItemDidPlayToEndTime,
-      object: avItem,
-    )
-    notificationCenter.addObserver(
-      self,
-      selector: #selector(avItemFailedToPlayToEndTime(_:)),
-      name: NSNotification.Name.AVPlayerItemFailedToPlayToEndTime,
-      object: avItem,
-    )
-    notificationCenter.addObserver(
-      self,
-      selector: #selector(avItemPlaybackStalled(_:)),
-      name: NSNotification.Name.AVPlayerItemPlaybackStalled,
-      object: avItem,
-    )
-  }
-
-  /**
-   Stop receiving notifications for the current AVPlayerItem.
-   */
-  func stopObservingCurrentItem() {
-    guard let observingAVItem, isObserving else {
-      return
-    }
-    notificationCenter.removeObserver(
-      self,
-      name: NSNotification.Name.AVPlayerItemDidPlayToEndTime,
-      object: observingAVItem,
-    )
-    notificationCenter.removeObserver(
-      self,
-      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 private nonisolated 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
-  }
-}

package/ios/Observer/PlayerItemPropertyObserver.swift

@@ -1,133 +0,0 @@
-@preconcurrency import AVFoundation
-import Foundation
-
-// AVTimedMetadataGroup is not Sendable, but we only use it on the main thread
-// via AVPlayerItemMetadataOutputPushDelegate (queue: .main)
-extension AVTimedMetadataGroup: @retroactive @unchecked Sendable {}
-
-/**
- Observes player item property changes and invokes callbacks passed at initialization.
- Uses modern block-based KVO for type-safe observation with automatic cleanup.
- */
-@MainActor final class PlayerItemPropertyObserver: NSObject {
-  private var observations: [NSKeyValueObservation] = []
-  private var currentMetadataOutput: AVPlayerItemMetadataOutput?
-
-  private(set) weak var observingAVItem: AVPlayerItem?
-
-  private let onDurationUpdate: @MainActor (Double) -> Void
-  private let onPlaybackLikelyToKeepUpUpdate: @MainActor (Bool) -> Void
-  private let onStatusChange: @MainActor (AVPlayerItem.Status, Error?) -> Void
-  // Note: AVTimedMetadataGroup is not Sendable, but this callback is always invoked
-  // on the main thread via AVPlayerItemMetadataOutputPushDelegate (queue: .main)
-  private let onTimedMetadataReceived: @MainActor ([AVTimedMetadataGroup]) -> Void
-
-  init(
-    onDurationUpdate: @escaping @MainActor (Double) -> Void,
-    onPlaybackLikelyToKeepUpUpdate: @escaping @MainActor (Bool) -> Void,
-    onStatusChange: @escaping @MainActor (AVPlayerItem.Status, Error?) -> Void,
-    onTimedMetadataReceived: @escaping @MainActor ([AVTimedMetadataGroup]) -> Void,
-  ) {
-    self.onDurationUpdate = onDurationUpdate
-    self.onPlaybackLikelyToKeepUpUpdate = onPlaybackLikelyToKeepUpUpdate
-    self.onStatusChange = onStatusChange
-    self.onTimedMetadataReceived = onTimedMetadataReceived
-  }
-
-  /**
-   Start observing an AVPlayerItem. Will remove self as observer from old item, if any.
-
-   - parameter avItem: The AVPlayerItem to observe.
-   */
-  func startObserving(item avItem: AVPlayerItem) {
-    stopObservingCurrentItem()
-
-    observingAVItem = avItem
-
-    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)
-        }
-      },
-      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)
-          }
-        }
-      },
-      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)
-        }
-      },
-      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)
-        }
-      },
-    ]
-
-    // Create and add a new metadata output to the AVPlayerItem
-    let metadataOutput = AVPlayerItemMetadataOutput()
-    metadataOutput.setDelegate(self, queue: .main)
-    avItem.add(metadataOutput)
-    currentMetadataOutput = metadataOutput
-  }
-
-  func stopObservingCurrentItem() {
-    observations.removeAll()
-
-    if let observingAVItem {
-      observingAVItem.removeAllMetadataOutputs()
-    }
-
-    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 {
-  nonisolated func metadataOutput(
-    _ output: AVPlayerItemMetadataOutput,
-    didOutputTimedMetadataGroups groups: [AVTimedMetadataGroup],
-    from _: AVPlayerItemTrack?,
-  ) {
-    // Delegate is called on main thread (queue: .main), so we can assume isolation
-    MainActor.assumeIsolated {
-      if output == currentMetadataOutput {
-        onTimedMetadataReceived(groups)
-      }
-    }
-  }
-}
-
-extension AVPlayerItem {
-  @MainActor
-  func removeAllMetadataOutputs() {
-    for output in outputs.filter({ $0 is AVPlayerItemMetadataOutput }) {
-      remove(output)
-    }
-  }
-}