react-native-audio-browser 0.1.1 → 0.2.0-next.10

package/android/src/test/java/com/audiobrowser/http/RequestConfigBuilderTest.kt

@@ -1,5 +1,7 @@
 package com.audiobrowser.http
 
+import com.audiobrowser.TestFixtures.mediaConfig
+import com.audiobrowser.TestFixtures.transformableConfig
 import com.margelo.nitro.audiobrowser.HttpMethod
 import com.margelo.nitro.audiobrowser.RequestConfig
 import kotlinx.coroutines.test.runTest
@@ -237,4 +239,74 @@ class RequestConfigBuilderTest {
 
     assertEquals("https://api.example.com/albums", result.url) // No query string
   }
+
+  // Run-both composition: the sync/async split replaced the old ambiguous variant.
+
+  @Test
+  fun `composeResolved merges async then sync with sync winning`() {
+    val async =
+      RequestConfig(null, null, "https://async.example.com", null, null, null, null, "ASYNC")
+    val sync = RequestConfig(null, null, null, null, null, null, null, "SYNC")
+
+    val merged = RequestConfigBuilder.composeResolved(async, sync)
+
+    assertEquals("SYNC", merged?.userAgent) // sync wins
+    assertEquals("https://async.example.com", merged?.baseUrl) // async's baseUrl survives
+  }
+
+  @Test
+  fun `composeResolved returns the single present side, or null for neither`() {
+    val cfg = RequestConfig(null, null, null, null, null, null, null, "ONLY")
+
+    assertEquals("ONLY", RequestConfigBuilder.composeResolved(cfg, null)?.userAgent)
+    assertEquals("ONLY", RequestConfigBuilder.composeResolved(null, cfg)?.userAgent)
+    assertNull(RequestConfigBuilder.composeResolved(null, null))
+  }
+
+  @Test
+  fun `mergeConfig MediaRequestConfig static fields merge over base and preserve callbacks`() =
+    runTest {
+      val base =
+        RequestConfig(
+          method = null,
+          path = "/stream.mp3",
+          baseUrl = "https://media.example.com",
+          headers = mapOf("x-base" to "1"),
+          query = null,
+          body = null,
+          contentType = null,
+          userAgent = "base-ua",
+        )
+      val override = mediaConfig(headers = mapOf("x-media" to "2"), query = mapOf("token" to "abc"))
+      val merged = RequestConfigBuilder.mergeConfig(base, override)
+      assertEquals("/stream.mp3", merged.path)
+      assertEquals("https://media.example.com", merged.baseUrl)
+      assertEquals("1", merged.headers?.get("x-base"))
+      assertEquals("2", merged.headers?.get("x-media"))
+      assertEquals("abc", merged.query?.get("token"))
+      assertEquals("base-ua", merged.userAgent)
+    }
+
+  // Request-Config Layer rule (mirrors iOS applyLayer and the web stub): a
+  // layer's static `path` never overrides the base path — the path is carried
+  // from the base; only a Transform may change it.
+
+  @Test
+  fun `mergeConfig TransformableRequestConfig carries the base path over a static layer path`() =
+    runTest {
+      val base =
+        RequestConfig(null, "/navigated", "https://api.example.com", null, null, null, null, null)
+      val layer = transformableConfig(path = "/static-layer-path")
+      val merged = RequestConfigBuilder.mergeConfig(base, layer, emptyMap())
+      assertEquals("/navigated", merged.path)
+    }
+
+  @Test
+  fun `mergeConfig MediaRequestConfig carries the base path over a static media path`() = runTest {
+    val base =
+      RequestConfig(null, "/stream/123", "https://api.example.com", null, null, null, null, null)
+    val media = mediaConfig(path = "/static-media-path")
+    val merged = RequestConfigBuilder.mergeConfig(base, media)
+    assertEquals("/stream/123", merged.path)
+  }
 }

package/android/src/test/java/com/audiobrowser/player/CapabilityControlsTest.kt

