react-native-audio-browser 0.2.0-next.3 → 0.2.0-next.31

package/ios/Tests/BrowserPathHelperTests.swift

@@ -74,6 +74,56 @@ import Testing
   #expect(result == "/items?a=1&m=2&z=3")
 }
 
+// MARK: - build
+
+@Test func buildAppendsTrackIdWithQuestionMark() {
+  let result = BrowserPathHelper.build(parentPath: "/library", trackId: "song.mp3")
+  #expect(result == "/library?__trackId=song.mp3")
+}
+
+@Test func buildAppendsTrackIdWithAmpersandWhenParentHasQuery() {
+  let result = BrowserPathHelper.build(parentPath: "/search?q=jazz", trackId: "song.mp3")
+  #expect(result == "/search?q=jazz&__trackId=song.mp3")
+}
+
+@Test func buildRoundTripsSrcWithQueryParams() {
+  // A src carrying its own query string (signed CDN URL) must survive the
+  // build → extract/strip round-trip: an unescaped `&` splits the src into
+  // stray query params, truncating the trackId and polluting the parent path.
+  let src = "https://cdn.example.com/stream.mp3?token=abc&exp=1699999999"
+  let url = BrowserPathHelper.build(parentPath: "/library", trackId: src)
+  #expect(BrowserPathHelper.extractTrackId(url) == src)
+  #expect(BrowserPathHelper.stripTrackId(url) == "/library")
+}
+
+@Test func buildRoundTripsSrcWithEqualsAndPlus() {
+  let src = "https://cdn.example.com/a+b.mp3?sig=x=y"
+  let url = BrowserPathHelper.build(parentPath: "/library", trackId: src)
+  #expect(BrowserPathHelper.extractTrackId(url) == src)
+  #expect(BrowserPathHelper.stripTrackId(url) == "/library")
+}
+
+@Test func buildStampsTheIndexAndRoundTripsIt() {
+  let src = "https://cdn.example.com/stream.mp3?token=abc&exp=1"
+  let url = BrowserPathHelper.build(parentPath: "/library", trackId: src, index: 3)
+  #expect(BrowserPathHelper.extractTrackId(url) == src)
+  #expect(BrowserPathHelper.extractIndex(url) == 3)
+  #expect(BrowserPathHelper.stripTrackId(url) == "/library")
+}
+
+// MARK: - extractIndex
+
+@Test func extractIndexReturnsNilWithoutAStampedIndex() {
+  let url = BrowserPathHelper.build(parentPath: "/library", trackId: "song.mp3")
+  #expect(BrowserPathHelper.extractIndex(url) == nil)
+}
+
+@Test func extractIndexReturnsNilForNonContextualOrMalformedIndex() {
+  #expect(BrowserPathHelper.extractIndex("/library") == nil)
+  #expect(BrowserPathHelper.extractIndex("/library?__trackId=song.mp3&__index=x") == nil)
+  #expect(BrowserPathHelper.extractIndex("/library?__trackId=song.mp3&__index=-1") == nil)
+}
+
 // MARK: - stripTrackId
 
 @Test func stripTrackIdRemovesTrackParam() {
@@ -117,22 +167,13 @@ import Testing
   #expect(BrowserPathHelper.isContextual("/lib?q=1&__trackId=x") == true)
 }
 
-// MARK: - containsSegment
+// MARK: - isSearchPath
 
