react-native-audio-browser 0.2.0-next.9 → 0.2.0

package/ios/Tests/RetryManagerTests.swift

@@ -1,89 +0,0 @@
-import Foundation
-import Testing
-
-@testable import AudioBrowserTestable
-
-private final class MockNetworkStatus: NetworkStatusProviding, @unchecked Sendable {
-  var isOnline: Bool
-  init(isOnline: Bool) { self.isOnline = isOnline }
-}
-
-/// The two duration budgets: a never-played load gives up fast while online; a
-/// load that produced audio — or a device that is offline — keeps the full
-/// recovery budget. Timing-based: budgets are configured in single-digit
-/// milliseconds so one executed backoff (~1s) exhausts them.
-@Suite("RetryManager budgets")
-@MainActor
-struct RetryManagerBudgetTests {
-  /// Returns the mock too — `networkMonitor` is weak, the test must keep it alive.
-  private func makeManager(
-    firstConnectMs: Double,
-    maxMs: Double = 120_000,
-    online: Bool,
-  ) -> (RetryManager, MockNetworkStatus) {
-    let manager = RetryManager()
-    manager.updatePolicy(from: .second(RetryConfig(
-      maxRetries: nil,
-      maxRetryDurationMs: maxMs,
-      firstConnectMaxRetryDurationMs: firstConnectMs,
-    )))
-    let network = MockNetworkStatus(isOnline: online)
-    manager.networkMonitor = network
-    return (manager, network)
-  }
-
-  /// A dead-on-arrival stream: the first attempt runs, and the budget refuses
-  /// a later one. Budgets are checked before AND after each backoff wait, so
-  /// the test budget must exceed the first backoff (~1s) for attempt one to
-  /// execute, and be exceeded by the cumulative ~2.5s before attempt two ends.
-  /// 1800ms sits ~800ms clear of the first backoff (sleep overshoot on a loaded
-  /// machine only widens the passing margins, never shrinks them into failure).
-  @Test func neverPlayedLoad_givesUpAfterFirstConnectBudget() async {
-    let (manager, network) = makeManager(firstConnectMs: 1800, online: true)
-    _ = network
-
-    #expect(await manager.attemptRetry(startFromCurrentTime: false) == true)
-    #expect(await manager.attemptRetry(startFromCurrentTime: false) == false)
-  }
-
-  /// The same failure timeline on a load that has produced audio keeps
-  /// retrying: only the recovery budget applies.
-  @Test func playedLoad_ignoresTheFirstConnectBudget() async {
-    let (manager, network) = makeManager(firstConnectMs: 500, online: true)
-    _ = network
-    manager.hasPlayed = true
-
-    #expect(await manager.attemptRetry(startFromCurrentTime: false) == true)
-    #expect(await manager.attemptRetry(startFromCurrentTime: false) == true)
-  }
-
-  /// 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 failure observed online, so a dead station still gets a fast
-  /// verdict after restoration.
-  @Test func offlineTime_doesNotBurnTheFirstConnectBudget() async {
-    // 4s: well above the ~2.3s backoff of the first online attempt (the ladder
-    // kept climbing while offline), well below the ~5.6s cumulative after it.
-    let (manager, network) = makeManager(firstConnectMs: 4000, online: false)
-
-    // Offline: the short budget never engages, attempts keep running.
-    #expect(await manager.attemptRetry(startFromCurrentTime: false) == true)
-    #expect(await manager.attemptRetry(startFromCurrentTime: false) == true)
-
-    // Connectivity returns: the short clock starts now — one more attempt
-    // runs, then the budget is spent.
-    network.isOnline = true
-    #expect(await manager.attemptRetry(startFromCurrentTime: false) == true)
-    #expect(await manager.attemptRetry(startFromCurrentTime: false) == false)
-  }
-
-  /// `reset()` (track change / budget refill) restarts the clocks but must NOT
-  /// touch `hasPlayed` — the refill runs mid-play, and clearing the flag there
-  /// would hand a playing stream the short budget on its next drop.
-  @Test func reset_keepsHasPlayed() {
-    let manager = RetryManager()
-    manager.hasPlayed = true
-    manager.reset()
-    #expect(manager.hasPlayed == true)
-  }
-}