@@ -0,0 +1,203 @@
+package com.audiobrowser.player
+
+import com.margelo.nitro.audiobrowser.PlayerCapabilities
+import com.margelo.nitro.audiobrowser.RemoteButton
+import com.margelo.nitro.audiobrowser.RemoteButtonLayout
+import com.margelo.nitro.audiobrowser.Variant_Boolean_FavoriteConfig
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+/**
+ * Truth tables for the pure Capability decision core: [PlayerCapabilities.isEnabled] (one rule for
+ * "available by default, only false disables; favorite is opt-in; play/pause is one control") and
+ * [deriveButtonSlots] (the single slot derivation every Media3 assembly consumes).
+ */
+class CapabilityControlsTest {
+
+  private fun capabilities(
+    play: Boolean? = null,
+    pause: Boolean? = null,
+    stop: Boolean? = null,
+    seekTo: Boolean? = null,
+    skipToNext: Boolean? = null,
+    skipToPrevious: Boolean? = null,
+    jumpForward: Boolean? = null,
+    jumpBackward: Boolean? = null,
+    favorite: Boolean? = null,
+  ) =
+    PlayerCapabilities(
+      play = play,
+      pause = pause,
+      stop = stop,
+      seekTo = seekTo,
+      skipToNext = skipToNext,
+      skipToPrevious = skipToPrevious,
+      jumpForward = jumpForward,
+      jumpBackward = jumpBackward,
+      favorite = favorite?.let { Variant_Boolean_FavoriteConfig.First(it) },
+      shuffleMode = null,
+      repeatMode = null,
+      playbackRate = null,
+    )
+
+  private fun layout(
+    back: RemoteButton? = null,
+    forward: RemoteButton? = null,
+    overflow: Array<RemoteButton> = emptyArray(),
+  ) = RemoteButtonLayout(back = back, forward = forward, overflow = overflow)
+
+  private fun slots(
+    capabilities: PlayerCapabilities,
+    layout: RemoteButtonLayout? = null,
+  ): List<Pair<RemoteButton, ButtonSlot>> =
+    deriveButtonSlots(capabilities, layout).map { it.button to it.slot }
+
+  // MARK: isEnabled
+
+  @Test
+  fun `everything but favorite is enabled by default`() {
+    val defaults = capabilities()
+    for (control in Capability.entries) {
+      assertEquals("$control", control != Capability.FAVORITE, defaults.isEnabled(control))
+    }
+  }
+
+  @Test
+  fun `only an explicit false disables a control`() {
+    val caps = capabilities(skipToNext = false, jumpBackward = false)
+    assertFalse(caps.isEnabled(Capability.SKIP_TO_NEXT))
+    assertFalse(caps.isEnabled(Capability.JUMP_BACKWARD))
+    assertTrue(caps.isEnabled(Capability.SKIP_TO_PREVIOUS))
+    assertTrue(caps.isEnabled(Capability.JUMP_FORWARD))
+  }
+
+  @Test
+  fun `play pause is one control - it survives a single half being disabled`() {
+    assertTrue(capabilities(play = false).isEnabled(Capability.PLAY_PAUSE))
+    assertTrue(capabilities(pause = false).isEnabled(Capability.PLAY_PAUSE))
+    assertFalse(capabilities(play = false, pause = false).isEnabled(Capability.PLAY_PAUSE))
+  }
+
+  @Test
+  fun `favorite is opt-in`() {
+    assertFalse(capabilities().isEnabled(Capability.FAVORITE))
+    assertFalse(capabilities(favorite = false).isEnabled(Capability.FAVORITE))
+    assertTrue(capabilities(favorite = true).isEnabled(Capability.FAVORITE))
+  }
+
+  // MARK: deriveButtonSlots — capability defaults
+
+  @Test
+  fun `default layout puts skip on the primary positions, jump and favorite in overflow`() {
+    val derived = slots(capabilities(favorite = true))
+    assertEquals(
+      listOf(
+        RemoteButton.SKIP_TO_PREVIOUS to ButtonSlot.BACK,
+        RemoteButton.SKIP_TO_NEXT to ButtonSlot.FORWARD,
+        RemoteButton.JUMP_BACKWARD to ButtonSlot.OVERFLOW,
+        RemoteButton.JUMP_FORWARD to ButtonSlot.OVERFLOW,
+        RemoteButton.FAVORITE to ButtonSlot.OVERFLOW,
+      ),
+      derived,
+    )
+  }
+
+  @Test
+  fun `jump falls back to a primary position when skip is disabled`() {
+    val derived = slots(capabilities(skipToPrevious = false, skipToNext = false))
+    assertEquals(
+      listOf(
+        RemoteButton.JUMP_BACKWARD to ButtonSlot.BACK,
+        RemoteButton.JUMP_FORWARD to ButtonSlot.FORWARD,
+      ),
+      derived,
+    )
+  }
+
+  @Test
+  fun `a fully disabled side leaves its position empty`() {
+    val derived =
+      slots(capabilities(skipToPrevious = false, jumpBackward = false, jumpForward = false))
+    assertEquals(listOf(RemoteButton.SKIP_TO_NEXT to ButtonSlot.FORWARD), derived)
+  }
+
+  // MARK: deriveButtonSlots — explicit layout
+
+  @Test
+  fun `an explicit layout maps every field and keeps overflow order`() {
+    val derived =
+      slots(
+        capabilities(),
+        layout(
+          back = RemoteButton.JUMP_BACKWARD,
+          forward = RemoteButton.JUMP_FORWARD,
+          overflow = arrayOf(RemoteButton.SKIP_TO_PREVIOUS, RemoteButton.SKIP_TO_NEXT),
+        ),
+      )
+    assertEquals(
+      listOf(
+        RemoteButton.JUMP_BACKWARD to ButtonSlot.BACK,
+        RemoteButton.JUMP_FORWARD to ButtonSlot.FORWARD,
+        RemoteButton.SKIP_TO_PREVIOUS to ButtonSlot.OVERFLOW,
+        RemoteButton.SKIP_TO_NEXT to ButtonSlot.OVERFLOW,
+      ),
+      derived,
+    )
+  }
+
+  @Test
+  fun `a null field leaves that position empty`() {
+    val derived = slots(capabilities(), layout(back = null, forward = RemoteButton.SKIP_TO_NEXT))
+    assertEquals(listOf(RemoteButton.SKIP_TO_NEXT to ButtonSlot.FORWARD), derived)
+  }
+
+  @Test
+  fun `a layout is never merged with the capability defaults`() {
+    // Nitro collapses an omitted and a null enum field to the same Kotlin null, so a per-field
+    // merge is not expressible: an empty position must stay empty rather than falling back to the
+    // capability default. Every capability here is enabled, so a merge would add skip and jump.
+    val derived =
+      slots(capabilities(favorite = true), layout(overflow = arrayOf(RemoteButton.FAVORITE)))
+    assertEquals(listOf(RemoteButton.FAVORITE to ButtonSlot.OVERFLOW), derived)
+  }
+
+  @Test
+  fun `a disabled entry drops out without promoting anything into its position`() {
+    // favorite unset (= disabled), skipToPrevious explicitly off. skip-to-next must stay on
+    // FORWARD rather than sliding into the vacated BACK position.
+    val derived =
+      slots(
+        capabilities(skipToPrevious = false),
+        layout(
+          back = RemoteButton.SKIP_TO_PREVIOUS,
+          forward = RemoteButton.SKIP_TO_NEXT,
+          overflow = arrayOf(RemoteButton.FAVORITE),
+        ),
+      )
+    assertEquals(listOf(RemoteButton.SKIP_TO_NEXT to ButtonSlot.FORWARD), derived)
+  }
+
+  // MARK: sameAs
+
+  @Test
+  fun `sameAs compares overflow by content, not by array identity`() {
+    val a = layout(back = RemoteButton.JUMP_BACKWARD, overflow = arrayOf(RemoteButton.FAVORITE))
+    val b = layout(back = RemoteButton.JUMP_BACKWARD, overflow = arrayOf(RemoteButton.FAVORITE))
+    // Distinct Array instances — data-class `==` would call these different and republish the
+    // layout to Android Auto on every unrelated options update.
+    assertTrue(a.sameAs(b))
+    assertFalse(a.sameAs(layout(back = RemoteButton.JUMP_BACKWARD)))
+    assertFalse(
+      a.sameAs(layout(back = RemoteButton.JUMP_FORWARD, overflow = arrayOf(RemoteButton.FAVORITE)))
+    )
+  }
+
+  @Test
+  fun `sameAs treats null as its own layout`() {
+    assertTrue(null.sameAs(null))
+    assertFalse(layout(back = RemoteButton.SKIP_TO_NEXT).sameAs(null))
+    assertFalse(null.sameAs(layout(back = RemoteButton.SKIP_TO_NEXT)))
+  }
+}