-@Test func containsSegmentMatchesFullSegments() {
-  let path = "/listen/amsterdam-funk-channel/Gw0LGB8j"
-  #expect(BrowserPathHelper.containsSegment(path, "Gw0LGB8j"))
-  #expect(BrowserPathHelper.containsSegment(path, "amsterdam-funk-channel"))
-  #expect(BrowserPathHelper.containsSegment(path, "listen"))
-  #expect(BrowserPathHelper.containsSegment("/listen/x/Gw0LGB8j?hl=en", "Gw0LGB8j"))
-  #expect(BrowserPathHelper.containsSegment("/listen/x/Gw0LGB8j#frag", "Gw0LGB8j"))
+@Test func isSearchPathMatchesCreatedSearchPaths() {
+  #expect(BrowserPathHelper.isSearchPath(BrowserPathHelper.createSearchPath("jazz")) == true)
 }
 
-@Test func containsSegmentRejectsPartialAndMissing() {
-  let path = "/listen/amsterdam-funk-channel/Gw0LGB8j"
-  #expect(!BrowserPathHelper.containsSegment(path, "Gw0LGB8"))
-  #expect(!BrowserPathHelper.containsSegment(path, "funk"))
-  #expect(!BrowserPathHelper.containsSegment(path, "msterdam-funk-channe"))
-  #expect(!BrowserPathHelper.containsSegment(path, "NopeNope"))
-  #expect(!BrowserPathHelper.containsSegment(path, ""))
+@Test func isSearchPathRejectsBrowsePaths() {
+  #expect(BrowserPathHelper.isSearchPath("/search?q=jazz") == false)
+  #expect(BrowserPathHelper.isSearchPath("/__searchable") == false)
 }

package/ios/Tests/CarPlayArtworkResolverTests.swift

@@ -2,412 +2,99 @@ import Testing
 
 @testable import AudioBrowserTestable
 
-// MARK: - SF Symbol Detection
-
-@Suite("SF symbol artwork")
-struct SFSymbolTests {
-  @Test func sfSymbolArtwork_returnsSfSymbolAction() async {
-    let action = await CarPlayArtworkResolver.resolve(
-      artwork: "sf:heart.fill",
-      artworkSourceUri: nil,
-      artworkCarPlayTinted: nil,
-      targetWidth: 40, targetHeight: 40,
-      displayScale: 2.0,
-      urlResolver: nil,
-    )
-    #expect(action == .sfSymbol(artwork: "sf:heart.fill", width: 40, height: 40))
-  }
-
-  @Test func sfSymbolWithParams_returnsSfSymbolAction() async {
-    let action = await CarPlayArtworkResolver.resolve(
-      artwork: "sf:play.circle?bg=#000&fg=#fff",
-      artworkSourceUri: nil,
-      artworkCarPlayTinted: nil,
-      targetWidth: 24, targetHeight: 24,
-      displayScale: 3.0,
-      urlResolver: nil,
-    )
-    #expect(action == .sfSymbol(artwork: "sf:play.circle?bg=#000&fg=#fff", width: 24, height: 24))
-  }
-
-  @Test func sfSymbolTakesPriorityOverUrlResolver() async {
-    var resolverCalled = false
-    let action = await CarPlayArtworkResolver.resolve(
-      artwork: "sf:music.note",
-      artworkSourceUri: nil,
-      artworkCarPlayTinted: nil,
-      targetWidth: 40, targetHeight: 40,
-      displayScale: 2.0,
-      urlResolver: { _, _ in
-        resolverCalled = true
-        return ArtworkResolvedImage(uri: "https://example.com/img.jpg", headers: nil)
-      },
-    )
-    #expect(action == .sfSymbol(artwork: "sf:music.note", width: 40, height: 40))
-    #expect(!resolverCalled)
-  }
-
-  @Test func sfSymbolInArtworkSource_usedAsFallback() async {
-    let action = await CarPlayArtworkResolver.resolve(
-      artwork: nil,
-      artworkSourceUri: "sf:star.fill",
-      artworkCarPlayTinted: nil,
-      targetWidth: 20, targetHeight: 20,
-      displayScale: 2.0,
-      urlResolver: nil,
-    )
-    #expect(action == .sfSymbol(artwork: "sf:star.fill", width: 20, height: 20))
-  }
-}
-
-// MARK: - No Artwork
-
-@Suite("no artwork")
-struct NoArtworkTests {
-  @Test func noArtworkOrSource_returnsNone() async {
-    let action = await CarPlayArtworkResolver.resolve(
-      artwork: nil,
-      artworkSourceUri: nil,
-      artworkCarPlayTinted: nil,
-      targetWidth: 40, targetHeight: 40,
-      displayScale: 2.0,
-      urlResolver: nil,
-    )
-    #expect(action == .none)
-  }
-
-  @Test func noArtworkOrSource_withResolver_returnsNone() async {
-    let action = await CarPlayArtworkResolver.resolve(
-      artwork: nil,
-      artworkSourceUri: nil,
-      artworkCarPlayTinted: nil,
-      targetWidth: 40, targetHeight: 40,
-      displayScale: 2.0,
-      urlResolver: { _, _ in nil },
-    )
-    #expect(action == .none)
-  }
-}
-
-// MARK: - URL Resolution
-
-@Suite("URL resolution")
-struct URLResolutionTests {
-  @Test func resolvedUrl_returnsFetchWithHeaders() async {
-    let action = await CarPlayArtworkResolver.resolve(
-      artwork: "https://example.com/art.jpg",
-      artworkSourceUri: nil,
-      artworkCarPlayTinted: false,
-      targetWidth: 40, targetHeight: 40,
-      displayScale: 2.0,
-      urlResolver: { pixelWidth, pixelHeight in
-        #expect(pixelWidth == 80)
-        #expect(pixelHeight == 80)
-        return ArtworkResolvedImage(
-          uri: "https://cdn.example.com/art_80x80.jpg",
-          headers: ["Authorization": "Bearer token"],
-        )
-      },
-    )
-    #expect(action == .fetch(
-      uri: "https://cdn.example.com/art_80x80.jpg",
-      headers: ["Authorization": "Bearer token"],
-      shouldTint: false,
-      isSvg: false,
-    ))
-  }
-
-  @Test func resolvedUrl_noHeaders_returnsFetchWithNilHeaders() async {
-    let action = await CarPlayArtworkResolver.resolve(
-      artwork: "https://example.com/art.jpg",
-      artworkSourceUri: nil,
-      artworkCarPlayTinted: nil,
-      targetWidth: 24, targetHeight: 24,
-      displayScale: 3.0,
-      urlResolver: { _, _ in
-        ArtworkResolvedImage(uri: "https://cdn.example.com/resized.jpg", headers: nil)
-      },
+@Suite("CarPlayArtworkResolver")
+struct CarPlayArtworkResolverTests {
+  private func action(
+    artwork: String? = nil,
+    artworkSource: ArtworkResolvedImage? = nil,
+    resolved: ArtworkResolvedImage? = nil,
+    stencil: Bool = false,
+  ) -> ArtworkLoadAction {
+    CarPlayArtworkResolver.action(
+      artwork: artwork, artworkSource: artworkSource, resolved: resolved, stencil: stencil, width: 40, height: 40,
     )
-    #expect(action == .fetch(
-      uri: "https://cdn.example.com/resized.jpg",
-      headers: nil,
-      shouldTint: false,
-      isSvg: false,
-    ))
   }
 
-  @Test func resolverReturnsNil_fallsBackToDirect() async {
-    let action = await CarPlayArtworkResolver.resolve(
-      artwork: "https://example.com/art.jpg",
-      artworkSourceUri: nil,
-      artworkCarPlayTinted: nil,
-      targetWidth: 40, targetHeight: 40,
-      displayScale: 2.0,
-      urlResolver: { _, _ in nil },
-    )
-    #expect(action == .fetch(
-      uri: "https://example.com/art.jpg",
-      headers: nil,
-      shouldTint: false,
-      isSvg: false,
-    ))
-  }
-
-  @Test func resolvedInvalidUrl_fallsBackToDirect() async {
-    let action = await CarPlayArtworkResolver.resolve(
-      artwork: "https://example.com/fallback.jpg",
-      artworkSourceUri: nil,
-      artworkCarPlayTinted: nil,
-      targetWidth: 40, targetHeight: 40,
-      displayScale: 2.0,
-      urlResolver: { _, _ in
-        // Return an invalid URI that URL(string:) would reject
-        ArtworkResolvedImage(uri: "", headers: nil)
-      },
-    )
-    // Should fall back to direct artwork URL
-    #expect(action == .fetch(
-      uri: "https://example.com/fallback.jpg",
-      headers: nil,
-      shouldTint: false,
-      isSvg: false,
-    ))
-  }
-
-  @Test func displayScale_appliedToPixelDimensions() async {
-    var receivedWidth: Double?
-    var receivedHeight: Double?
-    _ = await CarPlayArtworkResolver.resolve(
-      artwork: "https://example.com/art.jpg",
-      artworkSourceUri: nil,
-      artworkCarPlayTinted: nil,
-      targetWidth: 50, targetHeight: 30,
-      displayScale: 2.5,
-      urlResolver: { w, h in
-        receivedWidth = w
-        receivedHeight = h
-        return ArtworkResolvedImage(uri: "https://cdn.example.com/art.jpg", headers: nil)
-      },
-    )
-    #expect(receivedWidth == 125) // 50 * 2.5
-    #expect(receivedHeight == 75) // 30 * 2.5
+  private func image(_ uri: String, headers: [String: String]? = nil) -> ArtworkResolvedImage {
+    ArtworkResolvedImage(uri: uri, headers: headers)
   }
-}
-
-// MARK: - Direct Fallback
 