package/ios/Tests/SearchDrillInTests.swift

@@ -1,63 +0,0 @@
-import Testing
-
-@testable import AudioBrowserTestable
-
-private struct Item: PlayableSearchItem {
-  let src: String?
-  let url: String?
-}
-
-@Suite("SearchDrillIn.playable")
-struct SearchDrillInTests {
-  /// A resolver that fails the test if the drill-in path calls it.
-  private func unusedResolver(_ url: String) async throws -> [Item] {
-    Issue.record("resolveChildren should not have been called (url: \(url))")
-    return []
-  }
-
-  @Test func noResults_returnsNil() async throws {
-    let result = try await SearchDrillIn.playable(from: [Item](), resolveChildren: unusedResolver)
-    #expect(result == nil)
-  }
-
-  @Test func firstPlayable_returnsFlatPlayable_inOrder_withoutResolving() async throws {
-    let items = [
-      Item(src: "/a.mp3", url: nil),
-      Item(src: nil, url: "/page/x"), // browsable, filtered out
-      Item(src: "/b.mp3", url: nil),
-    ]
-    let result = try await SearchDrillIn.playable(from: items, resolveChildren: unusedResolver)
-    #expect(result?.compactMap(\.src) == ["/a.mp3", "/b.mp3"])
-  }
-
-  @Test func firstBrowsable_drillsIntoIt_andPlaysItsChildren() async throws {
-    let items = [
-      Item(src: nil, url: "/page/place"), // browsable first result
-      Item(src: "/later.mp3", url: nil), // would win without drill-in
-    ]
-    let result = try await SearchDrillIn.playable(from: items) { url in
-      #expect(url == "/page/place")
-      return [Item(src: "/station1.mp3", url: nil), Item(src: "/station2.mp3", url: nil)]
-    }
-    #expect(result?.compactMap(\.src) == ["/station1.mp3", "/station2.mp3"])
-  }
-
-  @Test func browsableDrillYieldsNothing_fallsBackToFlat() async throws {
-    let items = [
-      Item(src: nil, url: "/page/empty"),
-      Item(src: "/fallback.mp3", url: nil),
-    ]
-    let result = try await SearchDrillIn.playable(from: items) { _ in
-      [Item(src: nil, url: "/page/nested")] // nothing playable inside
-    }
-    #expect(result?.compactMap(\.src) == ["/fallback.mp3"])
-  }
-
-  @Test func nothingPlayableAnywhere_returnsNil() async throws {
-    let items = [Item(src: nil, url: "/page/a"), Item(src: nil, url: "/page/b")]
-    let result = try await SearchDrillIn.playable(from: items) { _ in
-      [Item(src: nil, url: "/page/nested")]
-    }
-    #expect(result == nil)
-  }
-}

package/ios/Tests/SectionScopeTests.swift

