react-native-audio-browser 0.2.0-next.2 → 0.2.0-next.20

package/android/src/test/java/com/audiobrowser/browser/BrowserManagerTest.kt

@@ -1,19 +1,35 @@
 package com.audiobrowser.browser
 
+import androidx.media3.common.C
+import androidx.media3.common.MediaItem
+import com.audiobrowser.TestFixtures.resolvedTrack
+import com.audiobrowser.TestFixtures.section
+import com.audiobrowser.TestFixtures.sectionStyle
+import com.audiobrowser.TestFixtures.staticRoute
+import com.audiobrowser.TestFixtures.track
+import com.audiobrowser.util.BrowserPathHelper
 import kotlinx.coroutines.runBlocking
-import org.junit.Assert.*
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNull
+import org.junit.Assert.fail
 import org.junit.Before
 import org.junit.Test
 import org.junit.runner.RunWith
 import org.robolectric.RobolectricTestRunner
 
-// TODO: Most tests disabled — BrowserConfig API changed (routes is now Array<NativeRouteEntry>).
-// When revived, add expandQueueFromContextualUrl glue tests: found id → its
-// SectionScope section as the queue; vanished id → null (single-track
-// fallback). The section logic and the caller fallback are covered
-// (SectionScopeTest, TrackSelectorTests); the wiring between them is not.
-// Tests that used BrowserSource/BrowserList need to be rewritten.
-
+/**
+ * Navigation and queue-expansion glue.
+ *
+ * [BrowserManager.expandQueueFromContextualPath] is the seam between the page a listener tapped in
+ * and the queue that starts playing. Its two halves are covered on their own — the section logic in
+ * [SectionScopeTest], the caller's single-track fallback in the player tests — but the wiring
+ * between them is what decides whether tapping row 3 of a page resumes the right station, and only
+ * these tests exercise it.
+ *
+ * Routes serve `browseStatic`, the one browse arm that needs neither the JNI bridge nor HTTP.
+ * Robolectric is required for `android.net.Uri` (contextual-path parsing) and
+ * `android.util.LruCache` (the content cache).
+ */
 @RunWith(RobolectricTestRunner::class)
 class BrowserManagerTest {
 
@@ -24,6 +40,31 @@ class BrowserManagerTest {
     browserManager = BrowserManager()
   }
 
+  /** Configures a single static route at [path] serving [children] as its page. */
+  private fun servePage(
+    path: String,
+    vararg children: com.margelo.nitro.audiobrowser.Track,
+    singleTrack: Boolean = false,
+  ) {
+    browserManager.config =
+      BrowserConfig(
+        routes =
+          arrayOf(staticRoute(path, resolvedTrack(path = path, children = arrayOf(*children)))),
+        singleTrack = singleTrack,
+      )
+  }
+
+  /** Configures a single static route at [path] serving [sections] as its page. */
+  private fun serveSections(path: String, vararg sections: com.margelo.nitro.audiobrowser.Section) {
+    browserManager.config =
+      BrowserConfig(
+        routes =
+          arrayOf(staticRoute(path, resolvedTrack(path = path, sections = arrayOf(*sections))))
+      )
+  }
+
+  private fun contextual(path: String, trackId: String) = BrowserPathHelper.build(path, trackId)
+
   @Test
   fun `getPath returns default path initially`() {
     assertEquals("/", browserManager.getPath())
@@ -64,4 +105,301 @@ class BrowserManagerTest {
       } catch (_: ContentNotFoundException) {}
     }
   }
