react-native-queue-player 1.2.0 → 2.0.1

package/ios/CarPlayCoordinator.swift

@@ -52,6 +52,7 @@ final class CarPlayCoordinator {
 
   // MARK: - Connection state
 
+  private let connectionLock = NSLock()
   /// Whether the CarPlay scene is currently connected. Written by
   /// [CarPlaySceneDelegate] at scene attach / detach — the same points that
   /// fire the `onCarConnect` / `onCarDisconnect` callbacks — and read by the
@@ -63,7 +64,6 @@ final class CarPlayCoordinator {
   /// attached/detached flag rather than a connection count (the Android side
   /// counts because its headless controllers — Auto / Wear / Assistant — can
   /// overlap).
-  private let connectionLock = NSLock()
   private var carConnectedFlag = false
 
   var isCarConnected: Bool {
@@ -72,9 +72,25 @@ final class CarPlayCoordinator {
     return carConnectedFlag
   }
 
+  /// Invoked on the main queue when a scene attaches. `TrackPlayer` uses it
+  /// to rebuild the queue mirror, which is only maintained while a car is
+  /// attached — without this a car connecting mid-session would show whatever
+  /// the mirror held when it was last connected.
+  var onCarAttached: (() -> Void)? {
+    get { connectionLock.withLock { carAttachedCallback } }
+    set { connectionLock.withLock { carAttachedCallback = newValue } }
+  }
+  /// Written by `TrackPlayer` on its player queue, read here on main.
+  private var carAttachedCallback: (() -> Void)?
+
   func setCarConnected(_ connected: Bool) {
     connectionLock.lock()
-    defer { connectionLock.unlock() }
+    let wasConnected = carConnectedFlag
     carConnectedFlag = connected
+    let attached = carAttachedCallback
+    connectionLock.unlock()
+    if connected, !wasConnected {
+      attached?()
+    }
   }
 }

package/ios/CarPlaySceneDelegate.swift

@@ -16,8 +16,8 @@ import Foundation
 /// the live `BrowseDataProvider`, `CarPlayBridge`,
 /// `PendingBrowseRequests`, and `ArtworkLoader` — all of which are
 /// also written from the JS-side `TrackPlayer` Hybrid path, so the
-/// scene delegate sees fresh data without needing a constructor
-/// injection seam.
+/// scene delegate sees fresh data without anything being injected
+/// through its initialiser.
 /// **Class is `internal` (not `public`) and uses `@objc(<bare-name>)`:**
 /// the auto-generated `<Module>-Swift.h` only emits public Swift
 /// classes; `internal` keeps this one out of the bridging header so

package/ios/Cast/AirPlayRouteState.swift

@@ -71,14 +71,15 @@ final class AirPlayRouteState {
   /// dispatching a tap to the picker's internal UIButton. Used by
   /// `CastManager.showSystemPicker()`.
   ///
-  /// Caveat: the internal button is private layout, walked via
-  /// recursive subview search rather than direct child lookup so the
-  /// picker keeps working when Apple reshapes the view hierarchy
-  /// (iOS 15 nested the button one level deeper; further reshuffles
-  /// are likely). The mitigation here is "best-effort + fail-quiet":
-  /// when no UIButton is found the call is a no-op and the consumer
-  /// can fall back to rendering its own `AVRoutePickerView` in app UI
-  /// (Apple's recommended pattern).
+  /// Workaround: `AVRoutePickerView` has no public API to present its
+  /// sheet, so this walks the view's subviews for its `UIButton` and
+  /// fires its `.touchUpInside` actions. The walk is recursive rather
+  /// than a direct child lookup because the button's depth has changed
+  /// between iOS releases. When no button is found the call is a no-op;
+  /// a consumer that needs a guaranteed sheet renders its own
+  /// `AVRoutePickerView`, which is the supported pattern.
+  /// TODO: monitor upstream for fixes — https://github.com/react-native-video/react-native-video/issues/3119
+  /// (the same subview walk, and the request for a public entry point).
   func showSystemPicker() {
     DispatchQueue.main.async {
       let picker = self.getOrCreatePicker()

package/ios/Cast/Core/CastEventBridge.swift

@@ -15,6 +15,14 @@ import NitroModules
 /// `setActive`: once a session is removed from the router and its
 /// listeners are disposed, no further events from it can fire
 /// `owner.emitRemoteState`.
+///
+/// The listener and session fields are main-thread state: the Cast SDK
+/// delivers session and listener callbacks on main, and the owner's `start`
+/// and `stop` hop there from its player queue rather than touching the fields
+/// where they are called. The deactivation snapshot is the exception — it is
+/// written from the player queue at handoff and has to be visible to a
+/// deactivation that lands on main right after, so it sits behind a lock.
+/// `seedStartMetadata` reads the owner's track list on the owner's queue.
 final class CastEventBridge {
 
   private weak var owner: TrackPlayer?
@@ -37,11 +45,21 @@ final class CastEventBridge {
   /// Receiver position at the moment the active session was cleared.
   /// The local engine can read this to resume from where the
   /// receiver was. Cleared when a new session activates.
-  private(set) var lastPositionMsOnDeactivate: Int64 = 0
+  private(set) var lastPositionMsOnDeactivate: Int64 {
+    get { snapshotLock.withLock { positionMsOnDeactivate } }
+    set { snapshotLock.withLock { positionMsOnDeactivate = newValue } }
+  }
 
   /// Receiver-side current track index at deactivation. `-1` when
   /// unknown.
-  private(set) var lastTrackIndexOnDeactivate: Int = -1
+  private(set) var lastTrackIndexOnDeactivate: Int {
+    get { snapshotLock.withLock { trackIndexOnDeactivate } }
+    set { snapshotLock.withLock { trackIndexOnDeactivate = newValue } }
+  }
+
+  private let snapshotLock = NSLock()
+  private var positionMsOnDeactivate: Int64 = 0
+  private var trackIndexOnDeactivate: Int = -1
 
   /// Last lib index emitted for the receiver's current item. Dedups
   /// repeat receiver statuses carrying the same resolved index so
@@ -54,19 +72,34 @@ final class CastEventBridge {
   }
 
   func start() {
-    if activeChangeDisposer != nil { return }
-    activeChangeDisposer = PlaybackStateRouter.shared.addActiveChangeListener {
-      [weak self] session in
-      self?.handleActiveSessionChange(to: session)
+    onMain { [self] in
+      if self.activeChangeDisposer != nil { return }
+      self.activeChangeDisposer = PlaybackStateRouter.shared.addActiveChangeListener {
+        [weak self] session in
+        self?.handleActiveSessionChange(to: session)
+      }
     }
   }
 
   func stop() {
-    activeChangeDisposer?()
-    activeChangeDisposer = nil
-    sessionListenerDisposers.forEach { $0() }
-    sessionListenerDisposers.removeAll()
-    currentActiveSession = nil
+    onMain {
+      self.activeChangeDisposer?()
+      self.activeChangeDisposer = nil
+      self.sessionListenerDisposers.forEach { $0() }
+      self.sessionListenerDisposers.removeAll()
+      self.currentActiveSession = nil
+    }
+  }
+
+  /// Runs `body` on main, in order with the SDK callbacks that own this
+  /// object's state; inline when already there so a caller on main sees its
+  /// effect before returning.
+  private func onMain(_ body: @escaping () -> Void) {
+    if Thread.isMainThread {
+      body()
+    } else {
+      DispatchQueue.main.async(execute: body)
+    }
   }
 
   /// Seed the deactivation snapshot from the local pre-handoff position +
@@ -75,13 +108,18 @@ final class CastEventBridge {
   /// lands local on the right spot. A receiver item resolved at
   /// deactivation takes precedence.
   func seedDeactivationSnapshot(trackIndex: Int, positionMs: Int64) {
-    lastTrackIndexOnDeactivate = trackIndex
-    lastPositionMsOnDeactivate = positionMs
+    snapshotLock.withLock {
+      trackIndexOnDeactivate = trackIndex
+      positionMsOnDeactivate = positionMs
+    }
   }
 
   // MARK: - Active-flow observer
 
   private func handleActiveSessionChange(to newSession: CastSessionRemotePlayer?) {
+    // The router fires listeners on the caller's thread; every caller today
+    // is on main, and the fields below are read and written on that basis.
+    dispatchPrecondition(condition: .onQueue(.main))
     let prior = currentActiveSession
     if newSession == nil, let prior = prior {
       // Capture deactivation snapshot BEFORE tearing down listeners so
@@ -152,8 +190,7 @@ final class CastEventBridge {
   // MARK: - Lockscreen metadata mirror
 
   /// Seed the start track's lockscreen metadata after a `setQueue` so the
-  /// surface doesn't wait for the first receiver status. Called on the
-  /// main thread from `TrackPlayer.setQueue`.
+  /// surface doesn't wait for the first receiver status.
   func seedStartMetadata(startIndex: Int) {
     pushMetadata(forIndex: startIndex)
   }
@@ -175,19 +212,22 @@ final class CastEventBridge {
 
   /// Resolve a lib track index to its `TrackItem` and push its metadata
   /// to the cast lockscreen controller. Out-of-range indices are
-  /// ignored (the controller keeps its prior snapshot).
+  /// ignored (the controller keeps its prior snapshot). The track list is
+  /// read on the queue that owns it, whichever thread this is called from.
   private func pushMetadata(forIndex index: Int) {
     guard let owner = owner else { return }
-    let tracks = owner.tracks
-    guard index >= 0, index < tracks.count else { return }
-    let track = tracks[index]
-    CastNowPlayingController.shared.updateTrackMetadata(
-      title: track.title,
-      artist: track.artist,
-      album: track.album,
-      durationSec: track.duration ?? 0,
-      artworkUrl: track.artworkUrl
-    )
+    owner.playerQueue.async {
+      guard index >= 0, index < owner.tracks.count else { return }
+      let track = owner.tracks[index]
+      // The controller hops to main itself.
+      CastNowPlayingController.shared.updateTrackMetadata(
+        title: track.title,
+        artist: track.artist,
+        album: track.album,
+        durationSec: track.duration ?? 0,
+        artworkUrl: track.artworkUrl
+      )
+    }
   }
 
 }

package/ios/Cast/Core/CastNowPlayingController.swift

@@ -66,19 +66,34 @@ final class CastNowPlayingController {
   /// no-ops. Called from `TrackPlayer.configure` after the engine is
   /// set up.
   func start() {
-    if activeChangeDisposer != nil { return }
-    activeChangeDisposer = PlaybackStateRouter.shared.addActiveChangeListener {
-      [weak self] session in
-      self?.handleActiveChange(to: session)
+    onMain { [self] in
+      if self.activeChangeDisposer != nil { return }
+      self.activeChangeDisposer = PlaybackStateRouter.shared.addActiveChangeListener {
+        [weak self] session in
+        self?.handleActiveChange(to: session)
+      }
+    }
+  }
+
+  /// Every field here is main-thread state — the router and session
+  /// callbacks arrive on main — so the owner's entry points, called on its
+  /// player queue, hop rather than touch the fields where they are called.
+  private func onMain(_ body: @escaping () -> Void) {
+    if Thread.isMainThread {
+      body()
+    } else {
+      DispatchQueue.main.async(execute: body)
     }
   }
 
   /// Stop observing + tear down any active mirror. Called from
   /// `TrackPlayer.internalDestroy`.
   func stop() {
-    deactivate()
-    activeChangeDisposer?()
-    activeChangeDisposer = nil
+    onMain {
+      self.deactivate()
+      self.activeChangeDisposer?()
+      self.activeChangeDisposer = nil
+    }
   }
 
   /// Push current-track metadata. Called by `TrackPlayer` when the
@@ -92,26 +107,33 @@ final class CastNowPlayingController {
     durationSec: Double,
     artworkUrl: String?
   ) {
-    currentMetadata = TrackMetadata(
-      title: title, artist: artist, album: album,
-      durationSec: durationSec, artworkUrl: artworkUrl
-    )
-    if currentSession != nil {
-      refreshNowPlayingInfo()
-      resolveArtwork()
+    onMain {
+      self.currentMetadata = TrackMetadata(
+        title: title, artist: artist, album: album,
+        durationSec: durationSec, artworkUrl: artworkUrl
+      )
+      if self.currentSession != nil {
+        self.refreshNowPlayingInfo()
+        self.resolveArtwork()
+      }
     }
   }
 
   /// Forward the player's artwork HTTP config so authenticated artwork
   /// URLs resolve during cast. Called from `TrackPlayer.configure`.
   func configureArtwork(headers: [String: String]?, userAgent: String?) {
-    artworkResolver.configHeaders = headers
-    artworkResolver.configUserAgent = userAgent
+    onMain {
+      self.artworkResolver.configHeaders = headers
+      self.artworkResolver.configUserAgent = userAgent
+    }
   }
 
   // MARK: - Active-flow observer
 
   private func handleActiveChange(to session: CastSessionRemotePlayer?) {
+    // The router fires listeners on the caller's thread; every caller today
+    // is on main, and the fields here are read and written on that basis.
+    dispatchPrecondition(condition: .onQueue(.main))
     if let session, !session.isPushSink {
       activate(with: session)
     } else {

package/ios/Cast/Core/CastSession.swift

@@ -46,8 +46,8 @@ protocol CastSessionRemotePlayer: CastSession {
   var lastState: RemotePlaybackStateKind { get }
 
   /// `true` once the receiver has reported any state other than `.idle`.
-  /// Latches on the first such report and stays set for the session's
-  /// lifetime.
+  /// Set by the first such report and stays set for the session's lifetime;
+  /// nothing clears it.
   ///
   /// State reads use this to decide whether the receiver can answer yet: a
   /// session that has just activated still holds its initial `.idle`, and the

package/ios/Cast/Core/CastTransportRouter.swift

@@ -15,27 +15,38 @@ import Foundation
 /// Mirrors Android's `internal object CastTransportRouter`.
 enum CastTransportRouter {
 
+  /// Hands a receiver command to main. The Cast SDK is main-only, while the
+  /// decision above it — whether a remote session is live — reads a
+  /// lock-guarded snapshot and is safe from any thread, so only the command
+  /// itself crosses.
+  /// Always asynchronous, never inline-when-already-on-main: mixing the two
+  /// lets a command issued later run before one issued earlier — a CarPlay tap
+  /// arriving on main would overtake a JS seek that is still enqueued.
+  private static func onMain(_ body: @escaping () -> Void) {
+    DispatchQueue.main.async(execute: body)
+  }
+
   static func routePlay() -> Bool {
     guard let remote = PlaybackStateRouter.shared.activeRemote() else { return false }
-    remote.play()
+    onMain { remote.play() }
     return true
   }
 
   static func routePause() -> Bool {
     guard let remote = PlaybackStateRouter.shared.activeRemote() else { return false }
-    remote.pause()
+    onMain { remote.pause() }
     return true
   }
 
   static func routeStop() -> Bool {
     guard let remote = PlaybackStateRouter.shared.activeRemote() else { return false }
-    remote.stop()
+    onMain { remote.stop() }
     return true
   }
 
   static func routeSeekTo(positionMs: Int64) -> Bool {
     guard let remote = PlaybackStateRouter.shared.activeRemote() else { return false }
-    remote.seekTo(positionMs: positionMs)
+    onMain { remote.seekTo(positionMs: positionMs) }
     return true
   }
 
@@ -46,31 +57,32 @@ enum CastTransportRouter {
   /// session for AirPlay/local, where the caller seeks the local engine).
   static func routeSeekBy(deltaMs: Int64) -> Bool {
     guard let remote = PlaybackStateRouter.shared.activeRemote() else { return false }
-    remote.seekBy(deltaMs: deltaMs)
+    onMain { remote.seekBy(deltaMs: deltaMs) }
     return true
   }
 
   static func routeSkipToNext() -> Bool {
     guard let remote = PlaybackStateRouter.shared.activeRemote() else { return false }
-    remote.queueNext()
+    onMain { remote.queueNext() }
     return true
   }
 
   static func routeSkipToPrevious() -> Bool {
     guard let remote = PlaybackStateRouter.shared.activeRemote() else { return false }
-    remote.queuePrev()
+    onMain { remote.queuePrev() }
     return true
   }
 
   static func routeSkipToIndex(index: Int) -> Bool {
     guard let remote = PlaybackStateRouter.shared.activeRemote() else { return false }
-    remote.skipToQueueIndex(index: index)
+    onMain { remote.skipToQueueIndex(index: index) }
     return true
   }
 
   static func routeSetVolume(value: Double) -> Bool {
     guard let remote = PlaybackStateRouter.shared.activeRemote() else { return false }
-    remote.setVolume(Float(max(0.0, min(1.0, value))))
+    let clamped = Float(max(0.0, min(1.0, value)))
+    onMain { remote.setVolume(clamped) }
     return true
   }
 

package/ios/Cast/Core/LocalMediaServer.swift

@@ -17,8 +17,8 @@ import Network
 /// Backends call `acquire(sessionId:)` for a `MediaServerHandle`; the
 /// listener starts on first acquire and stops when the last handle
 /// closes. Range / HEAD / Content-Length are handled by the responder.
-// Thread-safe singleton: all mutable state is guarded by `lock` / `listenerLock`,
-// so it is safe to capture in the listener's `@Sendable` dispatch closures.
+/// Thread-safe singleton: all mutable state is guarded by `lock`, so it is
+/// safe to capture in the listener's `@Sendable` dispatch closures.
 final class LocalMediaServer: @unchecked Sendable {
   /// Process-wide singleton — only the Chromecast / DLNA / Sonos
   /// backends acquire handles; AirPlay-only apps never touch this and
@@ -32,7 +32,6 @@ final class LocalMediaServer: @unchecked Sendable {
   private var boundPort: UInt16 = 0
   private var refCount = 0
   private let registry = MediaTokenRegistry()
-  private var addressMonitor: LocalAddressMonitor?
   /// Live accepted connections, tracked so `stop()` can cancel any
   /// in-flight transfer. Keyed by identity; each self-removes on finish.
   private var connections: [ObjectIdentifier: MediaHTTPConnection] = [:]
@@ -43,62 +42,51 @@ final class LocalMediaServer: @unchecked Sendable {
   // acquiring async task suspends instead of busy-waiting a cooperative thread.
   private var readinessWaiters: [CheckedContinuation<Void, Never>] = []
 
-  // `lifecycleListener` is read from acquire/release (which may run on
-  // any thread the consumer routes calls through) and set from caller
-  // code on app init. Reads + writes go through this dedicated lock so
-  // a concurrent set during a refcount flip doesn't race the read.
-  private let listenerLock = NSLock()
-  private var _lifecycleListener: ((Bool) -> Void)?
-
-  var lifecycleListener: ((Bool) -> Void)? {
-    get {
-      listenerLock.lock(); defer { listenerLock.unlock() }
-      return _lifecycleListener
-    }
-    set {
-      listenerLock.lock()
-      _lifecycleListener = newValue
-      listenerLock.unlock()
-    }
-  }
-
-  private func fireLifecycle(_ active: Bool) {
-    listenerLock.lock()
-    let cb = _lifecycleListener
-    listenerLock.unlock()
-    cb?(active)
-  }
-
   /// OS-assigned port. `nil` when the listener is not bound.
   var serverPortOrNil: Int? {
     lock.lock(); defer { lock.unlock() }
     return boundPort == 0 ? nil : Int(boundPort)
   }
 
-  /// LAN IPv4 address for receivers to reach. Prefers the attached
-  /// `LocalAddressMonitor`'s cached value; falls back to a synchronous
-  /// `getifaddrs` lookup so the first cast attempt after app launch
-  /// doesn't fail just because the monitor's first path-update
-  /// callback hasn't fired yet.
+  /// LAN IPv4 address for receivers to reach: the first IPv4 on an `en*`
+  /// interface, looked up with `getifaddrs` on every read; `nil` when
+  /// there is none.
   var currentLanAddress: String? {
-    if let cached = addressMonitor?.currentAddress { return cached }
-    return LocalAddressMonitor.firstWifiIPv4()
+    Self.firstWifiIPv4()
   }
 
-  func attachAddressMonitor(_ monitor: LocalAddressMonitor) {
-    addressMonitor = monitor
-  }
-
-  func addAddressChangeListener(
-    _ listener: @escaping (String?) -> Void
-  ) -> LocalAddressMonitor.Subscription? {
-    addressMonitor?.addListener(listener)
+  /// The first IPv4 address on an `en*` interface (Wi-Fi), from a
+  /// synchronous `getifaddrs` scan; `nil` when no such interface has one.
+  /// Cellular addresses can't reach a LAN receiver, so other interfaces
+  /// are ignored.
+  private static func firstWifiIPv4() -> String? {
+    var ifaddrPtr: UnsafeMutablePointer<ifaddrs>?
+    guard getifaddrs(&ifaddrPtr) == 0, let first = ifaddrPtr else { return nil }
+    defer { freeifaddrs(ifaddrPtr) }
+    var ptr: UnsafeMutablePointer<ifaddrs>? = first
+    while let current = ptr {
+      defer { ptr = current.pointee.ifa_next }
+      let name = String(cString: current.pointee.ifa_name)
+      guard name.hasPrefix("en") else { continue }
+      guard let sa = current.pointee.ifa_addr else { continue }
+      guard sa.pointee.sa_family == UInt8(AF_INET) else { continue }
+      var hostBuf = [CChar](repeating: 0, count: Int(NI_MAXHOST))
+      let result = getnameinfo(
+        sa, socklen_t(sa.pointee.sa_len),
+        &hostBuf, socklen_t(hostBuf.count),
+        nil, 0, NI_NUMERICHOST
+      )
+      if result == 0 {
+        let host = String(cString: hostBuf)
+        if !host.isEmpty && host != "0.0.0.0" { return host }
+      }
+    }
+    return nil
   }
 
   func acquire(sessionId: String) async -> MediaServerHandle {
     if takeRefCountWasFirst() {
       await startAndWait()
-      fireLifecycle(true)
     }
     return MediaServerHandle(server: self, sessionId: sessionId)
   }
@@ -122,7 +110,6 @@ final class LocalMediaServer: @unchecked Sendable {
     lock.unlock()
     if last {
       stop()
-      fireLifecycle(false)
     }
   }
 
@@ -130,10 +117,6 @@ final class LocalMediaServer: @unchecked Sendable {
     registry.register(sessionId: sessionId, fileURL: fileURL, contentType: contentType)
   }
 
-  func revoke(_ token: String) {
-    registry.revoke(token)
-  }
-
   // MARK: - Listener lifecycle
 
   /// Start the listener (if not already bound) and suspend, bounded, until it
@@ -186,7 +169,8 @@ final class LocalMediaServer: @unchecked Sendable {
     // Bind every interface (Wi-Fi LAN, etc.) on an OS-assigned port — the
     // Cast receiver fetches URLs over the LAN, so unlike a loopback proxy
     // this listener must accept en0 connections. URLs handed to receivers
-    // scope the host to the active Wi-Fi address via `LocalAddressMonitor`;
+    // go through `MediaServerHandle.register(fileURL:lanAddress:contentType:)`
+    // with the host from `currentLanAddress` (the first IPv4 on an `en*` interface);
     // tokens are 32 hex chars (high entropy), so the LAN-reachable surface
     // can't be enumerated. `allowLocalEndpointReuse` avoids bind churn when
     // a prior listener's socket is still in TIME_WAIT.
@@ -238,7 +222,12 @@ final class LocalMediaServer: @unchecked Sendable {
   }
 
   private func accept(_ conn: NWConnection) {
-    let responder = MediaHTTPConnection(connection: conn, registry: registry) { [weak self] in
+    let responder = MediaHTTPConnection(
+      connection: conn,
+      resolve: { [registry] token in
+        registry.resolve(token).map { .file($0.fileURL, contentType: $0.contentType) }
+      }
+    ) { [weak self] in
       self?.untrack(conn)
     }
     // Track BEFORE start(): the responder's finish callback (-> untrack)

package/ios/Cast/Core/LocalNetworkPermissionProbe.swift

@@ -51,15 +51,17 @@ final class LocalNetworkPermissionProbe {
 
   init() {}
 
-  /// Snapshot of the most recently resolved permission state. Returns
-  /// `.undetermined` if no probe has resolved yet, or if the cached
-  /// result has expired past the TTL.
+  /// The most recently resolved permission state, or `.undetermined` if no
+  /// probe has resolved yet.
+  ///
+  /// Deliberately not TTL-gated. The TTL governs whether
+  /// `requestPermission()` re-probes; expiring the *answer* as well would
+  /// report `.undetermined` for a user who granted access a minute ago, and any
+  /// consumer rule of the form "granted suppresses the prompt" would then
+  /// invert — re-prompting exactly the people who already said yes.
   var cachedState: CastLocalNetworkPermission {
     stateLock.lock(); defer { stateLock.unlock() }
-    if let at = _cachedAt, Date().timeIntervalSince(at) < Self.cacheTTLSeconds {
-      return _cachedState
-    }
-    return .undetermined
+    return _cachedState
   }
 
   /// Trigger the probe. Returns immediately with a `Promise` that
@@ -215,6 +217,15 @@ fileprivate final class ProbeRun {
 
   private func handleBrowserState(_ state: NWBrowser.State) {
     switch state {
+    case .waiting(let error):
+      // Denial surfaces here, not in `.failed`: refusing local-network access
+      // leaves the browser waiting with kDNSServiceErr_PolicyDenied (-65570).
+      // `.waiting` is also the ordinary "no connectivity yet" state, so only
+      // the error code decides — anything else stays unresolved and lets the
+      // timeout or a later state settle it.
+      if Self.isLocalNetworkDeniedError(error) {
+        resolve(.denied)
+      }
     case .failed(let error):
       if Self.isLocalNetworkDeniedError(error) {
         resolve(.denied)
@@ -252,14 +263,24 @@ fileprivate final class ProbeRun {
     for p in resolvedPromises { p.resolve(withResult: state) }
   }
 
-  /// Detect the LNA-denied error code. Network.framework surfaces it
-  /// as a POSIX `EACCES` wrapped in `NWError.posix(.EACCES)`. Other
-  /// failure modes (no Wi-Fi, system error) fall through to
-  /// `.undetermined`.
+  /// Detect the local-network-denied error.
+  ///
+  /// A denied browse reports `kDNSServiceErr_PolicyDenied` (-65570) as
+  /// `NWError.dns`, which is the form that actually arrives on the `.waiting`
+  /// path. `NWError.posix(.EACCES)` is kept for the listener side, which
+  /// reports the same refusal as a POSIX error. Everything else (no Wi-Fi,
+  /// system error) is not a denial and falls through.
   static func isLocalNetworkDeniedError(_ error: NWError) -> Bool {
     if case .posix(let code) = error, code == .EACCES {
       return true
     }
+    if case .dns(let code) = error, code == Self.dnsPolicyDenied {
+      return true
+    }
     return false
   }
+
+  /// `kDNSServiceErr_PolicyDenied`. Spelled out rather than imported so the
+  /// probe does not pull in dnssd for one constant.
+  private static let dnsPolicyDenied: DNSServiceErrorType = -65570
 }

package/ios/Cast/Core/MediaServerHandle.swift

@@ -26,10 +26,6 @@ final class MediaServerHandle {
     return URL(string: "http://\(lanAddress):\(port)/media/\(token)")
   }
 
-  func revoke(_ token: String) {
-    server?.revoke(token)
-  }
-
   func close() {
     lock.lock()
     if closed {

package/ios/Cast/Core/MediaTokenRegistry.swift

@@ -28,12 +28,6 @@ final class MediaTokenRegistry {
     return entries[token]
   }
 
-  func revoke(_ token: String) {
-    lock.lock()
-    entries.removeValue(forKey: token)
-    lock.unlock()
-  }
-
   func revokeAll(sessionId: String) {
     lock.lock()
     entries = entries.filter { $0.value.sessionId != sessionId }