@@ -1,82 +0,0 @@
-@testable import AudioBrowserTestable
-import Testing
-
-struct SectionScopeTests {
-  private func track(_ src: String, group: String? = nil) -> Track {
-    Track(id: src, src: src, groupTitle: group)
-  }
-
-  private func runSrcs(_ section: SectionScope.Section?) -> [String?]? {
-    guard case let .run(tracks) = section else { return nil }
-    return tracks.map(\.src)
-  }
-
-  private func imageRowSrcs(_ section: SectionScope.Section?) -> [String?]? {
-    guard case let .imageRow(items) = section else { return nil }
-    return items.map(\.src)
-  }
-
-  @Test func scopesToTheContiguousGroupTitleRun() {
-    let children = [
-      track("a", group: "First"),
-      track("b", group: "First"),
-      track("c", group: "Second"),
-      track("d", group: "Second"),
-      track("e"),
-    ]
-    #expect(runSrcs(SectionScope.section(of: children, containing: "c")) == ["c", "d"])
-    #expect(runSrcs(SectionScope.section(of: children, containing: "a")) == ["a", "b"])
-  }
-
-  @Test func ungroupedItemsFormTheirOwnRun() {
-    let children = [
-      track("a", group: "First"),
-      track("b"),
-      track("c"),
-      track("d", group: "Second"),
-    ]
-    #expect(runSrcs(SectionScope.section(of: children, containing: "b")) == ["b", "c"])
-  }
-
-  @Test func identicalTitlesInSeparateRunsStaySeparate() {
-    let children = [
-      track("a", group: "Same"),
-      track("x", group: "Other"),
-      track("b", group: "Same"),
-    ]
-    #expect(runSrcs(SectionScope.section(of: children, containing: "a")) == ["a"])
-  }
-
-  @Test func findsTheIdInsideAnImageRow() {
-    let items = [
-      ImageRowItem(src: "s1", title: "One"),
-      ImageRowItem(src: "s2", title: "Two"),
-    ]
-    var row = Track(id: "row", title: "Most Played")
-    row.imageRow = items
-    let children = [row, track("a")]
-    #expect(imageRowSrcs(SectionScope.section(of: children, containing: "s2")) == ["s1", "s2"])
-  }
-
-  @Test func unknownIdReturnsNil() {
-    #expect(SectionScope.section(of: [track("a")], containing: "zz") == nil)
-  }
-
-  // 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.
-  @Test func imageRowWinsOverAFlatListDuplicate() {
-    var row = Track(id: "row", title: "Row")
-    row.imageRow = [ImageRowItem(src: "dup", title: "Dup")]
-    let children = [row, track("dup"), track("b")]
-    #expect(imageRowSrcs(SectionScope.section(of: children, containing: "dup")) == ["dup"])
-  }
-
-  @Test func duplicateSrcAcrossRunsResolvesToTheEarlierRun() {
-    let children = [
-      track("dup", group: "First"),
-      track("x", group: "Second"),
-      track("dup", group: "Second"),
-    ]
-    #expect(runSrcs(SectionScope.section(of: children, containing: "dup")) == ["dup"])
-  }
-}

package/ios/Tests/SleepTimerManagerTests.swift

