react-native-audio-browser 0.2.0-next.11 → 0.2.0-next.13

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())
+  }
+}

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

@@ -35,7 +35,7 @@ class JsonArtworkTest {
     // so one unparseable row rejected the whole page rather than losing an image.
     val resolved =
       json.decodeFromString<JsonResolvedTrack>(
-        """{"url":"/favorites","title":"Favorites","children":[
+        """{"path":"/favorites","title":"Favorites","children":[
           {"title":"Playlist","artwork":{"light":"https://e.example/l.png","dark":"https://e.example/d.png"}}
         ]}"""
       )

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

@@ -0,0 +1,147 @@
+package com.audiobrowser.browser
+
+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.StyleDisplay
+import kotlinx.serialization.json.Json
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNull
+import org.junit.Test
+
+/** Style blocks on the wire, decoded tolerantly (ADR 0011). */
+class JsonStyleTest {
+  private val json = Json { ignoreUnknownKeys = true }
+
+  @Test
+  fun `decodes a block onto TrackStyle`() {
+    val track =
+      json.decodeFromString<JsonTrack>(
+        """{"title":"X","style":{"display":"grid","artworkRendering":"stencil"}}"""
+      )
+    val style = track.toNitro().style
+    assertEquals(StyleDisplay.GRID, style?.display)
+    assertEquals(ArtworkRendering.STENCIL, style?.artworkRendering)
+  }
+
+  @Test
+  fun `decodes a block onto SectionStyle`() {
+    val resolved =
+      json.decodeFromString<JsonResolvedTrack>(
+        """{"path":"/home","title":"Home","sections":[
+          {"style":{"display":"grid","gridWrap":false},"children":[{"title":"C","src":"s"}]}
+        ]}"""
+      )
+    val style = resolved.toNitro().sections?.first()?.style
+    assertEquals(StyleDisplay.GRID, style?.display)
+    assertEquals(false, style?.gridWrap)
+  }
+
+  @Test
+  fun `a stale string style decodes as no declaration - never a parse failure`() {
+    // The retired string vocabulary must never kill the page (tolerant
+    // decoding, ADR 0011).
+    val resolved =
+      json.decodeFromString<JsonResolvedTrack>(
+        """{"path":"/home","title":"Home","style":"rail","children":[
+          {"title":"C","src":"s","style":"grid"}
+        ]}"""
+      )
+    val nitro = resolved.toNitro()
+    assertNull(nitro.style)
+    assertNull(nitro.children?.first()?.style)
+  }
+
+  @Test
+  fun `unknown enum values decode as no declaration`() {
+    // All-unknown declarations collapse to "no block" — one shape for "no
+    // declaration" on every platform.
+    val track =
+      json.decodeFromString<JsonTrack>(
+        """{"title":"X","style":{"display":"carousel","artworkRendering":"embossed","gridWrap":"yes"}}"""
+      )
+    assertNull(track.toNitro().style)
+  }
+
+  @Test
+  fun `an empty block decodes as no declaration`() {
+    val track = json.decodeFromString<JsonTrack>("""{"title":"X","style":{}}""")
+    assertNull(track.toNitro().style)
+  }
+
+  @Test
+  fun `a quoted boolean gridWrap is a wrong-typed field - no declaration`() {
+    // iOS's strict-typed tolerant decode drops a quoted "false"; the lenient
+    // Kotlin mapper must not read it either, or the same payload renders a
+    // teaser shelf on one platform and a wrapping grid on the other.
+    val resolved =
+      json.decodeFromString<JsonResolvedTrack>(
+        """{"path":"/home","title":"Home","sections":[
+          {"style":{"display":"grid","gridWrap":"false"},"children":[{"title":"C","src":"s"}]}
+        ]}"""
+      )
+    val style = resolved.toNitro().sections?.first()?.style
+    assertEquals(StyleDisplay.GRID, style?.display)
+    assertNull(style?.gridWrap)
+  }
+
+  @Test
+  fun `decodes disabled`() {
+    val track = json.decodeFromString<JsonTrack>("""{"title":"X","src":"s","disabled":true}""")
+    assertEquals(true, track.toNitro().disabled)
+  }
+
+  @Test
+  fun `decodes imageShape and accessorySymbol`() {
+    val track =
+      json.decodeFromString<JsonTrack>(
+        """{"title":"X","style":{"imageShape":"circular","accessorySymbol":"lock.fill"}}"""
+      )
+    val style = track.toNitro().style
+    assertEquals(ImageShape.CIRCULAR, style?.imageShape)
+    assertEquals("lock.fill", style?.accessorySymbol)
+  }
+
+  @Test
+  fun `accessorySymbol 'none' is a value - not emptiness`() {
+    // The inheritance-escape sentinel must survive the wire — collapsing it
+    // to "no declaration" would let the section value flow back in.
+    val track =
+      json.decodeFromString<JsonTrack>("""{"title":"X","style":{"accessorySymbol":"none"}}""")
+    assertEquals("none", track.toNitro().style?.accessorySymbol)
+  }
+
+  @Test
+  fun `unknown imageShape decodes as no declaration`() {
+    val track =
+      json.decodeFromString<JsonTrack>("""{"title":"X","style":{"imageShape":"hexagonal"}}""")
+    assertNull(track.toNitro().style)
+  }
+
+  @Test
+  fun `decodes the card family`() {
+    val resolved =
+      json.decodeFromString<JsonResolvedTrack>(
+        """{"path":"/home","title":"Home","sections":[
+          {"style":{"display":"grid","gridTile":"card","cardTint":"#1e3a8a","cardImage":"background"},
+           "children":[{"title":"C","src":"s"}]}
+        ]}"""
+      )
+    val style = resolved.toNitro().sections?.first()?.style
+    assertEquals(GridTile.CARD, style?.gridTile)
+    assertEquals("#1e3a8a", style?.cardTint)
+    assertEquals(CardImage.BACKGROUND, style?.cardImage)
+  }
+
+  @Test
+  fun `unknown gridTile decodes as no declaration`() {
+    val resolved =
+      json.decodeFromString<JsonResolvedTrack>(
+        """{"path":"/home","title":"Home","sections":[
+          {"style":{"gridTile":"hexagon"},"children":[{"title":"C","src":"s"}]}
+        ]}"""
+      )
+    assertNull(resolved.toNitro().sections?.first()?.style)
+  }
+}

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

@@ -1,94 +1,169 @@
 package com.audiobrowser.browser
 
-import com.audiobrowser.TestFixtures.imageRowItem
+import com.audiobrowser.TestFixtures.resolvedTrack
+import com.audiobrowser.TestFixtures.section
+import com.audiobrowser.TestFixtures.sectionStyle
 import com.audiobrowser.TestFixtures.track
+import com.margelo.nitro.audiobrowser.StyleDisplay
 import org.junit.Assert.assertEquals
 import org.junit.Assert.assertNull
 import org.junit.Test
 
 class SectionScopeTest {
 
-  @Test
-  fun `scopes to the contiguous groupTitle run`() {
-    val children =
-      listOf(
-        track(id = "a", src = "a", groupTitle = "First"),
-        track(id = "b", src = "b", groupTitle = "First"),
-        track(id = "c", src = "c", groupTitle = "Second"),
-        track(id = "d", src = "d", groupTitle = "Second"),
-        track(id = "e", src = "e"),
-      )
+  // Two sections sharing an identity — the duplicate-heavy shape the flat model
+  // had to disambiguate by precedence; sections + the stamped flat index make
+  // it exact.
+  private val sections =
+    listOf(
+      section(title = "First", children = arrayOf(track(src = "dup"), track(src = "x"))),
+      section(
+        title = "Second",
+        children = arrayOf(track(src = "y"), track(src = "dup"), track(src = "z")),
+      ),
+    )
 
-    val section = SectionScope.section(children, "c") as SectionScope.Section.Run
-    assertEquals(listOf("c", "d"), section.tracks.map { it.src })
+  @Test
+  fun `falls back to the first section containing the identity`() {
+    val scoped = SectionScope.scoped(sections, "dup")!!
+    assertEquals(listOf("dup", "x"), scoped.section.children.map { it.src })
+    assertNull(scoped.tappedOffset)
+  }
 
-    val first = SectionScope.section(children, "a") as SectionScope.Section.Run
-    assertEquals(listOf("a", "b"), first.tracks.map { it.src })
+  @Test
+  fun `flat index pins the tapped section`() {
+    // Flat index 3 = second section, offset 1.
+    val scoped = SectionScope.scoped(sections, "dup", tappedIndex = 3)!!
+    assertEquals(listOf("y", "dup", "z"), scoped.section.children.map { it.src })
+    assertEquals(1, scoped.tappedOffset)
   }
 
   @Test
-  fun `ungrouped items form their own run`() {
-    val children =
+  fun `flat index pins the exact copy within a section`() {
+    val playlist =
       listOf(
-        track(src = "a", groupTitle = "First"),
-        track(src = "b"),
-        track(src = "c"),
-        track(src = "d", groupTitle = "Second"),
+        section(
+          children = arrayOf(track(src = "a"), track(src = "b"), track(src = "a"), track(src = "c"))
+        )
       )
+    val scoped = SectionScope.scoped(playlist, "a", tappedIndex = 2)!!
+    assertEquals(2, scoped.tappedOffset)
+  }
 
-    val section = SectionScope.section(children, "b") as SectionScope.Section.Run
-    assertEquals(listOf("b", "c"), section.tracks.map { it.src })
+  @Test
+  fun `stale index falls back to the first identity match`() {
+    // The child at the stamped index no longer carries the tapped identity
+    // (the list shifted) — resolution ignores the index and pins nothing.
+    val scoped = SectionScope.scoped(sections, "dup", tappedIndex = 1)!!
+    assertEquals(listOf("dup", "x"), scoped.section.children.map { it.src })
+    assertNull(scoped.tappedOffset)
   }
 
   @Test
-  fun `identical titles in separate runs stay separate`() {
+  fun `out-of-range index is ignored`() {
+    val scoped = SectionScope.scoped(sections, "dup", tappedIndex = 99)!!
+    assertEquals(listOf("dup", "x"), scoped.section.children.map { it.src })
+    assertNull(scoped.tappedOffset)
+  }
+
+  @Test
+  fun `vanished identity returns null`() {
+    assertNull(SectionScope.scoped(sections, "gone"))
+  }
+
+  @Test
+  fun `locates a track by its id when it has one`() {
+    // Identity rule (ADR 0008): the id wins over the src, so a __trackId stamped
+    // from an id-bearing track must resolve — and its src must not.
     val children =
-      listOf(
-        track(src = "a", groupTitle = "Same"),
-        track(src = "x", groupTitle = "Other"),
-        track(src = "b", groupTitle = "Same"),
+      arrayOf(
+        track(id = "stable-a", src = "https://s/a.mp3"),
+        track(id = "stable-b", src = "https://s/b.mp3"),
       )
+    val scoped = SectionScope.scoped(listOf(section(children = children)), "stable-b")!!
+    assertEquals(listOf("stable-a", "stable-b"), scoped.section.children.map { it.id })
 
-    val section = SectionScope.section(children, "a") as SectionScope.Section.Run
-    assertEquals(listOf("a"), section.tracks.map { it.src })
+    // The src is shadowed by the id — it is not the track's identity.
+    assertNull(SectionScope.scoped(listOf(section(children = children)), "https://s/b.mp3"))
   }
 
+  // MARK: page shape helpers
+
   @Test
-  fun `finds the id inside an image row`() {
-    val items = arrayOf(imageRowItem("s1"), imageRowItem("s2"))
-    val row = track(title = "Most Played", src = null, imageRow = items)
-    val children = listOf(row, track(src = "a"))
+  fun `children sugar normalizes to one untitled section`() {
+    val page = resolvedTrack(children = arrayOf(track(src = "a"), track(src = "b")))
+    val sections = page.normalizedSections!!
+    assertEquals(1, sections.size)
+    assertNull(sections[0].title)
+    assertEquals(listOf("a", "b"), sections[0].children.map { it.src })
+  }
+
+  @Test
+  fun `sections win over children`() {
+    val page =
+      resolvedTrack(
+        sections = arrayOf(section(title = "S", children = arrayOf(track(src = "a")))),
+        children = arrayOf(track(src = "zzz")),
+      )
+    val sections = page.normalizedSections!!
+    assertEquals(1, sections.size)
+    assertEquals("S", sections[0].title)
+  }
 
-    val section = SectionScope.section(children, "s2") as SectionScope.Section.ImageRow
-    assertEquals(listOf("s1", "s2"), section.items.map { it.src })
+  @Test
+  fun `flattened children concatenate in section order`() {
+    val page =
+      resolvedTrack(
+        sections =
+          arrayOf(
+            section(title = "A", children = arrayOf(track(src = "a1"), track(src = "a2"))),
+            section(children = arrayOf(track(src = "b1"))),
+          )
+      )
+    assertEquals(listOf("a1", "a2", "b1"), page.flattenedChildren!!.map { it.src })
   }
 
   @Test
-  fun `unknown id returns null`() {
-    assertNull(SectionScope.section(listOf(track(src = "a")), "zz"))
+  fun `childless page has no sections`() {
+    assertNull(resolvedTrack().normalizedSections)
   }
 
-  // Pins the documented precedence: sections are located by src, and an id
-  // present in both an image row and the flat list resolves to the row.
+  // --- styleResolvedSections: the page->section fold (ADR 0011) ---
+
   @Test
-  fun `image row wins over a flat-list duplicate`() {
-    val row = track(title = "Row", src = null, imageRow = arrayOf(imageRowItem("dup")))
-    val children = listOf(row, track(src = "dup"), track(src = "b"))
+  fun `an unstyled section reaches the surface with the page's block folded in`() {
+    // The end-to-end wire for ResolvedTrack.style: without this fold, the
+    // page tier is a dead field — every existing unit test would stay green
+    // while a whole tier of ADR 0011 went dark in production.
+    val page =
+      resolvedTrack(
+        style =
+          sectionStyle(display = StyleDisplay.GRID, artworkRendering = null, gridWrap = false),
+        sections = arrayOf(section(children = arrayOf(track(src = "a")))),
+      )
 
-    val section = SectionScope.section(children, "dup") as SectionScope.Section.ImageRow
-    assertEquals(listOf("dup"), section.items.map { it.src })
+    val folded = page.styleResolvedSections()!!.single()
+    assertEquals(StyleDisplay.GRID, folded.style?.display)
+    assertEquals(false, folded.style?.gridWrap)
+    // The extras leg of this wire — folded section → per-item grid hint — is
+    // asserted in MediaExtrasBuilderTest (it needs Robolectric for Bundle).
   }
 
   @Test
-  fun `duplicate src across runs resolves to the earlier run`() {
-    val children =
-      listOf(
-        track(src = "dup", groupTitle = "First"),
-        track(src = "x", groupTitle = "Second"),
-        track(src = "dup", groupTitle = "Second"),
+  fun `a section's own block overrides the page's in the fold`() {
+    val page =
+      resolvedTrack(
+        style = sectionStyle(display = StyleDisplay.GRID, artworkRendering = null, gridWrap = null),
+        sections =
+          arrayOf(
+            section(
+              style =
+                sectionStyle(display = StyleDisplay.LIST, artworkRendering = null, gridWrap = null),
+              children = arrayOf(track(src = "a")),
+            )
+          ),
       )
 
-    val section = SectionScope.section(children, "dup") as SectionScope.Section.Run
-    assertEquals(listOf("dup"), section.tracks.map { it.src })
+    assertEquals(StyleDisplay.LIST, page.styleResolvedSections()!!.single().style?.display)
   }
 }