-@Suite("direct fallback")
-struct DirectFallbackTests {
-  @Test func noResolver_usesArtworkUrl() async {
-    let action = await CarPlayArtworkResolver.resolve(
-      artwork: "https://example.com/artwork.png",
-      artworkSourceUri: nil,
-      artworkCarPlayTinted: nil,
-      targetWidth: 40, targetHeight: 40,
-      displayScale: 2.0,
-      urlResolver: nil,
+  @Test func anSFSymbolRendersAndIsNotResolved() {
+    #expect(!CarPlayArtworkResolver.needsResolve(artwork: "sf:star.fill?fg=#fff"))
+    #expect(CarPlayArtworkResolver.needsResolve(artwork: "https://example.com/a.jpg"))
+    #expect(CarPlayArtworkResolver.needsResolve(artwork: nil))
+    #expect(
+      action(artwork: "sf:star.fill?fg=#fff", resolved: image("https://example.com/r.jpg"))
+        == .sfSymbol(artwork: "sf:star.fill?fg=#fff", width: 40, height: 40),
     )
-    #expect(action == .fetch(
-      uri: "https://example.com/artwork.png",
-      headers: nil,
-      shouldTint: false,
-      isSvg: false,
-    ))
   }
 
-  @Test func noArtwork_usesArtworkSourceUri() async {
-    let action = await CarPlayArtworkResolver.resolve(
-      artwork: nil,
-      artworkSourceUri: "https://example.com/source.jpg",
-      artworkCarPlayTinted: nil,
-      targetWidth: 40, targetHeight: 40,
-      displayScale: 2.0,
-      urlResolver: nil,
-    )
-    #expect(action == .fetch(
-      uri: "https://example.com/source.jpg",
-      headers: nil,
-      shouldTint: false,
-      isSvg: false,
-    ))
+  @Test func anSFSymbolArtworkSourceRendersAsTheFallback() {
+    #expect(action(artworkSource: image("sf:star.fill")) == .sfSymbol(artwork: "sf:star.fill", width: 40, height: 40))
   }
 