@@ -1,107 +0,0 @@
-@testable import AudioBrowserTestable
-import Foundation
-import Testing
-
-// Timing tests drive a ManualSleepTimerScheduler rather than the main queue:
-// every deadline below is virtual, so nothing races the real clock.
-
-@Suite("SleepTimerManager - fade scheduling")
-struct SleepTimerManagerTests {
-  @Test @MainActor
-  func fadeFiresBeforeDeadline_completionDoesNotEmitFadeCancel() {
-    let clock = ManualSleepTimerScheduler()
-    let manager = SleepTimerManager(scheduler: clock)
-    var fadeStarts: [TimeInterval] = []
-    var completes = 0
-    var cancels = 0
-    manager.onFadeStart = { fadeStarts.append($0) }
-    manager.onComplete = { completes += 1 }
-    manager.set(seconds: 0.3, fadeDuration: 0.15)
-    // Attach after set() — replacing a timer emits a defensive onFadeCancel.
-    manager.onFadeCancel = { cancels += 1 }
-
-    clock.advance(to: 0.05) // before the fade window
-    #expect(fadeStarts.isEmpty)
-    #expect(manager.get() != nil)
-
-    clock.advance(to: 0.22) // inside the fade window
-    #expect(fadeStarts == [0.15])
-    #expect(completes == 0)
-
-    clock.advance(to: 0.4) // past the deadline
-    #expect(completes == 1)
-    #expect(cancels == 0)
-    #expect(manager.get() == nil)
-  }
-
-  @Test @MainActor
-  func fadeLongerThanTimer_clampsAndStartsImmediately() {
-    let clock = ManualSleepTimerScheduler()
-    let manager = SleepTimerManager(scheduler: clock)
-    var fadeStarts: [TimeInterval] = []
-    manager.onFadeStart = { fadeStarts.append($0) }
-
-    manager.set(seconds: 0.2, fadeDuration: 5)
-
-    clock.advance(to: 0.1) // fade should have begun
-    #expect(fadeStarts == [0.2])
-  }
-
-  @Test @MainActor
-  func clear_emitsFadeCancel_andCancelsScheduledFade() {
-    let clock = ManualSleepTimerScheduler()
-    let manager = SleepTimerManager(scheduler: clock)
-    var fadeStarts = 0
-    manager.set(seconds: 0.2, fadeDuration: 0.15)
-    var cancels = 0
-    manager.onFadeStart = { _ in fadeStarts += 1 }
-    manager.onFadeCancel = { cancels += 1 }
-
-    #expect(manager.clear())
-    #expect(cancels == 1)
-
-    clock.advance(to: 0.3) // well past the would-be deadline
-    #expect(fadeStarts == 0)
-  }
-
-  @Test @MainActor
-  func replacingTimer_emitsFadeCancel() {
-    let manager = SleepTimerManager(scheduler: ManualSleepTimerScheduler())
-    manager.set(seconds: 60, fadeDuration: 10)
-    var cancels = 0
-    manager.onFadeCancel = { cancels += 1 }
-
-    manager.set(seconds: 30)
-
-    #expect(cancels == 1)
-  }
-
-  @Test @MainActor
-  func switchingToEndOfTrack_emitsFadeCancel() {
-    let manager = SleepTimerManager(scheduler: ManualSleepTimerScheduler())
-    manager.set(seconds: 60, fadeDuration: 10)
-    var cancels = 0
-    manager.onFadeCancel = { cancels += 1 }
-
-    manager.setToEndOfTrack()
-
-    #expect(cancels == 1)
-    #expect(manager.get() == .third(SleepTimerEndOfTrack(sleepWhenPlayedToEnd: true)))
-  }
-
-  @Test @MainActor
-  func noFadeDuration_schedulesNoFade() {
-    let clock = ManualSleepTimerScheduler()
-    let manager = SleepTimerManager(scheduler: clock)
-    var fadeStarts = 0
-    var completes = 0
-    manager.onFadeStart = { _ in fadeStarts += 1 }
-    manager.onComplete = { completes += 1 }
-
-    manager.set(seconds: 0.1)
-
-    clock.advance(to: 0.2)
-    #expect(fadeStarts == 0)
-    #expect(completes == 1)
-  }
-}

package/ios/Tests/Support/ManualSleepTimerScheduler.swift

@@ -1,47 +0,0 @@
-@testable import AudioBrowserTestable
-import Foundation
-
-/// A job handed back by `ManualSleepTimerScheduler`.
-private final class ManualJob: SleepTimerJob {
-  nonisolated(unsafe) var isCancelled = false
-  func cancel() { isCancelled = true }
-}
-
-/// Deterministic stand-in for the main-queue scheduler: jobs fire only when the
-/// test advances the clock, so an assertion can never lose a race against a
-/// real deadline on a loaded CI runner.
-@MainActor
-final class ManualSleepTimerScheduler: SleepTimerScheduling {
-  private struct Entry {
-    let deadline: TimeInterval
-    let job: ManualJob
-    let work: @MainActor () -> Void
-  }
-
-  private var entries: [Entry] = []
-  private(set) var now: TimeInterval = 0
-
-  func schedule(
-    after delay: TimeInterval,
-    _ work: @escaping @Sendable @MainActor () -> Void,
-  ) -> any SleepTimerJob {
-    let job = ManualJob()
-    entries.append(Entry(deadline: now + delay, job: job, work: work))
-    return job
-  }
-
-  /// Moves the virtual clock to `time`, firing every due job in deadline order.
-  /// Jobs run one at a time so a job that schedules or cancels another (the
-  /// fade landing before completion) sees the same ordering it would in
-  /// production.
-  func advance(to time: TimeInterval) {
-    now = time
-    while let next = entries
-      .filter({ !$0.job.isCancelled && $0.deadline <= now })
-      .min(by: { $0.deadline < $1.deadline })
-    {
-      entries.removeAll { $0.job === next.job }
-      next.work()
-    }
-  }
-}

