react-native-queue-player 1.0.2 → 1.0.3

package/android/src/main/cpp/CMakeLists.txt

@@ -36,6 +36,13 @@ target_include_directories(alac PUBLIC
     ${THIRD_PARTY}/alac/codec
     ${THIRD_PARTY}/alac/addons
 )
+# Apple's vendored ALAC reference codec carries benign unused-variable noise we
+# don't patch upstream; silence just those two categories for this third-party
+# target so a consumer's release build stays quiet. Our own code keeps -Wall.
+target_compile_options(alac PRIVATE
+    -Wno-unused-const-variable
+    -Wno-unused-but-set-variable
+)
 
 # --- Curve25519 / Ed25519 (retained for libraop / AP1 only) ---
 add_library(curve25519 STATIC
@@ -70,6 +77,10 @@ add_library(pair_ap STATIC
 )
 target_compile_definitions(pair_ap PRIVATE
     CONFIG_OPENSSL=1
+    # pair.c uses OpenSSL's legacy SHA*_Final API, deprecated in OpenSSL 3.0.
+    # OPENSSL_SUPPRESS_DEPRECATED is OpenSSL's own opt-in for intentional
+    # legacy-API use; the raop + airplay2 targets already set it.
+    OPENSSL_SUPPRESS_DEPRECATED
 )
 target_include_directories(pair_ap PUBLIC
     ${PAIR_AP_DIR}

package/android/src/main/cpp/airplay_jni.cpp

@@ -67,14 +67,17 @@ struct JniSession {
 
     // -- Drain thread --
     pthread_t thread;
-    bool      drain_running;
+    // Stop flag: set on the JNI/control thread, polled in the drain thread's
+    // loop. Atomic so the stop is a data-race-free, promptly-visible read
+    // (the ring buffer has its own mutex; this only gates the loop).
+    std::atomic<bool> drain_running{false};
 
     // -- Tracking --
     std::atomic<int64_t> bytes_sent{0};    // total PCM bytes sent to RAOP
     std::atomic<int64_t> chunks_sent{0};   // total chunks sent
 
     JniSession() : raop(nullptr), write_pos(0), read_pos(0),
-                   drain_running(false), thread{} {
+                   thread{} {
         memset(ring, 0, sizeof(ring));
         pthread_mutex_init(&mutex, nullptr);
     }

package/android/src/main/java/com/margelo/nitro/queueplayer/SleepTimerCore.kt

@@ -42,6 +42,12 @@ class SleepTimerCore(
   // defer the pause forever.
   private var tailExtended = false
 
+  // True while an end-of-track timer is pending, and survives the conversion to
+  // a DURATION fade so the real track-end signal (fireAtTrackEnd) knows to fire
+  // — the poll can't hit the boundary exactly and never fires at all when the
+  // duration is unknown (live/streaming).
+  private var originEndOfTrack = false
+
   val isActive: Boolean get() = mode != Mode.INACTIVE
   val isEndOfTrack: Boolean get() = mode == Mode.END_OF_TRACK
 
@@ -49,18 +55,33 @@ class SleepTimerCore(
     mode = Mode.DURATION
     deadlineEpochMs = nowMs + (seconds * 1000).toLong()
     tailExtended = false
+    originEndOfTrack = false
   }
 
   fun armEndOfTrack() {
     mode = Mode.END_OF_TRACK
     deadlineEpochMs = null
     tailExtended = false
+    originEndOfTrack = true
   }
 
   fun clear() {
     mode = Mode.INACTIVE
     deadlineEpochMs = null
     tailExtended = false
+    originEndOfTrack = false
+  }
+
+  /**
+   * Fire the pending end-of-track timer at the current track's real end. The
+   * owning engine calls this from its Media3 auto-transition signal so the pause
+   * lands exactly at the boundary (and fires even when the duration was never
+   * known). No-op unless an end-of-track timer is pending.
+   */
+  fun fireAtTrackEnd(): Tick {
+    if (!originEndOfTrack) return Tick.IDLE
+    clear()
+    return Tick(1.0, pauseNow = true, stateChanged = true)
   }
 
   /** Whole seconds until the fixed deadline, or `null` when inactive / awaiting track end. */
@@ -78,9 +99,13 @@ class SleepTimerCore(
         val tail = trackRemaining(trackDurationSec, trackPositionSec)
         if (tail != null && tail <= tailGraceSeconds) {
           mode = Mode.DURATION
-          deadlineEpochMs = nowMs + ((tail + 1) * 1000).toLong()
+          // Deadline lands AT the track boundary (not 1s past it) so the fade
+          // completes at the end; on the local engine the real track-end signal
+          // (fireAtTrackEnd) owns the actual pause, and this deadline is the
+          // fallback the cast path rides out on the receiver's clock.
+          deadlineEpochMs = nowMs + (tail * 1000).toLong()
           tailExtended = true
-          return Tick(fadeFraction(tail + 1), pauseNow = false, stateChanged = true)
+          return Tick(fadeFraction(tail), pauseNow = false, stateChanged = true)
         }
         return Tick.IDLE
       }
@@ -103,9 +128,7 @@ class SleepTimerCore(
           return Tick(fadeFraction(tail + 1), pauseNow = false, stateChanged = true)
         }
         // Fire.
-        mode = Mode.INACTIVE
-        deadlineEpochMs = null
-        tailExtended = false
+        clear()
         return Tick(1.0, pauseNow = true, stateChanged = true)
       }
     }

package/android/src/main/java/com/margelo/nitro/queueplayer/TrackPlayer.kt

@@ -2629,6 +2629,14 @@ class TrackPlayer : HybridTrackPlayerSpec(), PlaybackEngineDelegate {
       positionSec = maxOf(0L, serviceBinder?.engine?.currentPositionMs ?: 0L) / 1000.0
     }
     val result = sleepTimerCore.tick(System.currentTimeMillis(), durationSec, positionSec)
+    applySleepTimerResult(result)
+  }
+
+  /**
+   * Apply a [SleepTimerCore.Tick] decision — fade, state emit, boundary pause.
+   * Shared by the polling tick and the real track-end signal ([fireEndOfTrackSleepTimer]).
+   */
+  private fun applySleepTimerResult(result: SleepTimerCore.Tick) {
     applySleepTimerFade(result.fadeFraction)
     if (result.stateChanged) emitSleepTimerChanged()
     if (result.pauseNow) {
@@ -2643,6 +2651,17 @@ class TrackPlayer : HybridTrackPlayerSpec(), PlaybackEngineDelegate {
     if (!sleepTimerCore.isActive) stopSleepTimerTick()
   }
 
+  /**
+   * Fire the end-of-track sleep timer at a real auto-transition boundary (the
+   * current track finished and Media3 advanced). Called from the engine's
+   * track-transition callback so the pause lands at the boundary and fires even
+   * when the track duration was never known — no-op unless end-of-track is armed.
+   */
+  private fun fireEndOfTrackSleepTimer() {
+    val result = sleepTimerCore.fireAtTrackEnd()
+    if (result.pauseNow) applySleepTimerResult(result)
+  }
+
   private fun applySleepTimerFade(fraction: Double) {
     // Fade is local-only: the receiver's volume is user/system-owned and
     // `volumeState` tracks the local level, so ramping it on the receiver would
@@ -3599,6 +3618,11 @@ class TrackPlayer : HybridTrackPlayerSpec(), PlaybackEngineDelegate {
   internal fun maybeEmitQueueEnd(playbackState: Int) {
     if (playbackState != Player.STATE_ENDED) return
     if (tracks.isEmpty()) return
+    // End-of-track sleep timer on the LAST track: STATE_ENDED fires no
+    // MEDIA_ITEM_TRANSITION, so cover the final boundary here — matching iOS,
+    // whose per-item handlePlayerItemDidPlayToEndTime fires on the last track
+    // too. Idempotent, so it can't double-fire with the poll / transition path.
+    fireEndOfTrackSleepTimer()
     queueEndListeners.forEach { it() }
     emitState(PlayerState.ENDED, StateChangeReason.QUEUE_END)
   }
@@ -3622,6 +3646,12 @@ class TrackPlayer : HybridTrackPlayerSpec(), PlaybackEngineDelegate {
     val p = player ?: return
     val translated = translateTransitionReason(reason, p)
 
+    // End-of-track sleep timer: a natural track boundary — auto-advance to the
+    // next track OR a repeat-one loop of the same track (both translate to
+    // AUTO_ADVANCE) — is the real end of the current track, so pause here.
+    // fireAtTrackEnd is idempotent, so a deduped crossfade echo can't double-fire.
+    if (translated == TrackChangeReason.AUTO_ADVANCE) fireEndOfTrackSleepTimer()
+
     // Natural track change → reset error dedup so a new item's
     // identical-coded error fires. Without this, a TIMEOUT on
     // track 2 (after a TIMEOUT on track 1) would be silently

package/android/src/test/java/com/margelo/nitro/queueplayer/SleepTimerCoreTest.kt

@@ -111,6 +111,8 @@ class SleepTimerCoreTest {
     assertTrue(converted.stateChanged)
     assertFalse(t.isEndOfTrack)
     assertTrue(t.isActive)
+    // Deadline lands AT the boundary (tail=50s), not 1s past it.
+    assertEquals(2000L + 50_000L, t.deadlineEpochMs)
   }
 
   @Test
@@ -122,4 +124,43 @@ class SleepTimerCoreTest {
     assertNull(t.deadlineEpochMs)
     assertNull(t.remainingSeconds(0))
   }
+
+  @Test
+  fun `end-of-track fires a pause at the track-end signal`() {
+    val t = SleepTimerCore()
+    t.armEndOfTrack()
+    // Fires at the real track-end signal, before any tail conversion and even
+    // when the duration was never known (never ticked).
+    val fired = t.fireAtTrackEnd()
+    assertTrue(fired.pauseNow)
+    assertTrue(fired.stateChanged)
+    assertFalse(t.isActive)
+  }
+
+  @Test
+  fun `end-of-track signal fires after tail conversion`() {
+    val t = SleepTimerCore()
+    t.armEndOfTrack()
+    t.tick(1000, trackDurationSec = 200.0, trackPositionSec = 150.0) // converts to fade
+    val fired = t.fireAtTrackEnd()
+    assertTrue(fired.pauseNow)
+    assertFalse(t.isActive)
+  }
+
+  @Test
+  fun `fireAtTrackEnd is idempotent`() {
+    val t = SleepTimerCore()
+    t.armEndOfTrack()
+    t.fireAtTrackEnd()
+    assertFalse(t.fireAtTrackEnd().pauseNow)
+  }
+
+  @Test
+  fun `fireAtTrackEnd ignores a duration timer`() {
+    val t = SleepTimerCore()
+    t.armDuration(seconds = 60.0, nowMs = 0)
+    val fired = t.fireAtTrackEnd()
+    assertFalse(fired.pauseNow)
+    assertTrue(t.isActive)
+  }
 }

package/ios/AudioCategoryMapping.swift

@@ -4,8 +4,7 @@ import AVFoundation
 /// to the AVAudioSession `Mode` + `CategoryOptions` used during
 /// `AudioSession.activate()`.
 ///
-/// Pure function; no instance state. Mirrors `PlaybackErrorMapping`
-/// + `InterruptionEventMapping`.
+/// Pure function; no instance state. Mirrors `PlaybackErrorMapping`.
 ///
 /// `audioContentType == .speech` triggers two effects:
 /// 1. AVAudioSession mode flips to `.spokenAudio` (per Apple HIG —

package/ios/SleepTimerCore.swift

@@ -36,6 +36,11 @@ struct SleepTimerCore {
   // Guards the tail rule to a single track so a stalled/looping position can't
   // defer the pause forever.
   private var tailExtended = false
+  // True while an end-of-track timer is pending, and survives the conversion to
+  // a `.duration` fade so the real track-end signal (`fireAtTrackEnd`) knows to
+  // fire — the poll can't hit the boundary exactly and never fires at all when
+  // the duration is unknown (live/streaming).
+  private var originEndOfTrack = false
 
   let fadeSeconds: Double
   let tailGraceSeconds: Double
@@ -52,18 +57,31 @@ struct SleepTimerCore {
     mode = .duration
     deadlineEpochMs = nowMs + Int64(seconds * 1000)
     tailExtended = false
+    originEndOfTrack = false
   }
 
   mutating func armEndOfTrack() {
     mode = .endOfTrack
     deadlineEpochMs = nil
     tailExtended = false
+    originEndOfTrack = true
   }
 
   mutating func clear() {
     mode = .inactive
     deadlineEpochMs = nil
     tailExtended = false
+    originEndOfTrack = false
+  }
+
+  /// Fire the pending end-of-track timer at the current track's real end. The
+  /// owning player calls this from its track-end signal so the pause lands
+  /// exactly at the boundary (and fires even when the track duration was never
+  /// known). No-op unless an end-of-track timer is pending.
+  mutating func fireAtTrackEnd() -> Tick {
+    guard originEndOfTrack else { return .idle }
+    clear()
+    return Tick(fadeFraction: 1.0, pauseNow: true, stateChanged: true)
   }
 
   /// Whole seconds until the fixed deadline, or `nil` when inactive / awaiting
@@ -83,9 +101,13 @@ struct SleepTimerCore {
       // then let the duration branch ride it out + fire.
       if let tail = trackRemaining(trackDurationSec, trackPositionSec), tail <= tailGraceSeconds {
         mode = .duration
-        deadlineEpochMs = nowMs + Int64((tail + 1) * 1000)
+        // Deadline lands AT the track boundary (not 1s past it) so the fade
+        // completes at the end; on local playback the real track-end signal
+        // (fireAtTrackEnd) owns the actual pause, and this deadline is the
+        // fallback the cast path rides out on the receiver's clock.
+        deadlineEpochMs = nowMs + Int64(tail * 1000)
         tailExtended = true
-        return Tick(fadeFraction: fadeFraction(tail + 1), pauseNow: false, stateChanged: true)
+        return Tick(fadeFraction: fadeFraction(tail), pauseNow: false, stateChanged: true)
       }
       return .idle
 
@@ -106,9 +128,7 @@ struct SleepTimerCore {
         return Tick(fadeFraction: fadeFraction(tail + 1), pauseNow: false, stateChanged: true)
       }
       // Fire.
-      mode = .inactive
-      deadlineEpochMs = nil
-      tailExtended = false
+      clear()
       return Tick(fadeFraction: 1.0, pauseNow: true, stateChanged: true)
     }
   }

package/ios/Tests/FFTProcessorTests.swift

@@ -39,9 +39,15 @@ final class FFTProcessorTests: XCTestCase {
 
   func testDoesNotEmitUntilFftSizeSamplesAccumulate() throws {
     var calls = 0
+    // Fulfilled by the emit itself so the wait tracks the actual main-queue
+    // callback rather than a fixed delay that can lose the race under load.
+    let emitted = expectation(description: "emit landed")
     let proc = try FFTProcessor(
       fftSize: 512, intervalMs: 1, includeSamples: false,
-    ) { _, _, _ in calls += 1 }
+    ) { _, _, _ in
+      calls += 1
+      emitted.fulfill()
+    }
     let half = [Float](repeating: 0, count: 256)
     half.withUnsafeBufferPointer { p in
       proc.ingest(samples: p.baseAddress!, frameCount: 256, sampleRate: 44100)
@@ -51,10 +57,7 @@ final class FFTProcessorTests: XCTestCase {
     rest.withUnsafeBufferPointer { p in
       proc.ingest(samples: p.baseAddress!, frameCount: 256, sampleRate: 44100)
     }
-    // The callback hops to main; spin the run loop to give it a chance.
-    let exp = expectation(description: "emit landed")
-    DispatchQueue.main.asyncAfter(deadline: .now() + 0.1) { exp.fulfill() }
-    wait(for: [exp], timeout: 1.0)
+    wait(for: [emitted], timeout: 1.0)
     XCTAssertEqual(calls, 1)
   }
 

package/ios/Tests/SleepTimerCoreTests.swift

@@ -85,6 +85,8 @@ final class SleepTimerCoreTests: XCTestCase {
     XCTAssertTrue(converted.stateChanged)
     XCTAssertFalse(t.isEndOfTrack)
     XCTAssertTrue(t.isActive)
+    // Deadline lands AT the boundary (tail=50s), not 1s past it.
+    XCTAssertEqual(t.deadlineEpochMs, 2000 + 50_000)
   }
 
   func testClearResetsToInactive() {
@@ -95,4 +97,41 @@ final class SleepTimerCoreTests: XCTestCase {
     XCTAssertNil(t.deadlineEpochMs)
     XCTAssertNil(t.remainingSeconds(nowMs: 0))
   }
+
+  func testEndOfTrackFiresPauseAtTrackEndSignal() {
+    var t = SleepTimerCore()
+    t.armEndOfTrack()
+    // Fires at the real track-end signal, before any tail conversion and even
+    // when the duration was never known (never ticked).
+    let fired = t.fireAtTrackEnd()
+    XCTAssertTrue(fired.pauseNow)
+    XCTAssertTrue(fired.stateChanged)
+    XCTAssertFalse(t.isActive)
+  }
+
+  func testEndOfTrackSignalFiresAfterTailConversion() {
+    var t = SleepTimerCore()
+    t.armEndOfTrack()
+    _ = t.tick(nowMs: 1000, trackDurationSec: 200, trackPositionSec: 150) // converts to fade
+    // The end-of-track origin survives the conversion, so the boundary signal
+    // still owns the pause.
+    let fired = t.fireAtTrackEnd()
+    XCTAssertTrue(fired.pauseNow)
+    XCTAssertFalse(t.isActive)
+  }
+
+  func testFireAtTrackEndIsIdempotent() {
+    var t = SleepTimerCore()
+    t.armEndOfTrack()
+    _ = t.fireAtTrackEnd()
+    XCTAssertFalse(t.fireAtTrackEnd().pauseNow)
+  }
+
+  func testFireAtTrackEndIgnoresDurationTimer() {
+    var t = SleepTimerCore()
+    t.armDuration(seconds: 60, nowMs: 0)
+    let fired = t.fireAtTrackEnd()
+    XCTAssertFalse(fired.pauseNow)
+    XCTAssertTrue(t.isActive)
+  }
 }

package/ios/TrackPlayer.swift

@@ -424,6 +424,9 @@ class TrackPlayer: HybridTrackPlayerSpec {
   // first track needs the same initial-buffer leniency.
   private var currentItemObserver: NSKeyValueObservation?
   private var currentItemStatusObserver: NSKeyValueObservation?
+  // Duration can resolve a beat AFTER `.status` reaches `.readyToPlay`; observe
+  // it so the lock-screen duration lands even in that race.
+  private var currentItemDurationObserver: NSKeyValueObservation?
   private var gaplessFlipArmed: Bool = true
 
   /// Set to true by the `AVPlayerItemDidPlayToEndTime` notification
@@ -666,24 +669,11 @@ class TrackPlayer: HybridTrackPlayerSpec {
         break
       }
 
-      // Surface the interruption kind as a typed non-fatal
-      // `PlaybackError` so JS consumers can branch on the resume
-      // hint without inspecting a boolean. Wire literals + messages
-      // come from `InterruptionEventMapping` (single source of
-      // truth for the three nativeDomain strings).
-      let domain = InterruptionEventMapping.nativeDomain(for: kind)
-      let message = InterruptionEventMapping.message(for: kind)
-      let err = PlaybackError(
-        code: .unknown,
-        message: message,
-        fatal: false,
-        nativeCode: 0,
-        nativeDomain: domain,
-        nativeMessage: message,
-        queueItemId: "",
-        url: ""
-      )
-      self.errorListeners.forEach { $0(err) }
+      // An interruption is a normal lifecycle signal (call / Siri / a route
+      // handoff), NOT a playback error — surfacing it on the `onError` stream
+      // makes consumers render an error banner for a routine pause. The pause
+      // is already reported via the `.paused` state stamped with
+      // `reason = .interruption`, which is the correct, non-error signal.
     }
 
     self.audioSession.onRouteChange = { [weak self] kind in
@@ -992,6 +982,8 @@ class TrackPlayer: HybridTrackPlayerSpec {
   private func attachStatusObserverIfArmed() {
     currentItemStatusObserver?.invalidate()
     currentItemStatusObserver = nil
+    currentItemDurationObserver?.invalidate()
+    currentItemDurationObserver = nil
     tearDownBufferObservers()
     guard let item = self.player?.currentItem else {
       // No current item (empty queue / torn down) — settle to empty.
@@ -1034,6 +1026,14 @@ class TrackPlayer: HybridTrackPlayerSpec {
       }
     }
     self.dispatchItemStatus(item)
+    currentItemDurationObserver = item.observe(
+      \.duration, options: [.new]
+    ) { [weak self] _, _ in
+      guard let self else { return }
+      DispatchQueue.main.async {
+        self.nowPlayingInfo.refreshPositionAndRate()
+      }
+    }
     installBufferObservers(on: item)
   }
 
@@ -1086,6 +1086,11 @@ class TrackPlayer: HybridTrackPlayerSpec {
       // idempotent on items that already carry a tap, so a double-
       // fire is harmless.
       AudioTapProvider.shared.refreshActiveItemMixes()
+      // Duration is only reliably readable once the item is `.readyToPlay`.
+      // Re-publish now-playing so the lock-screen scrubber gets a duration on
+      // first load + auto-advance (not just after a manual skip, which is the
+      // only path that otherwise forces a state change that re-publishes it).
+      self.nowPlayingInfo.refreshPositionAndRate()
     case .failed:
       // Pause synchronously BEFORE surfacing the typed error. Without
       // this, AVQueuePlayer treats `.failed` as end-of-item and chain-
@@ -1191,6 +1196,8 @@ class TrackPlayer: HybridTrackPlayerSpec {
     currentItemObserver = nil
     currentItemStatusObserver?.invalidate()
     currentItemStatusObserver = nil
+    currentItemDurationObserver?.invalidate()
+    currentItemDurationObserver = nil
     tearDownBufferObservers()
   }
 
@@ -2591,6 +2598,13 @@ class TrackPlayer: HybridTrackPlayerSpec {
       nowMs: Self.nowEpochMs(),
       trackDurationSec: durationSec,
       trackPositionSec: positionSec)
+    applySleepTimerResult(result)
+  }
+
+  /// Apply a `SleepTimerCore.Tick` decision to the engine — fade, state emit,
+  /// and the boundary pause. Shared by the polling tick and the real track-end
+  /// signal (`handlePlayerItemDidPlayToEndTime`).
+  private func applySleepTimerResult(_ result: SleepTimerCore.Tick) {
     applySleepTimerFade(result.fadeFraction)
     if result.stateChanged { emitSleepTimerChanged() }
     if result.pauseNow {
@@ -3766,6 +3780,12 @@ class TrackPlayer: HybridTrackPlayerSpec {
   @objc private func handlePlayerItemDidPlayToEndTime(_ notification: Notification) {
     DispatchQueue.main.async { [weak self] in
       guard let self else { return }
+      // End-of-track sleep timer: pause at the current track's real end —
+      // before the repeat-track rewind or the auto-advance — so the pause
+      // lands exactly at the boundary and fires even when the track duration
+      // was never known. Under repeat-one this pauses at the first natural end.
+      let sleepFired = self.sleepTimerCore.fireAtTrackEnd()
+      if sleepFired.pauseNow { self.applySleepTimerResult(sleepFired) }
       // Branch on repeat-track FIRST, separately from the
       // currentItem === item check. The notification dispatches
       // async to main but AVQueuePlayer
@@ -3796,8 +3816,10 @@ class TrackPlayer: HybridTrackPlayerSpec {
              player.currentItem === item {
             item.seek(to: .zero, completionHandler: nil)
             // Replay through the engine so the user's playback speed is
-            // restored (a raw AVPlayer.play() resets rate to 1.0).
-            self.engine?.play()
+            // restored (a raw AVPlayer.play() resets rate to 1.0) — unless the
+            // end-of-track sleep timer just fired, in which case we pause at
+            // this natural end instead of looping.
+            if !sleepFired.pauseNow { self.engine?.play() }
           }
         }
         // If the rewind window was lost (player chain-advanced

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-queue-player",
-  "version": "1.0.2",
+  "version": "1.0.3",
   "description": "Nitro Modules audio playback library for React Native — gapless, EQ, crossfade, automotive, voice, casting",
   "main": "./lib/module/index.js",
   "types": "./lib/typescript/index.d.ts",

package/ios/InterruptionEventMapping.swift

@@ -1,51 +0,0 @@
-import Foundation
-
-/// Maps `AudioSession.InterruptionKind` to the lib-standardized
-/// `nativeDomain` string + a stable human-readable message used by
-/// `TrackPlayer.wireAudioSession()` when firing the corresponding
-/// non-fatal `PlaybackError` through `errorListeners`.
-///
-/// Pure function; no instance state. Mirrors `PlaybackErrorMapping`.
-///
-/// Three `nativeDomain` strings — all share the
-/// `AUDIO_SESSION_INTERRUPTION_` prefix so JS consumers can branch
-/// on `nativeDomain.startsWith(...)` and treat any
-/// audio-session-interruption variant as a single category when they
-/// don't care about the resume-hint sub-state. `.endedShouldNotResume`
-/// maps to the bare `..._ENDED` (no `_SHOULD_NOT_RESUME` suffix) so
-/// consumers that ignore the resume-hint variant default to the
-/// "stop" semantics.
-enum InterruptionEventMapping {
-
-  /// Shared prefix for the three interruption `nativeDomain` strings.
-  static let nativeDomainPrefix = "AUDIO_SESSION_INTERRUPTION_"
-
-  /// `nativeDomain` for the supplied interruption kind.
-  static func nativeDomain(for kind: AudioSession.InterruptionKind) -> String {
-    switch kind {
-    case .began:
-      return nativeDomainPrefix + "BEGAN"
-    case .endedShouldResume:
-      return nativeDomainPrefix + "ENDED_SHOULD_RESUME"
-    case .endedShouldNotResume:
-      return nativeDomainPrefix + "ENDED"
-    }
-  }
-
-  /// Human-readable message for the supplied interruption kind.
-  /// Same string is fired as both `message` and `nativeMessage` on
-  /// the resulting `PlaybackError` — there's no lib-mapped vs native
-  /// distinction at this layer (session-scope event, not track-
-  /// scope error).
-  static func message(for kind: AudioSession.InterruptionKind) -> String {
-    switch kind {
-    case .began:
-      return "Audio session interruption began"
-    case .endedShouldResume:
-      return "Audio session interruption ended; system suggests resume"
-    case .endedShouldNotResume:
-      return "Audio session interruption ended"
-    }
-  }
-
-}

package/ios/Tests/InterruptionEventMappingTests.swift

@@ -1,91 +0,0 @@
-import XCTest
-@testable import QueuePlayer
-
-/// `InterruptionEventMapping` is a pure-function namespace mapping
-/// `AudioSession.InterruptionKind` to the lib-standardized
-/// `nativeDomain` string + a stable human-readable message + the
-/// non-fatal `PlaybackError` that `TrackPlayer.wireAudioSession()`
-/// fires through `errorListeners`.
-final class InterruptionEventMappingTests: XCTestCase {
-
-  // MARK: - nativeDomain
-
-  func testNativeDomainBeganIsBeganLiteral() {
-    XCTAssertEqual(
-      InterruptionEventMapping.nativeDomain(for: .began),
-      "AUDIO_SESSION_INTERRUPTION_BEGAN"
-    )
-  }
-
-  func testNativeDomainEndedShouldResumeIsResumeHintLiteral() {
-    XCTAssertEqual(
-      InterruptionEventMapping.nativeDomain(for: .endedShouldResume),
-      "AUDIO_SESSION_INTERRUPTION_ENDED_SHOULD_RESUME"
-    )
-  }
-
-  func testNativeDomainEndedShouldNotResumeIsBareEndedLiteral() {
-    XCTAssertEqual(
-      InterruptionEventMapping.nativeDomain(for: .endedShouldNotResume),
-      "AUDIO_SESSION_INTERRUPTION_ENDED"
-    )
-  }
-
-  func testAllInterruptionDomainsShareTheBranchablePrefix() {
-    let kinds: [AudioSession.InterruptionKind] = [
-      .began, .endedShouldResume, .endedShouldNotResume,
-    ]
-    for kind in kinds {
-      let domain = InterruptionEventMapping.nativeDomain(for: kind)
-      XCTAssertTrue(
-        domain.hasPrefix(InterruptionEventMapping.nativeDomainPrefix),
-        "domain for \(kind) must use the consumer-branchable prefix; got \(domain)"
-      )
-    }
-  }
-
-  func testTheThreeDomainsAreExactlyTheSetOfWireLiterals() {
-    let domains: Set<String> = [
-      InterruptionEventMapping.nativeDomain(for: .began),
-      InterruptionEventMapping.nativeDomain(for: .endedShouldResume),
-      InterruptionEventMapping.nativeDomain(for: .endedShouldNotResume),
-    ]
-    XCTAssertEqual(domains, [
-      "AUDIO_SESSION_INTERRUPTION_BEGAN",
-      "AUDIO_SESSION_INTERRUPTION_ENDED_SHOULD_RESUME",
-      "AUDIO_SESSION_INTERRUPTION_ENDED",
-    ], "wire-protocol literals must not drift; rename = breaking change for JS consumers")
-  }
-
-  // MARK: - message
-
-  func testMessagesAreNonEmpty() {
-    let kinds: [AudioSession.InterruptionKind] = [
-      .began, .endedShouldResume, .endedShouldNotResume,
-    ]
-    for kind in kinds {
-      XCTAssertFalse(
-        InterruptionEventMapping.message(for: kind).isEmpty,
-        "message for \(kind) must be non-empty"
-      )
-    }
-  }
-
-  func testMessagesAreDistinctPerKind() {
-    let began = InterruptionEventMapping.message(for: .began)
-    let resume = InterruptionEventMapping.message(for: .endedShouldResume)
-    let ended = InterruptionEventMapping.message(for: .endedShouldNotResume)
-    XCTAssertNotEqual(began, resume)
-    XCTAssertNotEqual(began, ended)
-    XCTAssertNotEqual(resume, ended)
-  }
-
-  // PlaybackError construction lives inline at the call site in
-  // `TrackPlayer.wireAudioSession()` — Swift cxx-interop excludes
-  // internal helpers that return C++-bridged types like
-  // `PlaybackError` from the `@testable import` swiftmodule export,
-  // so the construction can't be invoked from an XCTest target. The
-  // wire literals + messages are pinned by the tests above; full-
-  // path coverage lives in the Maestro `interruption-handling`
-  // suite.
-}