-  @Test func artworkPreferredOverArtworkSource() async {
-    let action = await CarPlayArtworkResolver.resolve(
-      artwork: "https://example.com/artwork.jpg",
-      artworkSourceUri: "https://example.com/source.jpg",
-      artworkCarPlayTinted: nil,
-      targetWidth: 40, targetHeight: 40,
-      displayScale: 2.0,
-      urlResolver: nil,
-    )
-    #expect(action == .fetch(
-      uri: "https://example.com/artwork.jpg",
-      headers: nil,
-      shouldTint: false,
-      isSvg: false,
-    ))
+  @Test func nothingToLoadIsNone() {
+    #expect(action() == .none)
   }
 
-  @Test func invalidDirectUrl_returnsNone() async {
-    let action = await CarPlayArtworkResolver.resolve(
-      artwork: "",
-      artworkSourceUri: nil,
-      artworkCarPlayTinted: nil,
-      targetWidth: 40, targetHeight: 40,
-      displayScale: 2.0,
-      urlResolver: nil,
+  @Test func theResolvedURLIsFetchedWithItsHeaders() {
+    #expect(
+      action(artwork: "https://example.com/a.jpg", resolved: image("https://cdn.example.com/r.jpg", headers: ["A": "1"]))
+        == .fetch(uri: "https://cdn.example.com/r.jpg", headers: ["A": "1"], shouldTint: false, isSvg: false),
     )
-    #expect(action == .none)
   }
-}
-
-// MARK: - SVG Detection
 