+
+  @Test
+  fun `navigate serves a static route and gives playable children contextual urls`() = runBlocking {
+    servePage("/library", track(src = "a", title = "A"), track(src = "b", title = "B"))
+
+    val resolved = browserManager.navigate("/library")
+
+    assertEquals(listOf("A", "B"), resolved.flattenedChildren?.map { it.title })
+    // The tap target: a child's path is rewritten to point back at this page
+    // plus its own id and page position (the duplicate-identity tie-breaker).
+    assertEquals(
+      listOf(
+        BrowserPathHelper.build("/library", "a", 0),
+        BrowserPathHelper.build("/library", "b", 1),
+      ),
+      resolved.flattenedChildren?.map { it.path },
+    )
+    assertEquals("/library", browserManager.getPath())
+  }
+
+  // MARK: - expandQueueFromContextualPath
+
+  @Test
+  fun `expandQueueFromContextualPath scopes the queue to the tapped section`() = runBlocking {
+    serveSections(
+      "/home",
+      section(title = "Recent", children = arrayOf(track(src = "a"), track(src = "b"))),
+      section(title = "Popular", children = arrayOf(track(src = "c"), track(src = "d"))),
+    )
+
+    val expanded = browserManager.expandQueueFromContextualPath(contextual("/home", "c"))
+
+    // "Popular" only — a page aggregating sections must not leak next/previous across them.
+    val (queue, index) = requireNotNull(expanded)
+    assertEquals(listOf("c", "d"), queue.map { it.src })
+    assertEquals(0, index)
+  }
+
+  @Test
+  fun `expandQueueFromContextualPath indexes the tapped track within its section`() = runBlocking {
+    serveSections(
+      "/home",
+      section(title = "Recent", children = arrayOf(track(src = "a"))),
+      section(title = "Popular", children = arrayOf(track(src = "b"), track(src = "c"))),
+    )
+
+    val (queue, index) =
+      requireNotNull(browserManager.expandQueueFromContextualPath(contextual("/home", "c")))
+
+    assertEquals(listOf("b", "c"), queue.map { it.src })
+    assertEquals(1, index)
+  }
+
+  @Test
+  fun `expandQueueFromContextualPath pins the tapped copy of a duplicate identity`() = runBlocking {
+    // The same src twice in one section (normal for music playlists): the
+    // stamped page index selects the tapped copy, so "next" continues from
+    // there instead of from the first copy.
+    servePage("/playlist", track(src = "a"), track(src = "b"), track(src = "a"), track(src = "c"))
+
+    val (queue, index) =
+      requireNotNull(
+        browserManager.expandQueueFromContextualPath(BrowserPathHelper.build("/playlist", "a", 2))
+      )
+
+    assertEquals(listOf("a", "b", "a", "c"), queue.map { it.src })
+    assertEquals(2, index)
+  }
+
+  @Test
+  fun `expandQueueFromContextualPath scopes a cross-section duplicate to the tapped section`() =
+    runBlocking {
+      // The same identity in a rail section AND the list section below it:
+      // the stamped flat index resolves the tap to the list section.
+      serveSections(
+        "/home",
+        section(
+          title = "Row",
+          style =
+            sectionStyle(
+              display = com.margelo.nitro.audiobrowser.StyleDisplay.GRID,
+              artworkRendering = null,
+              gridWrap = false,
+            ),
+          children = arrayOf(track(src = "dup")),
+        ),
+        section(title = "Stations", children = arrayOf(track(src = "dup"), track(src = "b"))),
+      )
+
+      val (queue, index) =
+        requireNotNull(
+          browserManager.expandQueueFromContextualPath(BrowserPathHelper.build("/home", "dup", 1))
+        )
+
+      assertEquals(listOf("dup", "b"), queue.map { it.src })
+      assertEquals(0, index)
+    }
+
+  @Test
+  fun `expandQueueFromContextualPath falls back to the first match on a stale index`() =
+    runBlocking {
+      // The list shifted since the stamp: the child at the index no longer
+      // carries the identity, so resolution ignores the index and falls back
+      // to the first identity match instead of aborting.
+      servePage("/home", track(src = "x"), track(src = "a"), track(src = "b"))
+
+      val (queue, index) =
+        requireNotNull(
+          browserManager.expandQueueFromContextualPath(BrowserPathHelper.build("/home", "a", 0))
+        )
+
+      assertEquals(listOf("x", "a", "b"), queue.map { it.src })
+      assertEquals(1, index)
+    }
+
+  @Test
+  fun `expandQueueFromContextualPath returns null when the id has vanished from the page`() =
+    runBlocking {
+      // The stored path points at a track the page no longer lists — the page changed under a
+      // resumed session. Queueing the current list would resume the wrong station, so expansion
+      // aborts and the caller falls back to the stored single track.
+      servePage("/home", track(src = "a"), track(src = "b"))
+
+      assertNull(browserManager.expandQueueFromContextualPath(contextual("/home", "gone")))
+    }
+
+  @Test
+  fun `expandQueueFromContextualPath returns null for a non-contextual path`() = runBlocking {
+    servePage("/home", track(src = "a"))
+
+    assertNull(browserManager.expandQueueFromContextualPath("/home"))
+  }
+
+  @Test
+  fun `expandQueueFromContextualPath returns null when the page has no children`() = runBlocking {
+    browserManager.config =
+      BrowserConfig(routes = arrayOf(staticRoute("/home", resolvedTrack(path = "/home"))))
+
+    assertNull(browserManager.expandQueueFromContextualPath(contextual("/home", "a")))
+  }
+
+  @Test
+  fun `expandQueueFromContextualPath scopes a rail section to its own tiles`() = runBlocking {
+    serveSections(
+      "/home",
+      section(
+        title = "Most Played",
+        style =
+          sectionStyle(
+            display = com.margelo.nitro.audiobrowser.StyleDisplay.GRID,
+            artworkRendering = null,
+            gridWrap = false,
+          ),
+        children = arrayOf(track(src = "r1"), track(src = "r2")),
+      ),
+      section(children = arrayOf(track(src = "a"))),
+    )
+
+    val (queue, index) =
+      requireNotNull(browserManager.expandQueueFromContextualPath(contextual("/home", "r2")))
+
+    // A tile tap queues its section, not the list rows beside it.
+    assertEquals(listOf("r1", "r2"), queue.map { it.src })
+    assertEquals(1, index)
+  }
+
+  @Test
+  fun `expandQueueFromContextualPath drops unplayable siblings`() = runBlocking {
+    serveSections(
+      "/home",
+      section(
+        title = "Mixed",
+        children =
+          arrayOf(
+            track(src = "a"),
+            // A browsable row sitting inside the same section — no src, so not queueable.
+            track(src = null).copy(path = "/sub"),
+            track(src = "b"),
+          ),
+      ),
+    )
+
+    val (queue, index) =
+      requireNotNull(browserManager.expandQueueFromContextualPath(contextual("/home", "b")))
+
+    assertEquals(listOf("a", "b"), queue.map { it.src })
+    assertEquals(1, index)
+  }
+
+  @Test
+  fun `navigate stamps the identity, not the src, into id-bearing children's contextual urls`() =
+    runBlocking {
+      servePage(
+        "/home",
+        track(id = "stable-a", src = "https://s/a.mp3", title = "A"),
+        track(src = "https://s/b.mp3", title = "B"),
+      )
+
+      val resolved = browserManager.navigate("/home")
+
+      // id when non-blank, else src — Track.identity (ADR 0008).
+      assertEquals(
+        listOf(
+          BrowserPathHelper.build("/home", "stable-a", 0),
+          BrowserPathHelper.build("/home", "https://s/b.mp3", 1),
+        ),
+        resolved.flattenedChildren?.map { it.path },
+      )
+    }
+
+  @Test
+  fun `expandQueueFromContextualPath finds the selected index by identity`() = runBlocking {
+    servePage(
+      "/home",
+      track(id = "stable-a", src = "https://s/a.mp3"),
+      track(id = "stable-b", src = "https://s/b.mp3"),
+      track(id = "stable-c", src = "https://s/c.mp3"),
+    )
+
+    val (queue, index) =
+      requireNotNull(browserManager.expandQueueFromContextualPath(contextual("/home", "stable-c")))
+
+    assertEquals(listOf("stable-a", "stable-b", "stable-c"), queue.map { it.id })
+    assertEquals(2, index)
+  }
+
+  @Test
+  fun `getCachedTrack resolves an id-valued trackId through the cache`() = runBlocking {
+    servePage("/home", track(id = "stable-b", src = "https://s/b.mp3", title = "B"))
+    browserManager.navigate("/home")
+
+    // A contextual mediaId whose __trackId is the identity (the id), with a parent path that was
+    // never cached directly — the extract-then-lookup path must find it via the id key.
+    val mediaId = contextual("/elsewhere", "stable-b")
+
+    assertEquals("B", browserManager.getCachedTrack(mediaId)?.title)
+  }
+
+  @Test
+  fun `expandQueueFromContextualPath honours singleTrack`() = runBlocking {
+    servePage("/home", track(src = "a"), track(src = "b"), singleTrack = true)
+
+    val (queue, index) =
+      requireNotNull(browserManager.expandQueueFromContextualPath(contextual("/home", "b")))
+
+    assertEquals(listOf("b"), queue.map { it.src })
+    assertEquals(0, index)
+  }
+
+  // --- Track.disabled: queue expansion excludes unavailable tracks ---
+
+  @Test
+  fun `expandQueueFromContextualPath excludes disabled tracks`() = runBlocking {
+    servePage(
+      "/home",
+      track(src = "a"),
+      track(src = "unavailable", disabled = true),
+      track(src = "b"),
+    )
+
+    val (queue, index) =
+      requireNotNull(browserManager.expandQueueFromContextualPath(contextual("/home", "b")))
+
+    assertEquals(listOf("a", "b"), queue.map { it.src })
+    assertEquals(1, index)
+  }
+
+  @Test
+  fun `expandQueueFromContextualPath aborts when the tapped track is disabled`() = runBlocking {
+    // A disabled track never plays: with the tapped identity excluded from the
+    // playable list, expansion aborts, and every caller's fallback refuses the
+    // disabled track itself — navigateTrack's guard on tap,
+    // onPlaybackResumption's refusal on resume.
+    servePage("/home", track(src = "a"), track(src = "unavailable", disabled = true))
+
+    assertNull(browserManager.expandQueueFromContextualPath(contextual("/home", "unavailable")))
+  }
+
+  @Test
+  fun `resolveMediaItemsForPlayback refuses a disabled track on the legacy INDEX_UNSET path`() =
+    runBlocking {
+      // Android Auto and Assistant request playback through Media3's legacy
+      // path, which passes C.INDEX_UNSET ("the default item") — the refusal
+      // must cover it, or a stale browse row for a now-disabled track plays.
+      servePage("/home", track(src = "unavailable", disabled = true))
+      browserManager.resolve("/home")
+
+      val item = MediaItem.Builder().setMediaId("unavailable").build()
+
+      try {
+        browserManager.resolveMediaItemsForPlayback(listOf(item), C.INDEX_UNSET, 0)
+        fail("Expected refusal of a disabled track")
+      } catch (expected: IllegalStateException) {
+        // Refused by failing the future: Media3 surfaces an error to the
+        // controller and live playback stays untouched.
+      }
+    }
 }

