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

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

@@ -1,19 +1,32 @@
 package com.audiobrowser.browser
 
+import com.audiobrowser.TestFixtures.imageRowItem
+import com.audiobrowser.TestFixtures.resolvedTrack
+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.expandQueueFromContextualUrl] 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-URL parsing) and
+ * `android.util.LruCache` (the content cache).
+ */
 @RunWith(RobolectricTestRunner::class)
 class BrowserManagerTest {
 
@@ -24,6 +37,22 @@ 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(url = path, children = arrayOf(*children)))),
+        singleTrack = singleTrack,
+      )
+  }
+
+  private fun contextual(path: String, trackId: String) = BrowserPathHelper.build(path, trackId)
+
   @Test
   fun `getPath returns default path initially`() {
     assertEquals("/", browserManager.getPath())
@@ -64,4 +93,134 @@ 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.children?.map { it.title })
+    // The tap target: a child's url is rewritten to point back at this page plus its own id.
+    assertEquals(
+      listOf(contextual("/library", "a"), contextual("/library", "b")),
+      resolved.children?.map { it.url },
+    )
+    assertEquals("/library", browserManager.getPath())
+  }
+
+  // MARK: - expandQueueFromContextualUrl
+
+  @Test
+  fun `expandQueueFromContextualUrl scopes the queue to the tapped section`() = runBlocking {
+    servePage(
+      "/home",
+      track(src = "a", groupTitle = "Recent"),
+      track(src = "b", groupTitle = "Recent"),
+      track(src = "c", groupTitle = "Popular"),
+      track(src = "d", groupTitle = "Popular"),
+    )
+
+    val expanded = browserManager.expandQueueFromContextualUrl(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 `expandQueueFromContextualUrl indexes the tapped track within its section`() = runBlocking {
+    servePage(
+      "/home",
+      track(src = "a", groupTitle = "Recent"),
+      track(src = "b", groupTitle = "Popular"),
+      track(src = "c", groupTitle = "Popular"),
+    )
+
+    val (queue, index) =
+      requireNotNull(browserManager.expandQueueFromContextualUrl(contextual("/home", "c")))
+
+    assertEquals(listOf("b", "c"), queue.map { it.src })
+    assertEquals(1, index)
+  }
+
+  @Test
+  fun `expandQueueFromContextualUrl returns null when the id has vanished from the page`() =
+    runBlocking {
+      // The stored url 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.expandQueueFromContextualUrl(contextual("/home", "gone")))
+    }
+
+  @Test
+  fun `expandQueueFromContextualUrl returns null for a non-contextual url`() = runBlocking {
+    servePage("/home", track(src = "a"))
+
+    assertNull(browserManager.expandQueueFromContextualUrl("/home"))
+  }
+
+  @Test
+  fun `expandQueueFromContextualUrl returns null when the page has no children`() = runBlocking {
+    browserManager.config =
+      BrowserConfig(routes = arrayOf(staticRoute("/home", resolvedTrack(url = "/home"))))
+
+    assertNull(browserManager.expandQueueFromContextualUrl(contextual("/home", "a")))
+  }
+
+  @Test
+  fun `expandQueueFromContextualUrl expands an image row into its items`() = runBlocking {
+    servePage(
+      "/home",
+      track(
+        title = "Most Played",
+        src = null,
+        imageRow = arrayOf(imageRowItem("r1"), imageRowItem("r2")),
+      ),
+      track(src = "a"),
+    )
+
+    val (queue, index) =
+      requireNotNull(browserManager.expandQueueFromContextualUrl(contextual("/home", "r2")))
+
+    // A tile tap queues its row, not the list rows beside it.
+    assertEquals(listOf("r1", "r2"), queue.map { it.src })
+    assertEquals(1, index)
+  }
+
+  @Test
+  fun `expandQueueFromContextualUrl drops unplayable siblings`() = runBlocking {
+    servePage(
+      "/home",
+      track(src = "a", groupTitle = "Mixed"),
+      // A browsable row sitting inside the same section — no src, so not queueable.
+      track(src = null, groupTitle = "Mixed").copy(url = "/sub"),
+      track(src = "b", groupTitle = "Mixed"),
+    )
+
+    val (queue, index) =
+      requireNotNull(browserManager.expandQueueFromContextualUrl(contextual("/home", "b")))
+
+    assertEquals(listOf("a", "b"), queue.map { it.src })
+    assertEquals(1, index)
+  }
+
+  @Test
+  fun `expandQueueFromContextualUrl honours singleTrack`() = runBlocking {
+    servePage(
+      "/home",
+      track(src = "a", groupTitle = "Recent"),
+      track(src = "b", groupTitle = "Recent"),
+      singleTrack = true,
+    )
+
+    val (queue, index) =
+      requireNotNull(browserManager.expandQueueFromContextualUrl(contextual("/home", "b")))
+
+    assertEquals(listOf("b"), queue.map { it.src })
+    assertEquals(0, index)
+  }
 }

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

@@ -10,7 +10,8 @@ class JsonArtworkTest {
 
   @Test
   fun `decodes a single url`() {
-    val track = json.decodeFromString<JsonTrack>("""{"title":"X","artwork":"https://e.example/a.png"}""")
+    val track =
+      json.decodeFromString<JsonTrack>("""{"title":"X","artwork":"https://e.example/a.png"}""")
     assertEquals(
       Variant_String_ArtworkVariants.First("https://e.example/a.png"),
       track.toNitro().artwork,

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

@@ -59,8 +59,7 @@ class SectionScopeTest {
     val row = track(title = "Most Played", src = null, imageRow = items)
     val children = listOf(row, track(src = "a"))
 
-    val section =
-      SectionScope.section(children, "s2") as SectionScope.Section.ImageRow
+    val section = SectionScope.section(children, "s2") as SectionScope.Section.ImageRow
     assertEquals(listOf("s1", "s2"), section.items.map { it.src })
   }
 
@@ -76,8 +75,7 @@ class SectionScopeTest {
     val row = track(title = "Row", src = null, imageRow = arrayOf(imageRowItem("dup")))
     val children = listOf(row, track(src = "dup"), track(src = "b"))
 
-    val section =
-      SectionScope.section(children, "dup") as SectionScope.Section.ImageRow
+    val section = SectionScope.section(children, "dup") as SectionScope.Section.ImageRow
     assertEquals(listOf("dup"), section.items.map { it.src })
   }
 

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

@@ -1,8 +1,8 @@
 package com.audiobrowser.player
 
-import com.margelo.nitro.audiobrowser.NotificationButton
-import com.margelo.nitro.audiobrowser.NotificationButtonLayout
 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
@@ -12,8 +12,7 @@ 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
- * [deriveNotificationSlots] (the single notification slot derivation that both the button layout
- * and the notification player commands consume).
+ * [deriveButtonSlots] (the single slot derivation every Media3 assembly consumes).
  */
 class CapabilityControlsTest {
 
@@ -43,117 +42,162 @@ class CapabilityControlsTest {
       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: NotificationButtonLayout? = null,
-  ): List<Pair<NotificationButton, NotificationSlot>> =
-    deriveNotificationSlots(capabilities, layout).map { it.button to it.slot }
+    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 Control.entries) {
-      assertEquals("$control", control != Control.FAVORITE, defaults.isEnabled(control))
+    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(Control.SKIP_TO_NEXT))
-    assertFalse(caps.isEnabled(Control.JUMP_BACKWARD))
-    assertTrue(caps.isEnabled(Control.SKIP_TO_PREVIOUS))
-    assertTrue(caps.isEnabled(Control.JUMP_FORWARD))
+    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(Control.PLAY_PAUSE))
-    assertTrue(capabilities(pause = false).isEnabled(Control.PLAY_PAUSE))
-    assertFalse(capabilities(play = false, pause = false).isEnabled(Control.PLAY_PAUSE))
+    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(Control.FAVORITE))
-    assertFalse(capabilities(favorite = false).isEnabled(Control.FAVORITE))
-    assertTrue(capabilities(favorite = true).isEnabled(Control.FAVORITE))
+    assertFalse(capabilities().isEnabled(Capability.FAVORITE))
+    assertFalse(capabilities(favorite = false).isEnabled(Capability.FAVORITE))
+    assertTrue(capabilities(favorite = true).isEnabled(Capability.FAVORITE))
   }
 
-  // MARK: deriveNotificationSlots — capability defaults
+  // MARK: deriveButtonSlots — capability defaults
 
   @Test
-  fun `default layout puts skip on the primary slots, jump on the secondary, favorite in overflow`() {
+  fun `default layout puts skip on the primary positions, jump and favorite in overflow`() {
     val derived = slots(capabilities(favorite = true))
     assertEquals(
       listOf(
-        NotificationButton.SKIP_TO_PREVIOUS to NotificationSlot.BACK,
-        NotificationButton.SKIP_TO_NEXT to NotificationSlot.FORWARD,
-        NotificationButton.JUMP_BACKWARD to NotificationSlot.BACK_SECONDARY,
-        NotificationButton.JUMP_FORWARD to NotificationSlot.FORWARD_SECONDARY,
-        NotificationButton.FAVORITE to NotificationSlot.OVERFLOW,
+        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 the primary slot when skip is disabled`() {
+  fun `jump falls back to a primary position when skip is disabled`() {
     val derived = slots(capabilities(skipToPrevious = false, skipToNext = false))
     assertEquals(
       listOf(
-        NotificationButton.JUMP_BACKWARD to NotificationSlot.BACK,
-        NotificationButton.JUMP_FORWARD to NotificationSlot.FORWARD,
+        RemoteButton.JUMP_BACKWARD to ButtonSlot.BACK,
+        RemoteButton.JUMP_FORWARD to ButtonSlot.FORWARD,
       ),
       derived,
     )
   }
 
   @Test
-  fun `a fully disabled side leaves its slot empty`() {
+  fun `a fully disabled side leaves its position empty`() {
     val derived =
       slots(capabilities(skipToPrevious = false, jumpBackward = false, jumpForward = false))
-    assertEquals(listOf(NotificationButton.SKIP_TO_NEXT to NotificationSlot.FORWARD), derived)
+    assertEquals(listOf(RemoteButton.SKIP_TO_NEXT to ButtonSlot.FORWARD), derived)
   }
 
-  // MARK: deriveNotificationSlots — explicit layout
+  // MARK: deriveButtonSlots — explicit layout
 
   @Test
-  fun `explicit layout maps every slot and keeps overflow order`() {
-    val layout =
-      NotificationButtonLayout(
-        back = NotificationButton.JUMP_BACKWARD,
-        forward = NotificationButton.JUMP_FORWARD,
-        backSecondary = null,
-        forwardSecondary = null,
-        overflow = arrayOf(NotificationButton.SKIP_TO_PREVIOUS, NotificationButton.SKIP_TO_NEXT),
+  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),
+        ),
       )
-    val derived = slots(capabilities(), layout)
     assertEquals(
       listOf(
-        NotificationButton.JUMP_BACKWARD to NotificationSlot.BACK,
-        NotificationButton.JUMP_FORWARD to NotificationSlot.FORWARD,
-        NotificationButton.SKIP_TO_PREVIOUS to NotificationSlot.OVERFLOW,
-        NotificationButton.SKIP_TO_NEXT to NotificationSlot.OVERFLOW,
+        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 `explicit layout entries are dropped when their capability is disabled`() {
-    val layout =
-      NotificationButtonLayout(
-        back = NotificationButton.SKIP_TO_PREVIOUS,
-        forward = NotificationButton.SKIP_TO_NEXT,
-        backSecondary = null,
-        forwardSecondary = null,
-        overflow = arrayOf(NotificationButton.FAVORITE),
+  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),
+        ),
       )
-    // favorite unset (= disabled), skipToPrevious explicitly off
-    val derived = slots(capabilities(skipToPrevious = false), layout)
-    assertEquals(listOf(NotificationButton.SKIP_TO_NEXT to NotificationSlot.FORWARD), derived)
+    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/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),
+      )
+    }
+  }
+}

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

@@ -132,8 +132,8 @@ class PlaybackErrorClassifierTest {
 
   /**
    * Load errors are raw IOExceptions from the transport layer; the policy only retries network
-   * ones, so the advisory classification is UNREACHABLE unless the device is offline or the
-   * server actually answered.
+   * ones, so the advisory classification is UNREACHABLE unless the device is offline or the server
+   * actually answered.
    */
   @Test
   fun `retrying transport failure is unreachable`() {
@@ -158,8 +158,7 @@ class PlaybackErrorClassifierTest {
   /** The HTTP status is dug out of the cause chain and mapped through the shared status table. */
   @Test
   fun `retrying HTTP failure carries the status`() {
-    val error =
-      PlaybackErrorClassifier.retryingLoadError(httpException(503), online = true)
+    val error = PlaybackErrorClassifier.retryingLoadError(httpException(503), online = true)
     assertEquals(PlaybackErrorKind.SERVER_ERROR, error.kind)
     assertEquals(503.0, error.statusCode!!, 0.0)
     assertEquals(true, error.retrying)

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

@@ -201,9 +201,9 @@ class RetryLoadErrorHandlingPolicyBudgetTest {
   }
 
   /**
-   * Offline failures must not burn the first-connect budget (a station tapped in a tunnel parks
-   * for connectivity); the budget's clock starts at the first error observed online, so a dead
-   * station still gets a fast verdict after restoration.
+   * Offline failures must not burn the first-connect budget (a station tapped in a tunnel parks for
+   * connectivity); the budget's clock starts at the first error observed online, so a dead station
+   * still gets a fast verdict after restoration.
    */
   @Test
   fun `offline time does not burn the first-connect budget`() {