-@Suite("SVG detection")
-struct SVGDetectionTests {
-  @Test func svgExtension_setsIsSvgTrue() async {
-    let action = await CarPlayArtworkResolver.resolve(
-      artwork: "https://example.com/icon.svg",
-      artworkSourceUri: nil,
-      artworkCarPlayTinted: nil,
-      targetWidth: 40, targetHeight: 40,
-      displayScale: 2.0,
-      urlResolver: nil,
+  @Test func withoutAResolvedURLTheArtworkIsFetched() {
+    #expect(
+      action(artwork: "https://example.com/a.jpg")
+        == .fetch(uri: "https://example.com/a.jpg", headers: nil, shouldTint: false, isSvg: false),
     )
-    #expect(action == .fetch(
-      uri: "https://example.com/icon.svg",
-      headers: nil,
-      shouldTint: false,
-      isSvg: true,
-    ))
   }
 
-  @Test func svgUppercase_setsIsSvgTrue() async {
-    let action = await CarPlayArtworkResolver.resolve(
-      artwork: "https://example.com/icon.SVG",
-      artworkSourceUri: nil,
-      artworkCarPlayTinted: nil,
-      targetWidth: 40, targetHeight: 40,
-      displayScale: 2.0,
-      urlResolver: nil,
+  @Test func anInvalidResolvedURLFallsBackToTheArtwork() {
+    #expect(
+      action(artwork: "https://example.com/a.jpg", resolved: image(""))
+        == .fetch(uri: "https://example.com/a.jpg", headers: nil, shouldTint: false, isSvg: false),
     )
-    #expect(action == .fetch(
-      uri: "https://example.com/icon.SVG",
-      headers: nil,
-      shouldTint: false,
-      isSvg: true,
-    ))
   }
 
-  @Test func resolvedSvgUrl_setsIsSvgTrue() async {
-    let action = await CarPlayArtworkResolver.resolve(
-      artwork: "https://example.com/art.jpg",
-      artworkSourceUri: nil,
-      artworkCarPlayTinted: nil,
-      targetWidth: 40, targetHeight: 40,
-      displayScale: 2.0,
-      urlResolver: { _, _ in
-        ArtworkResolvedImage(uri: "https://cdn.example.com/icon.svg", headers: nil)
-      },
+  @Test func withoutArtworkTheArtworkSourceIsFetchedWithItsHeaders() {
+    #expect(
+      action(artworkSource: image("https://example.com/s.jpg", headers: ["Authorization": "Bearer t"]))
+        == .fetch(uri: "https://example.com/s.jpg", headers: ["Authorization": "Bearer t"], shouldTint: false, isSvg: false),
     )
-    #expect(action == .fetch(
-      uri: "https://cdn.example.com/icon.svg",
-      headers: nil,
-      shouldTint: false,
-      isSvg: true,
-    ))
   }
 