package/android/src/test/java/com/audiobrowser/browser/BrowserUrlResolutionTest.kt

@@ -91,6 +91,44 @@ class BrowserUrlResolutionTest {
     assertEquals("https://api.example.com/artwork/abc", source?.uri)
   }
 
+  @Test
+  fun `resolveArtworkUrl leaves the id token literal for a track without an id`() = runTest {
+    bm.config =
+      BrowserConfig(
+        request = transformableConfig(baseUrl = "https://api.example.com"),
+        artwork = artworkConfig(path = "/artwork/{id}"),
+      )
+    // The config still runs (no blanket skip); the token stays literal so the resulting request
+    // 404s with a self-describing URL.
+    val source = bm.resolveArtworkUrl(track(artwork = null, id = null))
+    assertEquals("https://api.example.com/artwork/{id}", source?.uri)
+  }
+
+  @Test
+  fun `resolveArtworkUrl treats a blank id like a missing one`() = runTest {
+    bm.config =
+      BrowserConfig(
+        request = transformableConfig(baseUrl = "https://api.example.com"),
+        artwork = artworkConfig(path = "/artwork/{id}"),
+      )
+    val source = bm.resolveArtworkUrl(track(artwork = null, id = ""))
+    assertEquals("https://api.example.com/artwork/{id}", source?.uri)
+  }
+
+  @Test
+  fun `resolveArtworkUrl leaves the id token literal in header values without an id`() = runTest {
+    bm.config =
+      BrowserConfig(
+        request = transformableConfig(baseUrl = "https://api.example.com"),
+        artwork = artworkConfig(path = "/artwork", headers = mapOf("x-track" to "{id}")),
+      )
+    val source = bm.resolveArtworkUrl(track(artwork = null, id = null))
+    assertEquals("{id}", source?.headers?.get("x-track"))
+
+    val substituted = bm.resolveArtworkUrl(track(artwork = null, id = "abc"))
+    assertEquals("abc", substituted?.headers?.get("x-track"))
+  }
+
   @Test
   fun `resolveArtworkUrl applies image query params from the image context`() = runTest {
     bm.config =

package/android/src/test/java/com/audiobrowser/browser/InertStyleDiagnosticTest.kt

@@ -0,0 +1,277 @@
+package com.audiobrowser.browser
+
+import com.audiobrowser.TestFixtures.browseTrack
+import com.audiobrowser.TestFixtures.section
+import com.audiobrowser.TestFixtures.sectionStyle
+import com.audiobrowser.TestFixtures.track
+import com.audiobrowser.TestFixtures.trackStyle
+import com.margelo.nitro.audiobrowser.ArtworkRendering
+import com.margelo.nitro.audiobrowser.CardImage
+import com.margelo.nitro.audiobrowser.GridTile
+import com.margelo.nitro.audiobrowser.ImageShape
+import com.margelo.nitro.audiobrowser.Section
+import com.margelo.nitro.audiobrowser.SectionStyle
+import com.margelo.nitro.audiobrowser.StyleDisplay
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+/**
+ * The dev diagnostic for declarations that can never render (ADR 0011): the recovery for the
+ * compile-time invalid-combination errors the block model deliberately gave up. Structural
+ * inertness only — a surface that can't draw a property it understands is intended usage, never a
+ * finding. Mirrors `ios/Tests/InertStyleDiagnosticTests.swift`.
+ */
+class InertStyleDiagnosticTest {
+
+  private fun findings(
+    sections: List<Section>,
+    page: SectionStyle? = null,
+    path: String = "/home",
+  ) = InertStyleDiagnostic.findings(path, page, sections)
+
+  // Container properties
+
+  @Test
+  fun `gridWrap on a list section is inert`() {
+    val found = findings(listOf(section(style = sectionStyle(gridWrap = false), title = "Recent")))
+    assertEquals(1, found.size)
+    assertTrue(found[0], found[0].contains("section 'Recent'"))
+    assertTrue(found[0], found[0].contains("style.gridWrap"))
+    assertTrue(found[0], found[0].contains("display 'list'"))
+    assertTrue(found[0], found[0].contains("/home"))
+  }
+
+  @Test
+  fun `gridWrap in a grid is live`() {
+    val style = sectionStyle(gridWrap = false, display = StyleDisplay.GRID)
+    assertTrue(findings(listOf(section(style = style))).isEmpty())
+  }
+
+  @Test
+  fun `a section inherits the page's grid display`() {
+    // `display` resolves by scope override, so the page's grid makes the section's `gridWrap` live
+    // without the section restating it.
+    val found =
+      findings(
+        listOf(section(style = sectionStyle(gridWrap = false))),
+        page = sectionStyle(display = StyleDisplay.GRID),
+      )
+    assertTrue(found.isEmpty())
+  }
+
+  @Test
+  fun `gridTile on a list section is inert`() {
+    val found = findings(listOf(section(style = sectionStyle(gridTile = GridTile.CARD))))
+    assertEquals(1, found.size)
+    assertTrue(found[0], found[0].contains("style.gridTile"))
+    assertTrue(found[0], found[0].contains("section #1"))
+  }
+
+  // Item properties
+
+  @Test
+  fun `card properties need the card treatment`() {
+    val plainGrid =
+      sectionStyle(
+        display = StyleDisplay.GRID,
+        cardTint = "#1e3a8a",
+        cardImage = CardImage.BACKGROUND,
+      )
+    val found = findings(listOf(section(style = plainGrid, title = "Featured")))
+    assertEquals(2, found.size)
+    assertTrue(found.any { it.contains("style.cardTint") })
+    assertTrue(found.any { it.contains("style.cardImage") })
+    assertTrue(found.all { it.contains("display 'grid', gridTile 'plain'") })
+  }
+
+  @Test
+  fun `card properties in a card grid are live`() {
+    val cards =
+      sectionStyle(
+        display = StyleDisplay.GRID,
+        gridTile = GridTile.CARD,
+        cardTint = "#1e3a8a",
+        cardImage = CardImage.BACKGROUND,
+      )
+    assertTrue(findings(listOf(section(style = cards))).isEmpty())
+  }
+
+  @Test
+  fun `imageShape needs a shaped tile`() {
+    val list = sectionStyle(imageShape = ImageShape.CIRCULAR)
+    val cards =
+      sectionStyle(
+        display = StyleDisplay.GRID,
+        gridTile = GridTile.CARD,
+        imageShape = ImageShape.CIRCULAR,
+      )
+    val condensed =
+      sectionStyle(
+        display = StyleDisplay.GRID,
+        gridTile = GridTile.CONDENSED,
+        imageShape = ImageShape.CIRCULAR,
+      )
+    assertEquals(1, findings(listOf(section(style = list))).size)
+    assertEquals(1, findings(listOf(section(style = cards))).size)
+    // Plain and condensed tiles both take a shape.
+    assertTrue(findings(listOf(section(style = condensed))).isEmpty())
+  }
+
+  @Test
+  fun `accessorySymbol is inert only on cards`() {
+    val rows = sectionStyle(accessorySymbol = "lock.fill")
+    val cards =
+      sectionStyle(
+        display = StyleDisplay.GRID,
+        gridTile = GridTile.CARD,
+        accessorySymbol = "lock.fill",
+      )
+    // List rows draw accessories; card elements have no slot for one.
+    assertTrue(findings(listOf(section(style = rows))).isEmpty())
+    val found = findings(listOf(section(style = cards)))
+    assertEquals(1, found.size)
+    assertTrue(found[0], found[0].contains("no accessory slot"))
+  }
+
+  @Test
+  fun `artworkRendering is never inert`() {
+    val stencilled =
+      sectionStyle(
+        display = StyleDisplay.GRID,
+        gridTile = GridTile.CARD,
+        artworkRendering = ArtworkRendering.STENCIL,
+      )
+    assertTrue(findings(listOf(section(style = stencilled))).isEmpty())
+  }
+
+  // Track-level declarations
+
+  @Test
+  fun `track declarations are reported per section`() {
+    val results =
+      section(
+        style = sectionStyle(display = StyleDisplay.GRID),
+        title = "Results",
+        children =
+          arrayOf(
+            track(style = trackStyle(cardTint = "#111")),
+            track(src = "https://s/b.mp3", style = trackStyle(cardTint = "#222")),
+            track(src = "https://s/c.mp3"),
+          ),
+      )
+    val found = findings(listOf(results))
+    assertEquals(1, found.size)
+    assertTrue(found[0], found[0].contains("2 tracks in section 'Results'"))
+    assertTrue(found[0], found[0].contains("style.cardTint"))
+  }
+
+  @Test
+  fun `a track's own shape is live in a plain grid`() {
+    val grid =
+      section(
+        style = sectionStyle(display = StyleDisplay.GRID),
+        children = arrayOf(track(style = trackStyle(imageShape = ImageShape.CIRCULAR))),
+      )
+    assertTrue(findings(listOf(grid)).isEmpty())
+  }
+
+  // The page block
+
+  @Test
+  fun `a page declaration live in one section is not reported`() {
+    // Card tint reaches both sections; one renders cards. Live is live.
+    val found =
+      findings(
+        listOf(
+          section(style = sectionStyle(display = StyleDisplay.GRID, gridTile = GridTile.CARD)),
+          section(style = sectionStyle(display = StyleDisplay.GRID)),
+        ),
+        page = sectionStyle(cardTint = "#1e3a8a"),
+      )
+    assertTrue(found.isEmpty())
+  }
+
+  @Test
+  fun `a page declaration no section renders is reported once`() {
+    val found =
+      findings(
+        listOf(
+          section(style = sectionStyle(display = StyleDisplay.GRID), title = "A"),
+          section(title = "B"),
+        ),
+        page = sectionStyle(cardTint = "#1e3a8a"),
+      )
+    assertEquals(1, found.size)
+    assertTrue(found[0], found[0].contains("the page block"))
+    assertTrue(found[0], found[0].contains("no section that inherits it"))
+  }
+
+  @Test
+  fun `a section override shadows the page value`() {
+    // Every section declares its own tint, so the page's is never resolved — shadowed, not inert;
+    // the diagnostic reports what can't render, not what isn't reached.
+    val found =
+      findings(
+        listOf(
+          section(
+            style =
+              sectionStyle(display = StyleDisplay.GRID, gridTile = GridTile.CARD, cardTint = "#000")
+          )
+        ),
+        page = sectionStyle(cardTint = "#1e3a8a"),
+      )
+    assertTrue(found.isEmpty())
+  }
+
+  @Test
+  fun `a page-wide grid makes section declarations live`() {
+    val found =
+      findings(
+        listOf(section(style = sectionStyle(cardTint = "#111"))),
+        page = sectionStyle(display = StyleDisplay.GRID, gridTile = GridTile.CARD),
+      )
+    assertTrue(found.isEmpty())
+  }
+
+  // The positional `display`
+
+  @Test
+  fun `display on a playable track is inert`() {
+    val tracks =
+      section(
+        title = "Tracks",
+        children =
+          arrayOf(
+            track(style = trackStyle(display = StyleDisplay.GRID)),
+            browseTrack(style = trackStyle(display = StyleDisplay.GRID)),
+          ),
+      )
+    val found = findings(listOf(tracks))
+    assertEquals(1, found.size)
+    assertTrue(found[0], found[0].contains("1 track in section 'Tracks'"))
+    assertTrue(found[0], found[0].contains("style.display"))
+    assertTrue(found[0], found[0].contains("opens none"))
+  }
+
+  @Test
+  fun `display on a section or page is never inert`() {
+    val found =
+      findings(
+        listOf(
+          section(
+            style = sectionStyle(display = StyleDisplay.LIST),
+            children = arrayOf(browseTrack()),
+          )
+        ),
+        page = sectionStyle(display = StyleDisplay.GRID),
+      )
+    assertTrue(found.isEmpty())
+  }
+
+  @Test
+  fun `an unstyled page is silent`() {
+    assertTrue(findings(listOf(section(children = arrayOf(track(), browseTrack())))).isEmpty())
+    assertTrue(findings(emptyList()).isEmpty())
+  }
+}