package/android/src/test/java/com/audiobrowser/player/DynamicLoadControlTest.kt

@@ -0,0 +1,56 @@
+package com.audiobrowser.player
+
+import androidx.media3.common.C
+import androidx.media3.common.Timeline
+import androidx.media3.exoplayer.LoadControl
+import androidx.media3.exoplayer.analytics.PlayerId
+import androidx.media3.exoplayer.source.MediaSource
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+class DynamicLoadControlTest {
+
+  private fun params(rebuffering: Boolean, bufferedUs: Long = 0L) =
+    LoadControl.Parameters(
+      PlayerId.UNSET,
+      Timeline.EMPTY,
+      MediaSource.MediaPeriodId(Any()),
+      /* playbackPositionUs= */ 0L,
+      /* bufferedDurationUs= */ bufferedUs,
+      /* playbackSpeed= */ 1.0f,
+      /* playWhenReady= */ true,
+      /* rebuffering= */ rebuffering,
+      /* targetLiveOffsetUs= */ C.TIME_UNSET,
+      /* lastRebufferRealtimeMs= */ 0L,
+    )
+
+  @Test
+  fun `isRebuffering starts false`() {
+    assertFalse(DynamicLoadControl().isRebuffering)
+  }
+
+  @Test
+  fun `mirrors ExoPlayer's rebuffering flag during buffering decisions`() {
+    val loadControl = DynamicLoadControl()
+    loadControl.shouldStartPlayback(params(rebuffering = true))
+    assertTrue(loadControl.isRebuffering)
+  }
+
+  @Test
+  fun `clears once the rebuffer recovers`() {
+    val loadControl = DynamicLoadControl()
+    loadControl.shouldStartPlayback(params(rebuffering = true))
+    // A later poll while playing normally reports rebuffering = false.
+    loadControl.shouldContinueLoading(params(rebuffering = false))
+    assertFalse(loadControl.isRebuffering)
+  }
+
+  @Test
+  fun `onPrepared resets rebuffering so a new track's initial connect isn't a rebuffer`() {
+    val loadControl = DynamicLoadControl()
+    loadControl.shouldContinueLoading(params(rebuffering = true))
+    loadControl.onPrepared()
+    assertFalse(loadControl.isRebuffering)
+  }
+}