-  @Test func nonSvg_setsIsSvgFalse() async {
-    let action = await CarPlayArtworkResolver.resolve(
-      artwork: "https://example.com/photo.jpg",
-      artworkSourceUri: nil,
-      artworkCarPlayTinted: nil,
-      targetWidth: 40, targetHeight: 40,
-      displayScale: 2.0,
-      urlResolver: nil,
+  @Test func artworkWinsOverArtworkSourceWithoutItsHeaders() {
+    #expect(
+      action(
+        artwork: "https://example.com/a.jpg",
+        artworkSource: image("https://example.com/s.jpg", headers: ["Authorization": "Bearer t"]),
+      ) == .fetch(uri: "https://example.com/a.jpg", headers: nil, shouldTint: false, isSvg: false),
     )
-    #expect(action == .fetch(
-      uri: "https://example.com/photo.jpg",
-      headers: nil,
-      shouldTint: false,
-      isSvg: false,
-    ))
   }
-}
-
-// MARK: - Tinting
 
-@Suite("tinting")
-struct TintingTests {
-  @Test func artworkCarPlayTintedTrue_setsShouldTint() async {
-    let action = await CarPlayArtworkResolver.resolve(
-      artwork: "https://example.com/icon.png",
-      artworkSourceUri: nil,
-      artworkCarPlayTinted: true,
-      targetWidth: 40, targetHeight: 40,
-      displayScale: 2.0,
-      urlResolver: nil,
-    )
-    #expect(action == .fetch(
-      uri: "https://example.com/icon.png",
-      headers: nil,
-      shouldTint: true,
-      isSvg: false,
-    ))
+  @Test func anInvalidDirectURLIsNone() {
+    #expect(action(artwork: "") == .none)
   }
 
-  @Test func artworkCarPlayTintedFalse_doesNotTint() async {
-    let action = await CarPlayArtworkResolver.resolve(
-      artwork: "https://example.com/photo.jpg",
-      artworkSourceUri: nil,
-      artworkCarPlayTinted: false,
-      targetWidth: 40, targetHeight: 40,
-      displayScale: 2.0,
-      urlResolver: nil,
+  @Test func anSVGPathIsMarkedCaseInsensitively() {
+    #expect(action(artwork: "https://example.com/i.svg") == .fetch(uri: "https://example.com/i.svg", headers: nil, shouldTint: false, isSvg: true))
+    #expect(action(artwork: "https://example.com/i.SVG") == .fetch(uri: "https://example.com/i.SVG", headers: nil, shouldTint: false, isSvg: true))
+    #expect(
+      action(resolved: image("https://cdn.example.com/i.svg"))
+        == .fetch(uri: "https://cdn.example.com/i.svg", headers: nil, shouldTint: false, isSvg: true),
     )
-    #expect(action == .fetch(
-      uri: "https://example.com/photo.jpg",
-      headers: nil,
-      shouldTint: false,
-      isSvg: false,
-    ))
   }
 
-  @Test func artworkCarPlayTintedNil_defaultsToFalse() async {
-    let action = await CarPlayArtworkResolver.resolve(
-      artwork: "https://example.com/photo.jpg",
-      artworkSourceUri: nil,
-      artworkCarPlayTinted: nil,
-      targetWidth: 40, targetHeight: 40,
-      displayScale: 2.0,
-      urlResolver: nil,
+  @Test func aStencilTints() {
+    #expect(
+      action(artwork: "https://example.com/a.png", stencil: true)
+        == .fetch(uri: "https://example.com/a.png", headers: nil, shouldTint: true, isSvg: false),
     )
-    #expect(action == .fetch(
-      uri: "https://example.com/photo.jpg",
-      headers: nil,
-      shouldTint: false,
-      isSvg: false,
-    ))
-  }
-
-  @Test func tintingPreservedThroughResolver() async {
-    let action = await CarPlayArtworkResolver.resolve(
-      artwork: "https://example.com/icon.png",
-      artworkSourceUri: nil,
-      artworkCarPlayTinted: true,
-      targetWidth: 40, targetHeight: 40,
-      displayScale: 2.0,
-      urlResolver: { _, _ in
-        ArtworkResolvedImage(uri: "https://cdn.example.com/icon.png", headers: nil)
-      },
+    #expect(
+      action(resolved: image("https://cdn.example.com/r.png"), stencil: true)
+        == .fetch(uri: "https://cdn.example.com/r.png", headers: nil, shouldTint: true, isSvg: false),
     )
-    #expect(action == .fetch(
-      uri: "https://cdn.example.com/icon.png",
-      headers: nil,
-      shouldTint: true,
-      isSvg: false,
-    ))
   }
 }