package/ios/Tests/TabBarEntriesTests.swift

@@ -1,71 +0,0 @@
-import Testing
-
-@testable import AudioBrowserTestable
-
-struct TabBarEntriesTests {
-  private func tab(
-    _ title: String, url: String, artwork: String? = nil,
-    artworkSource: ImageSource? = nil, artist: String? = nil,
-  ) -> Track {
-    Track(
-      id: url, url: url, title: title, artist: artist, artwork: artwork.map { .first($0) },
-      artworkSource: artworkSource,
-    )
-  }
-
-  @Test func identicalListsAreSame() {
-    let tabs = [tab("Explore", url: "/explore"), tab("Browse", url: "/browse")]
-    #expect(TabBarEntries.same(tabs, tabs))
-  }
-
-  @Test func titleChangeDiffers() {
-    #expect(
-      !TabBarEntries.same(
-        [tab("Explore", url: "/explore")],
-        [tab("Verkennen", url: "/explore")],
-      ))
-  }
-
-  @Test func urlChangeDiffers() {
-    #expect(
-      !TabBarEntries.same(
-        [tab("Explore", url: "/explore")],
-        [tab("Explore", url: "/discover")],
-      ))
-  }
-
-  @Test func artworkChangeDiffers() {
-    #expect(
-      !TabBarEntries.same(
-        [tab("Explore", url: "/explore", artwork: "sf:globe")],
-        [tab("Explore", url: "/explore", artwork: "sf:map")],
-      ))
-  }
-
-  @Test func artworkSourceUriChangeDiffers() {
-    #expect(
-      !TabBarEntries.same(
-        [tab("Explore", url: "/explore", artworkSource: ImageSource(uri: "https://a/1.png"))],
-        [tab("Explore", url: "/explore", artworkSource: ImageSource(uri: "https://a/2.png"))],
-      ))
-  }
-
-  @Test func countChangeDiffers() {
-    let tabs = [tab("Explore", url: "/explore")]
-    #expect(!TabBarEntries.same(tabs, tabs + [tab("Browse", url: "/browse")]))
-  }
-
-  @Test func nilOldDiffers() {
-    #expect(!TabBarEntries.same(nil, [tab("Explore", url: "/explore")]))
-  }
-
-  @Test func nonRenderedFieldChangeIsSame() {
-    // Only fields the tab bar renders are compared; other track fields may
-    // drift without churning the tab bar.
-    #expect(
-      TabBarEntries.same(
-        [tab("Explore", url: "/explore", artist: "a")],
-        [tab("Explore", url: "/explore", artist: "b")],
-      ))
-  }
-}

package/lib/commonjs/features/browser-config.js