package/android/src/test/java/com/audiobrowser/player/EqualizerControllerTest.kt

@@ -0,0 +1,216 @@
+package com.audiobrowser.player
+
+import androidx.media3.common.C
+import com.margelo.nitro.audiobrowser.EqualizerSettings
+import org.junit.Assert.assertArrayEquals
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertSame
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+/**
+ * The controller's contract across the stretches where no equalizer effect exists — before the
+ * first audio session and across a session change. Settings asked for in a gap have to survive it,
+ * and every effect that appears has to announce itself, because the JS side reads the settings once
+ * at startup and otherwise never learns the equalizer arrived.
+ */
+class EqualizerControllerTest {
+
+  /** Records what the controller does to an effect, and reports whatever it is told to report. */
+  private class FakeEffect(override val audioSessionId: Int) : EqualizerEffect {
+    var reported: EqualizerSettings? = equalizerSettings(preset = null, enabled = false)
+    var callback: ((EqualizerSettings) -> Unit)? = null
+    var released = false
+    val presets = mutableListOf<String>()
+    val levels = mutableListOf<DoubleArray>()
+    val enabledCalls = mutableListOf<Boolean>()
+
+    override fun getSettings() = reported
+
+    override fun setOnSettingsChanged(callback: (EqualizerSettings) -> Unit) {
+      this.callback = callback
+    }
+
+    override fun setEnabled(enabled: Boolean) {
+      enabledCalls += enabled
+    }
+
+    override fun setPreset(presetName: String) {
+      presets += presetName
+    }
+
+    override fun setLevels(levels: DoubleArray) {
+      this.levels += levels
+    }
+
+    override fun release() {
+      released = true
+    }
+  }
+
+  private class Fixture(private val failFor: Set<Int> = emptySet()) {
+    val emitted = mutableListOf<EqualizerSettings>()
+    val created = mutableListOf<FakeEffect>()
+    val controller =
+      EqualizerController({ emitted += it }) { audioSessionId ->
+        if (audioSessionId in failFor) throw RuntimeException("no effect for $audioSessionId")
+        FakeEffect(audioSessionId).also { created += it }
+      }
+  }
+
+  @Test
+  fun `an unset session defers creation and emits nothing`() {
+    val fixture = Fixture()
+
+    fixture.controller.initialize(C.AUDIO_SESSION_ID_UNSET)
+
+    assertTrue("created", fixture.created.isEmpty())
+    assertTrue("emitted", fixture.emitted.isEmpty())
+    assertNull("settings", fixture.controller.getSettings())
+  }
+
+  @Test
+  fun `the first effect announces its settings`() {
+    val fixture = Fixture()
+    fixture.controller.initialize(C.AUDIO_SESSION_ID_UNSET)
+
+    fixture.controller.onAudioSessionChanged(42)
+
+    assertEquals("created", 1, fixture.created.size)
+    assertEquals("emitted", 1, fixture.emitted.size)
+    assertSame("emitted settings", fixture.created[0].reported, fixture.emitted[0])
+  }
+
+  @Test
+  fun `settings asked for before any effect exists land on the first one`() {
+    val fixture = Fixture()
+    fixture.controller.initialize(C.AUDIO_SESSION_ID_UNSET)
+
+    fixture.controller.setPreset("Rock")
+    fixture.controller.setEnabled(true)
+    fixture.controller.onAudioSessionChanged(42)
+
+    val effect = fixture.created.single()
+    assertEquals("presets", listOf("Rock"), effect.presets)
+    assertEquals("enabled", listOf(true), effect.enabledCalls)
+  }
+
+  @Test
+  fun `a preset and custom levels asked for in a gap do not both apply`() {
+    val fixture = Fixture()
+    fixture.controller.initialize(C.AUDIO_SESSION_ID_UNSET)
+
+    fixture.controller.setPreset("Rock")
+    fixture.controller.setLevels(doubleArrayOf(300.0, -200.0))
+    fixture.controller.onAudioSessionChanged(42)
+
+    val effect = fixture.created.single()
+    assertTrue("presets", effect.presets.isEmpty())
+    assertArrayEquals("levels", doubleArrayOf(300.0, -200.0), effect.levels.single(), 0.0)
+  }
+
+  @Test
+  fun `restoring pending settings emits once, after the restore`() {
+    val fixture = Fixture()
+    fixture.controller.initialize(C.AUDIO_SESSION_ID_UNSET)
+    fixture.controller.setPreset("Rock")
+
+    fixture.controller.onAudioSessionChanged(42)
+
+    // The effect only gets the callback once the restore is done, so the intermediate states of a
+    // multi-step restore never reach the caller.
+    assertEquals("emitted", 1, fixture.emitted.size)
+    assertTrue("callback wired", fixture.created.single().callback != null)
+  }
+
+  @Test
+  fun `a live effect takes settings directly`() {
+    val fixture = Fixture()
+    fixture.controller.initialize(42)
+
+    fixture.controller.setPreset("Jazz")
+    fixture.controller.setLevels(doubleArrayOf(100.0))
+    fixture.controller.setEnabled(true)
+
+    val effect = fixture.created.single()
+    assertEquals("presets", listOf("Jazz"), effect.presets)
+    assertEquals("levels", 1, effect.levels.size)
+    assertEquals("enabled", listOf(true), effect.enabledCalls)
+  }
+
+  @Test
+  fun `a session change carries the active preset to the new effect`() {
+    val fixture = Fixture()
+    fixture.controller.initialize(42)
+    fixture.created.single().reported = equalizerSettings(preset = "Rock", enabled = true)
+
+    fixture.controller.onAudioSessionChanged(43)
+
+    assertTrue("old released", fixture.created[0].released)
+    val fresh = fixture.created[1]
+    assertEquals("session", 43, fresh.audioSessionId)
+    assertEquals("presets", listOf("Rock"), fresh.presets)
+    assertEquals("enabled", listOf(true), fresh.enabledCalls)
+  }
+
+  @Test
+  fun `a session change carries custom levels when no preset is active`() {
+    val fixture = Fixture()
+    fixture.controller.initialize(42)
+    fixture.created.single().reported =
+      equalizerSettings(preset = null, enabled = true, levels = doubleArrayOf(400.0, 0.0))
+
+    fixture.controller.onAudioSessionChanged(43)
+
+    val fresh = fixture.created[1]
+    assertTrue("presets", fresh.presets.isEmpty())
+    assertArrayEquals("levels", doubleArrayOf(400.0, 0.0), fresh.levels.single(), 0.0)
+  }
+
+  @Test
+  fun `the same session is left alone`() {
+    val fixture = Fixture()
+    fixture.controller.initialize(42)
+    fixture.emitted.clear()
+
+    fixture.controller.onAudioSessionChanged(42)
+
+    assertEquals("created", 1, fixture.created.size)
+    assertFalse("released", fixture.created.single().released)
+    assertTrue("emitted", fixture.emitted.isEmpty())
+  }
+
+  @Test
+  fun `a failed create keeps the pending settings for the next session`() {
+    val fixture = Fixture(failFor = setOf(42))
+    fixture.controller.initialize(C.AUDIO_SESSION_ID_UNSET)
+    fixture.controller.setPreset("Rock")
+
+    fixture.controller.onAudioSessionChanged(42)
+    assertTrue("created", fixture.created.isEmpty())
+    assertNull("settings", fixture.controller.getSettings())
+
+    fixture.controller.onAudioSessionChanged(43)
+    assertEquals("presets", listOf("Rock"), fixture.created.single().presets)
+  }
+
+  private companion object {
+    fun equalizerSettings(
+      preset: String?,
+      enabled: Boolean,
+      levels: DoubleArray = doubleArrayOf(0.0, 0.0),
+    ) =
+      EqualizerSettings(
+        activePreset = preset,
+        bandCount = levels.size.toDouble(),
+        bandLevels = levels,
+        centerBandFrequencies = DoubleArray(levels.size),
+        enabled = enabled,
+        lowerBandLevelLimit = -1500.0,
+        presets = arrayOf("Normal", "Rock", "Jazz"),
+        upperBandLevelLimit = 1500.0,
+      )
+  }
+}