package/ios/Tests/DeferredSeekTests.swift

@@ -0,0 +1,70 @@
+import Testing
+
+@testable import AudioBrowserTestable
+
+@Suite("DeferredSeek")
+struct DeferredSeekTests {
+  @Test func startsIdle() {
+    let seek = DeferredSeek()
+    #expect(seek.state == .idle)
+    #expect(seek.target == nil)
+    #expect(!seek.defersReady)
+  }
+
+  @Test func aCaptureDefersReadyUntilItLands() {
+    var seek = DeferredSeek()
+    seek.capture(30)
+    #expect(seek.defersReady)
+    #expect(seek.begin() == 30)
+    #expect(seek.state == .inFlight(30))
+    #expect(seek.defersReady)
+    #expect(seek.land() == .done)
+    #expect(seek.state == .idle)
+    #expect(!seek.defersReady)
+  }
+
+  @Test func theLatestCaptureWins() {
+    var seek = DeferredSeek()
+    seek.capture(10)
+    seek.capture(20)
+    #expect(seek.target == 20)
+  }
+
+  @Test func beginHandsOutOnlyAPendingTarget() {
+    var seek = DeferredSeek()
+    #expect(seek.begin() == nil)
+    seek.capture(15)
+    #expect(seek.begin() == 15)
+    #expect(seek.begin() == nil)
+    #expect(seek.target == 15)
+  }
+
+  /// A target captured while a seek is in flight is issued when that seek lands, and only its
+  /// own landing makes the load ready.
+  @Test func aCaptureInFlightIsReissuedOnLanding() {
+    var seek = DeferredSeek()
+    seek.capture(10)
+    _ = seek.begin()
+    seek.capture(50)
+    #expect(seek.state == .pending(50))
+    #expect(seek.land() == .reseek(50))
+    #expect(seek.state == .inFlight(50))
+    #expect(seek.land() == .done)
+  }
+
+  /// A seek issued while playing, not deferred, lands as nothing to do.
+  @Test func aLandingWithNothingInFlightIsNone() {
+    var seek = DeferredSeek()
+    #expect(seek.land() == .none)
+  }
+
+  @Test func resetDropsTheTargetAndInvalidatesSeeksInFlight() {
+    var seek = DeferredSeek()
+    seek.capture(10)
+    _ = seek.begin()
+    let issuedAgainst = seek.generation
+    seek.reset()
+    #expect(seek.state == .idle)
+    #expect(seek.generation != issuedAgainst)
+  }
+}

package/ios/Tests/EmitterTests.swift

@@ -120,3 +120,32 @@ struct ListenerCountTests {
     #expect(emitter.listenerCount == 0)
   }
 }
+
+// MARK: - subscribe
+
+@Suite("subscribe")
+struct SubscribeTests {
+  @Test func receivesUntilCancelled() {
+    let emitter = Emitter<Int>()
+    var received: [Int] = []
+    let subscription = emitter.subscribe { received.append($0) }
+    emitter.emit(1)
+    subscription.cancel()
+    emitter.emit(2)
+    #expect(received == [1])
+    #expect(emitter.listenerCount == 0)
+  }
+
+  @Test func releasingTheSubscriptionRemovesTheListener() {
+    let emitter = Emitter<Int>()
+    var received: [Int] = []
+    do {
+      let subscription = emitter.subscribe { received.append($0) }
+      emitter.emit(1)
+      _ = subscription
+    }
+    emitter.emit(2)
+    #expect(received == [1])
+    #expect(emitter.listenerCount == 0)
+  }
+}