react-native-queue-player 1.0.0 → 1.0.3

package/android/build.gradle

@@ -71,6 +71,11 @@ android {
     targetSdkVersion getExtOrDefault("targetSdkVersion")
     testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
 
+    // Shipped in the AAR and applied to the consumer's R8 run so a consuming
+    // app's release build needs no manual rules for this library's transitive
+    // dependencies (e.g. Ktor's java.lang.management reference on Android).
+    consumerProguardFiles "consumer-rules.pro"
+
     externalNativeBuild {
       cmake {
         cppFlags "-frtti -fexceptions -Wall -fstack-protector-all"

package/android/consumer-rules.pro

@@ -0,0 +1,14 @@
+# React Native Queue Player — consumer R8 / ProGuard rules.
+#
+# Packaged into the published AAR via `consumerProguardFiles` and applied
+# automatically to a consuming app's R8 run, so consumers need no manual rules
+# for this library's transitive dependencies.
+
+# The embedded Ktor CIO HTTP server (the Android AirPlay 2 receiver) ships
+# io.ktor.util.debug.IntellijIdeaDebugDetector, which references
+# java.lang.management.ManagementFactory and RuntimeMXBean to detect an attached
+# IntelliJ debugger. Those JMX classes are JVM-only and absent on Android, so a
+# consumer's R8 release build (full mode treats missing classes as errors) fails
+# on the missing references. The detector is debug tooling that never executes
+# at runtime on Android; ignore the missing classes rather than fail the build.
+-dontwarn java.lang.management.**

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/AudioPipelineRenderersFactory.kt

@@ -23,12 +23,14 @@ import androidx.media3.exoplayer.audio.DefaultAudioSink
  * interleave their `flush` + buffer state. The CrossfadeEngine builds two
  * factories (one per leg); each receives its own chain.
  *
- * Float-output is opted in at construction via [setEnableAudioFloatOutput]:
- * Media3's [DefaultRenderersFactory] defaults that flag to `false`, which would
- * propagate as `enableFloatOutput = false` into [buildAudioSink] and produce an
- * Int16 PCM sink. [ReplayGainAudioProcessor.isActive] and
- * [SignalsmithStretchAudioProcessor.isActive] gate on `ENCODING_PCM_FLOAT`, so
- * without the explicit opt-in they would silently run as pass-throughs.
+ * Float output is deliberately NOT enabled. With Media3 float output, a hi-res
+ * (24-bit+) source produces a float sink, and [DefaultAudioSink.configure] then
+ * DROPS the entire custom [AudioProcessorChain] — its float branch omits the
+ * chain because the built-in Sonic outputs 16-bit — silently disabling playback
+ * speed, pitch-correction, ReplayGain, and the visualizer on hi-res content.
+ * Keeping the sink at 16-bit (Media3 downconverts hi-res) keeps the chain in the
+ * pipeline for every source; [ReplayGainAudioProcessor] and
+ * [SignalsmithStretchAudioProcessor] both process 16-bit PCM directly.
  */
 @UnstableApi
 internal class AudioPipelineRenderersFactory(
@@ -36,10 +38,6 @@ internal class AudioPipelineRenderersFactory(
   private val audioProcessorChain: AudioProcessorChain,
 ) : DefaultRenderersFactory(context) {
 
-  init {
-    setEnableAudioFloatOutput(true)
-  }
-
   override fun buildAudioSink(
     context: Context,
     enableFloatOutput: Boolean,

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

@@ -5,23 +5,22 @@ import androidx.media3.common.audio.AudioProcessor
 import androidx.media3.common.audio.BaseAudioProcessor
 import androidx.media3.common.util.UnstableApi
 import java.nio.ByteBuffer
+import kotlin.math.roundToInt
 
 /**
  * Standalone Media3 [AudioProcessor] that applies a per-track linear
- * gain to a Float32 PCM stream. No knowledge of the engine, the EQ
- * stage, or the visualizer pipeline — purely "given a Float32 buffer,
- * multiply by [linearGain]". The owning engine pushes a new gain via
- * [setLinearGain] from its `Player.Listener.onMetadata` callback;
- * `onMediaItemTransition` resets to unity until the next metadata
- * arrival.
+ * gain to a PCM stream. No knowledge of the engine, the EQ stage, or the
+ * visualizer pipeline — purely "given a PCM buffer, multiply by
+ * [linearGain]". The owning engine pushes a new gain via [setLinearGain]
+ * from its `Player.Listener` callbacks; `onMediaItemTransition` resets to
+ * unity until the next track's tags arrive.
  *
- * Float32-only by design. [AudioPipelineRenderersFactory] opts the
- * factory into `setEnableAudioFloatOutput(true)` at construction so
- * Media3 propagates `enableFloatOutput = true` into `buildAudioSink`,
- * and the resulting `DefaultAudioSink` produces `ENCODING_PCM_FLOAT`.
- * Sources decoded to Int16 PCM transit through this processor
- * untouched via [isActive] returning `false`, matching the documented
- * non-Float32 no-op limitation in NOTES.md §25.
+ * Handles both 16-bit and float PCM. The sink runs at 16-bit (see
+ * [AudioPipelineRenderersFactory] — float output would drop the whole
+ * chain on hi-res sources), so a 16-bit block is scaled in float precision
+ * and narrowed back with a round + full-scale clamp; a float block is
+ * scaled in place. The gain is already clip-capped against the track peak
+ * (`ReplayGainGain`), so the clamp only guards sentinel/missing-peak tags.
  */
 @UnstableApi
 internal class ReplayGainAudioProcessor : BaseAudioProcessor() {
@@ -37,11 +36,11 @@ internal class ReplayGainAudioProcessor : BaseAudioProcessor() {
   private var linearGain: Float = 1.0f
 
   /**
-   * `true` when [onConfigure] saw `ENCODING_PCM_FLOAT`. Volatile for
-   * the same render-thread / main-thread split as [linearGain].
+   * Input PCM encoding captured at [onConfigure]. Volatile for the same
+   * render-thread / main-thread split as [linearGain].
    */
   @Volatile
-  private var inputIsFloat: Boolean = false
+  private var encoding: Int = C.ENCODING_INVALID
 
   /**
    * Push a new linear gain. `1.0f` disables the processor's per-sample
@@ -52,7 +51,7 @@ internal class ReplayGainAudioProcessor : BaseAudioProcessor() {
   }
 
   override fun onConfigure(input: AudioProcessor.AudioFormat): AudioProcessor.AudioFormat {
-    inputIsFloat = (input.encoding == C.ENCODING_PCM_FLOAT)
+    encoding = input.encoding
     // Pass-through: this stage doesn't change rate, channel count, or
     // encoding. Returning [AudioProcessor.AudioFormat.NOT_SET] would
     // tell Media3 the processor consumes the stream and drops the
@@ -61,23 +60,36 @@ internal class ReplayGainAudioProcessor : BaseAudioProcessor() {
   }
 
   override fun isActive(): Boolean =
-    super.isActive() && linearGain != 1.0f && inputIsFloat
+    super.isActive() && linearGain != 1.0f &&
+      (encoding == C.ENCODING_PCM_FLOAT || encoding == C.ENCODING_PCM_16BIT)
 
   override fun queueInput(input: ByteBuffer) {
     val gain = linearGain
     val byteCount = input.remaining()
     if (byteCount == 0) return
     val out = replaceOutputBuffer(byteCount)
-    val inF = input.asFloatBuffer()
-    val outF = out.asFloatBuffer()
-    while (inF.hasRemaining()) {
-      outF.put(inF.get() * gain)
+    if (encoding == C.ENCODING_PCM_FLOAT) {
+      val inF = input.asFloatBuffer()
+      val outF = out.asFloatBuffer()
+      while (inF.hasRemaining()) {
+        outF.put(inF.get() * gain)
+      }
+    } else {
+      // 16-bit: scale in float precision, narrow back with round + clamp.
+      // The gain is peak-capped upstream, so the clamp only guards
+      // sentinel/missing-peak tags against wraparound.
+      val inS = input.asShortBuffer()
+      val outS = out.asShortBuffer()
+      while (inS.hasRemaining()) {
+        val scaled = inS.get() * gain
+        outS.put(scaled.roundToInt().coerceIn(-32768, 32767).toShort())
+      }
     }
     input.position(input.limit())
     // Advance the byte-level position so [getOutput] hands back a
-    // buffer with the produced bytes between position and limit. The
-    // float-view writes mutate the underlying bytes but don't move
-    // the parent ByteBuffer's position.
+    // buffer with the produced bytes between position and limit — the
+    // typed-view writes mutate the underlying bytes but don't move the
+    // parent ByteBuffer's position.
     out.position(byteCount)
     out.flip()
   }

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

@@ -56,11 +56,12 @@ internal class SignalsmithStretchAudioProcessor : BaseAudioProcessor() {
   private var floatIn: ByteBuffer? = null
   private var floatOut: ByteBuffer? = null
 
-  // Input (media) vs output (playout) byte tallies since the last flush, for
-  // the chain's getMediaDuration position mapping. Accumulated only while
-  // stretching (the pass-through span never delegates to this processor).
-  private var inputBytes: Long = 0L
-  private var outputBytes: Long = 0L
+  // True once a stretched block has been produced, so the engine's tail
+  // latency awaits a drain. [onQueueEndOfStream] drains it exactly once and
+  // clears this — the native `outputLatency()` reports the fixed algorithmic
+  // latency (not the live buffer fill), so re-draining re-emits the same tail
+  // frames (an audible stutter) and never ends the stream.
+  private var pendingDrain = false
 
   // Fractional frame remainder so per-block outFrames average to inFrames/speed.
   private var frameCarry: Double = 0.0
@@ -73,13 +74,16 @@ internal class SignalsmithStretchAudioProcessor : BaseAudioProcessor() {
   fun isStretching(): Boolean = isActive && speed != 1f
 
   /**
-   * Map a playout duration back to media duration, mirroring Sonic's model:
-   * `playout * inputBytes / outputBytes`. Returns the playout unchanged until
-   * the first stretched block has been produced.
+   * Map a playout duration back to media duration. For a pure time-stretch,
+   * `s` seconds of media play per playout second at speed `s`, so media =
+   * playout * speed — computed from the live speed rather than a cumulative
+   * input/output byte ratio, which mis-maps while the engine's latency is
+   * drained (the drained tail inflates output-vs-input) and freezes the
+   * position clock on a speed change.
    */
   fun getMediaDuration(playoutDuration: Long): Long =
-    if (outputBytes == 0L) playoutDuration
-    else Util.scaleLargeTimestamp(playoutDuration, inputBytes, outputBytes)
+    if (speed == 1f) playoutDuration
+    else Util.scaleLargeTimestamp(playoutDuration, (speed * 1_000_000f).toLong(), 1_000_000L)
 
   override fun onConfigure(inputAudioFormat: AudioProcessor.AudioFormat): AudioProcessor.AudioFormat {
     encoding = inputAudioFormat.encoding
@@ -87,8 +91,11 @@ internal class SignalsmithStretchAudioProcessor : BaseAudioProcessor() {
     sampleRateHz = inputAudioFormat.sampleRate
     bytesPerFrame = channelCount * if (encoding == C.ENCODING_PCM_FLOAT) 4 else 2
     // A reconfigure invalidates any engine built for the previous format;
-    // the next stretching queueInput lazily rebuilds it.
+    // the next stretching queueInput lazily rebuilds it. Clear the drain flag
+    // so the invariant holds locally, independent of the flush that Media3
+    // issues after a (re)configure.
     releaseNative()
+    pendingDrain = false
     // Pass-through format — the stretch changes duration, not rate/channels/
     // encoding. Returning NOT_SET would drop the sink.
     return inputAudioFormat
@@ -148,13 +155,17 @@ internal class SignalsmithStretchAudioProcessor : BaseAudioProcessor() {
     }
 
     input.position(input.limit())
-    inputBytes += inFrames.toLong() * bytesPerFrame
-    outputBytes += outFrames.toLong() * bytesPerFrame
+    pendingDrain = true
   }
 
   override fun onQueueEndOfStream() {
     val stretch = nativeStretch ?: return
-    if (speed == 1f) return // not stretching — nothing buffered to drain
+    // Drain the engine's tail latency exactly once per stretched span. Media3
+    // can call this repeatedly around a reconfigure; `outputLatency()` reports
+    // the fixed algorithmic latency, so re-draining re-emits the same tail
+    // frames (stutter) and the stream never ends, stalling a speed change.
+    if (!pendingDrain || speed == 1f) return
+    pendingDrain = false
     val latency = stretch.outputLatency()
     if (latency <= 0) return
     if (encoding == C.ENCODING_PCM_FLOAT) {
@@ -176,14 +187,12 @@ internal class SignalsmithStretchAudioProcessor : BaseAudioProcessor() {
       out.position(latency * bytesPerFrame)
       out.flip()
     }
-    outputBytes += latency.toLong() * bytesPerFrame
   }
 
   override fun onFlush(streamMetadata: AudioProcessor.StreamMetadata) {
     nativeStretch?.reset()
     frameCarry = 0.0
-    inputBytes = 0L
-    outputBytes = 0L
+    pendingDrain = false
   }
 
   override fun onReset() {
@@ -191,8 +200,7 @@ internal class SignalsmithStretchAudioProcessor : BaseAudioProcessor() {
     floatIn = null
     floatOut = null
     frameCarry = 0.0
-    inputBytes = 0L
-    outputBytes = 0L
+    pendingDrain = false
   }
 
   private fun ensureNative(): SignalsmithStretchNative {

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/AudioPipelineRenderersFactoryTest.kt

@@ -3,8 +3,8 @@ package com.margelo.nitro.queueplayer
 import androidx.media3.common.util.UnstableApi
 import androidx.media3.exoplayer.DefaultRenderersFactory
 import androidx.test.core.app.ApplicationProvider
+import org.junit.Assert.assertFalse
 import org.junit.Assert.assertNotNull
-import org.junit.Assert.assertTrue
 import org.junit.Test
 import org.junit.runner.RunWith
 import org.robolectric.RobolectricTestRunner
@@ -13,8 +13,8 @@ import java.lang.reflect.Field
 
 /**
  * Unit coverage for [AudioPipelineRenderersFactory] construction — it wraps a
- * caller-supplied [androidx.media3.common.audio.AudioProcessorChain] and opts
- * the produced sink into float output. The engines drive end-to-end exercise of
+ * caller-supplied [androidx.media3.common.audio.AudioProcessorChain] and leaves
+ * the produced sink at 16-bit (float output off). The engines drive end-to-end exercise of
  * `buildAudioSink` via `ExoPlayer.Builder.build()` in
  * [GaplessEngineLifecycleTest] / [CrossfadeEngineLifecycleTest]; `buildAudioSink`
  * itself is `protected` on [DefaultRenderersFactory] and cannot be called
@@ -36,21 +36,22 @@ class AudioPipelineRenderersFactoryTest {
   }
 
   @Test
-  fun `factory enables audio float output so the float processors see Float32 PCM`() {
-    // [DefaultRenderersFactory.enableAudioFloatOutput] defaults to false;
-    // without an explicit opt-in Media3 propagates `enableFloatOutput = false`
-    // into [buildAudioSink], which makes the sink emit Int16 PCM and silently
-    // disables the float-gated processors (ReplayGain + the music stretcher,
-    // whose isActive gate on ENCODING_PCM_FLOAT). The factory's init block flips
-    // the flag to true; pin that by reading the private field via reflection —
-    // no public accessor exists, but the field name is stable across Media3 1.x.
+  fun `factory leaves audio float output off so the chain survives on hi-res sources`() {
+    // Float output would make a hi-res (24-bit+) source produce a float sink,
+    // and DefaultAudioSink.configure()'s float branch DROPS the custom
+    // AudioProcessorChain — silently disabling playback speed, pitch-correction,
+    // ReplayGain, and the visualizer on hi-res content. Keeping the sink at
+    // 16-bit (Media3 downconverts hi-res) keeps the chain in the pipeline for
+    // every source. Pin that the factory leaves float output off (the
+    // DefaultRenderersFactory default) via reflection — no public accessor
+    // exists, but the field name is stable across Media3 1.x.
     val factory =
       AudioPipelineRenderersFactory(context, PitchAwareAudioProcessorChain(emptyArray()))
     val field: Field =
       DefaultRenderersFactory::class.java.getDeclaredField("enableFloatOutput")
     field.isAccessible = true
-    assertTrue(
-      "AudioPipelineRenderersFactory must enable float output",
+    assertFalse(
+      "AudioPipelineRenderersFactory must NOT enable float output (it drops the chain on hi-res)",
       field.getBoolean(factory),
     )
   }

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

@@ -14,10 +14,11 @@ import java.nio.ByteBuffer
 import java.nio.ByteOrder
 
 /**
- * Unit coverage for [ReplayGainAudioProcessor] — the per-sample
- * Float32 gain stage Media3 wires into the AudioSink chain. Exercises
- * the [AudioProcessor] contract: configure, isActive gating, in-place
- * multiply, encoding gate.
+ * Unit coverage for [ReplayGainAudioProcessor] — the per-sample gain
+ * stage Media3 wires into the AudioSink chain. Exercises the
+ * [AudioProcessor] contract: configure, isActive gating, in-place multiply
+ * on both 16-bit and float PCM, the 16-bit full-scale clamp, and the
+ * encoding gate.
  */
 @RunWith(RobolectricTestRunner::class)
 @Config(sdk = [34])
@@ -43,10 +44,18 @@ class ReplayGainAudioProcessorTest {
   }
 
   @Test
-  fun `isActive is false on a non-Float32 input regardless of gain`() {
+  fun `isActive is true with non-unity gain on a 16-bit input`() {
     val proc = ReplayGainAudioProcessor()
     proc.configure(int16Format(48000, 2))
     proc.setLinearGain(0.5f)
+    assertTrue(proc.isActive)
+  }
+
+  @Test
+  fun `isActive is false on an unsupported encoding`() {
+    val proc = ReplayGainAudioProcessor()
+    proc.configure(AudioProcessor.AudioFormat(48000, 2, C.ENCODING_PCM_24BIT))
+    proc.setLinearGain(0.5f)
     assertFalse(proc.isActive)
   }
 
@@ -82,6 +91,39 @@ class ReplayGainAudioProcessorTest {
     assertEquals(0.6f, output[2], 1e-6f)
   }
 
+  @Test
+  fun `queueInput scales 16-bit samples by the linear gain`() {
+    val proc = ReplayGainAudioProcessor()
+    proc.configure(int16Format(48000, 1))
+    proc.setLinearGain(0.5f)
+
+    val input = shortBuffer(shortArrayOf(10000, -8000, 4, 0, -10000))
+    proc.queueInput(input)
+
+    val output = readShorts(proc.output, 5)
+    assertEquals(5000, output[0].toInt())
+    assertEquals(-4000, output[1].toInt())
+    assertEquals(2, output[2].toInt())
+    assertEquals(0, output[3].toInt())
+    assertEquals(-5000, output[4].toInt())
+  }
+
+  @Test
+  fun `queueInput clamps a 16-bit boost that exceeds full scale`() {
+    val proc = ReplayGainAudioProcessor()
+    proc.configure(int16Format(44100, 1))
+    proc.setLinearGain(2.0f)
+
+    // 20000*2 = 40000 > 32767 and -20000*2 = -40000 < -32768 both clamp.
+    val input = shortBuffer(shortArrayOf(20000, -20000, 1000))
+    proc.queueInput(input)
+
+    val output = readShorts(proc.output, 3)
+    assertEquals(32767, output[0].toInt())
+    assertEquals(-32768, output[1].toInt())
+    assertEquals(2000, output[2].toInt())
+  }
+
   @Test
   fun `queueInput consumes the input buffer`() {
     val proc = ReplayGainAudioProcessor()
@@ -137,5 +179,22 @@ class ReplayGainAudioProcessorTest {
     return out
   }
 
+  private fun shortBuffer(values: ShortArray): ByteBuffer {
+    val buffer = ByteBuffer
+      .allocateDirect(values.size * Short.SIZE_BYTES)
+      .order(ByteOrder.nativeOrder())
+    val asShort = buffer.asShortBuffer()
+    for (v in values) asShort.put(v)
+    buffer.position(0).limit(values.size * Short.SIZE_BYTES)
+    return buffer
+  }
+
+  private fun readShorts(buffer: ByteBuffer, count: Int): ShortArray {
+    val out = ShortArray(count)
+    val asShort = buffer.asShortBuffer()
+    for (i in 0 until count) out[i] = asShort.get()
+    return out
+  }
+
   // endregion
 }

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.0",
+  "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",
@@ -39,7 +39,11 @@
     "nitrogen": "nitrogen && bash scripts/strip-nitrogen-unused-let.sh",
     "typecheck": "tsc",
     "test": "jest",
-    "test:coverage": "jest --coverage"
+    "test:coverage": "jest --coverage",
+    "release:patch": "node scripts/release.mjs patch",
+    "release:minor": "node scripts/release.mjs minor",
+    "release:major": "node scripts/release.mjs major",
+    "publish:npm": "npm publish --access public"
   },
   "keywords": [
     "react-native",

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.
-}