package/android/src/test/java/com/audiobrowser/player/MediaSessionSlotMappingTest.kt

@@ -0,0 +1,45 @@
+package com.audiobrowser.player
+
+import androidx.media3.session.CommandButton
+import org.junit.Assert.assertArrayEquals
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+/**
+ * Guards the slot preference lists handed to Media3.
+ *
+ * The invariant that matters is the OVERFLOW fallback: every flattening keeps a button only if it
+ * won SLOT_BACK, won SLOT_FORWARD, or names SLOT_OVERFLOW. A slot that stops naming OVERFLOW
+ * silently deletes its button from the notification and the car the moment its primary position is
+ * unavailable, so the loop below asserts the property for every slot rather than only today's
+ * three.
+ */
+class MediaSessionSlotMappingTest {
+
+  @Test
+  fun `primary slots are preferred with an overflow fallback`() {
+    assertArrayEquals(
+      intArrayOf(CommandButton.SLOT_BACK, CommandButton.SLOT_OVERFLOW),
+      media3SlotsFor(ButtonSlot.BACK),
+    )
+    assertArrayEquals(
+      intArrayOf(CommandButton.SLOT_FORWARD, CommandButton.SLOT_OVERFLOW),
+      media3SlotsFor(ButtonSlot.FORWARD),
+    )
+  }
+
+  @Test
+  fun `overflow does not repeat itself`() {
+    assertArrayEquals(intArrayOf(CommandButton.SLOT_OVERFLOW), media3SlotsFor(ButtonSlot.OVERFLOW))
+  }
+
+  @Test
+  fun `every slot names OVERFLOW so nothing can be dropped`() {
+    for (slot in ButtonSlot.entries) {
+      assertTrue(
+        "$slot must name SLOT_OVERFLOW or its button is dropped from the notification and the car",
+        media3SlotsFor(slot).contains(CommandButton.SLOT_OVERFLOW),
+      )
+    }
+  }
+}