@@ -1,227 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.SEARCH_ROUTE_PATH = void 0;
-exports.toNativeConfig = toNativeConfig;
-exports.validateBrowserConfiguration = validateBrowserConfiguration;
-// ─────────────────────────────────────────────────────────────────────────────
-// Configuration Transformation
-//
-// Lowers the public BrowserConfiguration into the flattened native shape.
-// Deliberately NOT re-exported from features/index.ts — these helpers are
-// internal (and unit-tested directly), not public API.
-// ─────────────────────────────────────────────────────────────────────────────
-
-function isCallback(source) {
-  return typeof source === 'function';
-}
-function isObjectValue(value) {
-  return typeof value === 'object' && value !== null;
-}
-function isTransformableRequestConfig(source) {
-  if (!isObjectValue(source)) return false;
-  // Any RequestConfig key marks a request config. A static ResolvedTrack
-  // shares none of these at the top level (its per-track request override is
-  // nested under `request`).
-  return 'baseUrl' in source || 'path' in source || 'headers' in source || 'query' in source || 'method' in source || 'body' in source || 'contentType' in source || 'userAgent' in source || 'transform' in source || 'transformSync' in source;
-}
-function isRouteConfig(source) {
-  if (!isObjectValue(source)) return false;
-  // `browse`/`media` keys only exist on RouteConfig. `artwork` also exists on
-  // a static ResolvedTrack — but there it is a string URL, while RouteConfig's
-  // is a config object, so only an object-valued `artwork` marks a RouteConfig.
-  return 'browse' in source || 'media' in source || isObjectValue(source.artwork);
-}
-function splitLayer(layer) {
-  if (!layer) return {};
-  // A function is a resolver thunk; an object is a static layer config. (The
-  // `request`/`browse` layer fields are object-only today, so this is
-  // unambiguous — unlike route/search sources which already accept a callback.)
-  if (isCallback(layer)) {
-    const resolve = layer;
-    // Normalize the sync-or-async resolver to Promise-only for the bridge so it
-    // never sees a `T | Promise<T>` variant (which misreads the async case).
-    // Resolvers run once per content generation, so the wrap costs nothing.
-    return {
-      resolver: () => Promise.resolve(resolve())
-    };
-  }
-  return {
-    config: layer
-  };
-}
-function flattenBrowseSource(source) {
-  if (!source) return {};
-  if (isCallback(source)) return {
-    browseCallback: source
-  };
-  if (isTransformableRequestConfig(source)) return {
-    browseConfig: source
-  };
-  return {
-    browseStatic: source
-  };
-}
-
-/**
- * Converts a SearchSource to a NativeRouteEntry for the __search__ path.
- */
-function searchSourceToRouteEntry(source) {
-  if (isCallback(source)) {
-    return {
-      path: SEARCH_ROUTE_PATH,
-      searchCallback: source
-    };
-  }
-  return {
-    path: SEARCH_ROUTE_PATH,
-    searchConfig: source
-  };
-}
-
-/**
- * Wraps a Track[] into a ResolvedTrack for tabs.
- * Tabs are represented as a special route that returns children.
- */
-function wrapTracksAsResolvedTrack(tracks) {
-  return {
-    url: TABS_ROUTE_PATH,
-    title: 'Tabs',
-    children: tracks
-  };
-}
-
-/**
- * Converts a TabsSource to a NativeRouteEntry for the __tabs__ path.
- * Track[] is wrapped in ResolvedTrack, callbacks are wrapped to return ResolvedTrack.
- */
-function tabsSourceToRouteEntry(source) {
-  if (Array.isArray(source)) {
-    // Static Track[] - wrap as ResolvedTrack
-    return {
-      path: TABS_ROUTE_PATH,
-      browseStatic: wrapTracksAsResolvedTrack(source)
-    };
-  }
-  if (isCallback(source)) {
-    // Callback returning Track[] - wrap to return ResolvedTrack
-    const wrappedCallback = async () => {
-      const tracks = await source();
-      return wrapTracksAsResolvedTrack(tracks);
-    };
-    return {
-      path: TABS_ROUTE_PATH,
-      browseCallback: wrappedCallback
-    };
-  }
-
-  // TransformableRequestConfig — the endpoint returns a page object whose
-  // children are the tabs (same shape as a browse endpoint).
-  return {
-    path: TABS_ROUTE_PATH,
-    browseConfig: source
-  };
-}
-function flattenRouteEntry(path, source) {
-  if (isRouteConfig(source)) {
-    return {
-      path,
-      ...flattenBrowseSource(source.browse),
-      media: source.media,
-      artwork: source.artwork
-    };
-  }
-  return {
-    path,
-    ...flattenBrowseSource(source)
-  };
-}
-
-/** Internal path used for the default/root browse source */
-const DEFAULT_ROUTE_PATH = '__default__';
-
-/** Internal path used for navigation tabs */
-const TABS_ROUTE_PATH = '__tabs__';
-
-// Exported for hasSearch() in browser.ts, which inspects the lowered config.
-// DEFAULT_ROUTE_PATH and TABS_ROUTE_PATH are not needed outside this module.
-const SEARCH_ROUTE_PATH = exports.SEARCH_ROUTE_PATH = '__search__';
-function flattenRoutes(routes, tabs, search) {
-  const entries = [];
-
-  // Add explicit routes. The '*' key is the optional custom default — it maps to
-  // the __default__ entry (used when no other route matches). Without it, an
-  // unmatched browse path is fetched via request + browse config applied to the
-  // path (handled natively), so no __default__ entry is needed.
-  if (routes) {
-    for (const [path, source] of Object.entries(routes)) {
-      entries.push(flattenRouteEntry(path === '*' ? DEFAULT_ROUTE_PATH : path, source));
-    }
-  }
-
-  // Add tabs as special route
-  if (tabs) {
-    entries.push(tabsSourceToRouteEntry(tabs));
-  }
-
-  // Add search as special route
-  if (search) {
-    entries.push(searchSourceToRouteEntry(search));
-  }
-  return entries.length > 0 ? entries : undefined;
-}
-
-/** Android Auto / CarPlay display at most this many tabs. */
-const MAX_TABS = 4;
-
-/**
- * Dev-only sanity checks for a BrowserConfiguration. Warns (never throws) on
- * mistakes the type system cannot catch: reserved route keys, route values
- * that match no source shape (and would be served as garbage static content),
- * and platform display limits. Called by configureBrowser under __DEV__.
- */
-function validateBrowserConfiguration(config) {
-  const warn = message => console.warn(`[react-native-audio-browser] configureBrowser: ${message}`);
-  if (config.routes) {
-    for (const [path, source] of Object.entries(config.routes)) {
-      if (path !== '*' && path.startsWith('__')) {
-        warn(`route "${path}" uses the reserved "__" prefix and will conflict ` + `with internal routing entries. Rename the route.`);
-        continue;
-      }
-      if (!isCallback(source) && !isRouteConfig(source) && !isTransformableRequestConfig(source)) {
-        // Falls through to the static-page branch; a page needs url + title.
-        const page = source;
-        if (typeof page.url !== 'string' || typeof page.title !== 'string') {
-          warn(`route "${path}" matched no source shape — expected a callback, ` + `a request config ({ baseUrl, path, headers, ... }), a ` + `RouteConfig ({ browse, media, artwork }), or a static page ` + `({ url, title, children? }). It will be served as static ` + `content and likely render a blank screen.`);
-        }
-      }
-    }
-  }
-  if (Array.isArray(config.tabs) && config.tabs.length > MAX_TABS) {
-    warn(`${config.tabs.length} tabs configured; Android Auto and CarPlay ` + `display at most ${MAX_TABS} — extra tabs will not be shown.`);
-  }
-}
-function toNativeConfig(config) {
-  const request = splitLayer(config.request);
-  const browse = splitLayer(config.browse);
-  return {
-    path: config.path,
-    request: request.config,
-    requestResolver: request.resolver,
-    browse: browse.config,
-    browseResolver: browse.resolver,
-    media: config.media,
-    artwork: config.artwork,
-    nowPlayingArtwork: config.nowPlayingArtwork,
-    routes: flattenRoutes(config.routes, config.tabs, config.search),
-    singleTrack: config.singleTrack,
-    handleTrackLoad: config.handleTrackLoad,
-    androidControllerOfflineError: config.androidControllerOfflineError,
-    carPlayLoadingTitle: config.carPlayLoadingTitle,
-    resolveAlbumUrl: config.resolveAlbumUrl,
-    formatNavigationError: config.formatNavigationError
-  };
-}
-//# sourceMappingURL=browser-config.js.map