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

package/src/features/playback/controls.ts

@@ -58,8 +58,10 @@ export function seekTo(position: number): void {
 }
 
 /**
- * Jump to the live edge of the current track. No-op for non-live tracks; for
- * live, seeks to the window end (HLS) or reconnects (non-seekable streams).
+ * Jump to the live edge of the current track; no-op unless the track
+ * declares `live: true`. A stream with a seekable live window (HLS) seeks
+ * to the window's edge; a non-seekable stream (e.g. ICY radio) reconnects
+ * to rejoin live — an expired URL re-resolves through `media.resolve`.
  */
 export function seekToLiveEdge(): void {
   nativeBrowser.seekToLiveEdge()

package/src/features/playback/progress.ts

@@ -118,7 +118,8 @@ export function usePolledProgress(updateInterval = 1000): Progress {
     }
 
     const stop = () => {
-      clearTimeout(timer)
+      // Guarded: React Native types clearTimeout(handle: number) — no undefined.
+      if (timer !== undefined) clearTimeout(timer)
       timer = undefined
       unsubscribeState?.()
       unsubscribeState = undefined

package/src/features/playback/rate.ts

@@ -14,8 +14,15 @@ export function getRate(): number {
 
 /**
  * Sets the playback rate.
+ *
+ * The rate is a speed multiplier, not a transport control — it is independent
+ * of play/pause, and setting it while paused never starts playback. Use
+ * {@link play} / {@link pause} for that.
+ *
  * @param rate - The playback rate to change to, where 0.5 would be half speed,
- * 1 would be regular speed, 2 would be double speed etc.
+ * 1 would be regular speed, 2 would be double speed etc. Must be greater than
+ * zero; platforms disagree on what a non-positive rate does (iOS ignores it,
+ * Android throws, web stalls the element), so treat it as unsupported.
  */
 export function setRate(rate: number): void {
   nativeBrowser.setRate(rate)

package/src/features/playback/state.ts

@@ -18,9 +18,8 @@ import { useNativeUpdatedValue } from '../../utils/useNativeUpdatedValue'
  * - `'buffering'`: Indicates that the player is currently loading more data
  *   before it can continue playing or is ready to start playing.
  * - `'error'`: Indicates that playback of the current item failed. Call
- *   `AudioBrowser.getError()` to get more information on the type of error that
- *   occurred. Call `AudioBrowser.retry()` or `AudioBrowser.play()` to try to play
- *   the item again.
+ *   `getPlaybackError()` (or subscribe via `usePlaybackError()`) for the
+ *   error details. Call `retry()` or `play()` to try to play the item again.
  * - `'ended'`: Indicates that playback stopped due to the end of the queue
  *   being reached.
  */

package/src/features/playback/trackPlaybackTime.ts

@@ -9,7 +9,7 @@ export interface PlaybackElapsed {
   total: number
   /** Seconds played since the previous callback (≈ `period`). */
   sinceLast: number
-  /** The currently playing track (id / src / url / title …), if any. */
+  /** The currently playing track (id / src / path / title …), if any. */
   track?: Track
 }
 

package/src/features/player/options.ts

@@ -1,5 +1,7 @@
-import type { FavoriteConfig } from '../../types'
-import type { CarPlayNowPlayingButton } from '../../types/browser'
+import type {
+  CarPlayNowPlayingButton,
+  CarPlayPlayingIndicatorLocation
+} from '../../types/browser'
 import { nativeBrowser } from '../../native'
 import { NativeUpdatedValue } from '../../utils/NativeUpdatedValue'
 import { useNativeUpdatedValue } from '../../utils/useNativeUpdatedValue'
@@ -75,31 +77,22 @@ export interface PlayerCapabilities {
    *   Android Auto and the Android 13+ system media controls — and an
    *   (empty or filled) heart on playable browse rows.
    *
-   * `match` controls how the ids from `setFavorites` are
-   * compared against a track's `src` to decide its `favorited` state
-   * (see `FavoritesMatchMode`); `true` is shorthand for `'exact'`.
-   *
-   * - `false` / omitted: favoriting off everywhere.
-   * - `true`: on, with `'exact'` id matching.
-   * - `{ match }`: on, with the given match mode.
+   * The ids passed to `setFavorites` are matched exactly against a track's
+   * *identity* — its `id` when set, falling back to `src`. Store favorites as
+   * the same stable identifier you put in `Track.id` (or as the full `src`
+   * for tracks without an id).
    *
    * @example
    * ```ts
-   * // 'exact': a favorite id must equal the track's src.
-   * favorite: { match: 'exact' }
-   * setFavorites(['https://cdn.example.com/audio/track-42.mp3'])
-   * // → favorited when src === 'https://cdn.example.com/audio/track-42.mp3'
-   *
-   * // 'partial': a favorite id matches when it is a full path segment of src.
-   * favorite: { match: 'partial' }
+   * favorite: true
    * setFavorites(['track-42'])
-   * // → favorited when src is '/library/track-42' or '/stream/track-42?hq=1',
-   * //   but NOT '/library/track-420'
+   * // → favorited when track.id === 'track-42'
+   * //   (or, for id-less tracks, when track.src === 'track-42')
    * ```
    *
    * @default false
    */
-  favorite?: boolean | FavoriteConfig
+  favorite?: boolean
   /**
    * Enable shuffle mode toggle.
    * @default true
@@ -295,6 +288,13 @@ export interface IOSOptions {
    * @default []
    */
   carPlayNowPlayingButtons: CarPlayNowPlayingButton[]
+
+  /**
+   * Where the now-playing indicator draws on CarPlay list rows.
+   * See {@link CarPlayPlayingIndicatorLocation}.
+   * @default 'leading'
+   */
+  carPlayPlayingIndicatorLocation: CarPlayPlayingIndicatorLocation
 }
 
 export interface AndroidOptions {
@@ -391,6 +391,13 @@ export interface IOSUpdateOptions {
    * @default []
    */
   carPlayNowPlayingButtons?: CarPlayNowPlayingButton[]
+
+  /**
+   * Where the now-playing indicator draws on CarPlay list rows.
+   * See {@link CarPlayPlayingIndicatorLocation}.
+   * @default 'leading'
+   */
+  carPlayPlayingIndicatorLocation?: CarPlayPlayingIndicatorLocation
 }
 
 /**
@@ -401,6 +408,7 @@ export interface NitroIOSUpdateOptions {
   playbackRates?: number[]
   carPlayUpNextButton?: boolean
   carPlayNowPlayingButtons?: CarPlayNowPlayingButton[]
+  carPlayPlayingIndicatorLocation?: CarPlayPlayingIndicatorLocation
 }
 
 /**

package/src/features/player/setup.test.ts

@@ -74,14 +74,23 @@ describe('setupPlayer wire regrouping', () => {
     })
   })
 
-  it('moves ios playbackRates into the runtime options', async () => {
+  it('moves ios runtime fields into the runtime options', async () => {
     await setupPlayer({
-      ios: { category: 'playback', playbackRates: [0.5, 1, 2] }
+      ios: {
+        category: 'playback',
+        playbackRates: [0.5, 1, 2],
+        carPlayPlayingIndicatorLocation: 'trailing'
+      }
     })
 
     const sent = payload()
     expect(sent.ios).toEqual({ category: 'playback' })
-    expect(sent.options).toEqual({ ios: { playbackRates: [0.5, 1, 2] } })
+    expect(sent.options).toEqual({
+      ios: {
+        playbackRates: [0.5, 1, 2],
+        carPlayPlayingIndicatorLocation: 'trailing'
+      }
+    })
   })
 
   it('omits a platform bag that only carried runtime fields', async () => {

package/src/features/player/setup.ts

@@ -741,12 +741,14 @@ export async function setupPlayer(
     playbackRates,
     carPlayUpNextButton,
     carPlayNowPlayingButtons,
+    carPlayPlayingIndicatorLocation,
     ...iosSetup
   } = ios
   const iosUpdate = definedFields({
     playbackRates,
     carPlayUpNextButton,
-    carPlayNowPlayingButtons
+    carPlayNowPlayingButtons,
+    carPlayPlayingIndicatorLocation
   })
   validateIOSUpdateOptions(iosUpdate)
 

package/src/features/player/validateOptions.ts

@@ -7,6 +7,8 @@ const MAX_CARPLAY_NOW_PLAYING_BUTTONS = 5
  * Shared by `updateOptions` and `setupPlayer` (both can carry `ios` options).
  * Kept out of `options.ts`, which the barrel re-exports — see
  * public-surface.test.ts.
+ *
+ * @internal
  */
 export function validateIOSUpdateOptions(ios?: IOSUpdateOptions): void {
   const buttons = ios?.carPlayNowPlayingButtons

package/src/features/queue/activeTrack.ts

@@ -1,7 +1,8 @@
 import type { Track } from '../../types'
 import { nativeBrowser } from '../../native'
 import { NativeUpdatedValue } from '../../utils/NativeUpdatedValue'
-import { useNativeUpdatedValue } from '../../utils/useNativeUpdatedValue'
+import { useNativeValueRefreshedBy } from '../../utils/useNativeValueRefreshedBy'
+import { onFavoriteChanged } from '../favorites'
 
 /**
  * Event data for when the active track changes.
@@ -40,6 +41,12 @@ export function getActiveTrackIndex(): number | undefined {
 
 /**
  * Subscribes to active track change events.
+ *
+ * Fires on **transitions only** — selection, queue advance, skip. In-place
+ * metadata mutations of the active track (a favorite toggle) emit
+ * {@link onFavoriteChanged} instead; {@link useActiveTrack} subscribes to
+ * both, so UI bound through the hook still re-renders on a heart toggle.
+ *
  * @param callback - Called when the active track changes
  * @returns An emitter — subscribe with `addListener(callback)`, which returns a cleanup function
  */
@@ -50,10 +57,14 @@ export const onActiveTrackChanged =
 
 // MARK: - Hooks
 
+// Module-level so the hook's subscription identity is stable across renders.
+const activeTrackInvalidators = [onActiveTrackChanged, onFavoriteChanged]
+
 /**
- * Hook that returns the current active track and updates when it changes.
+ * Hook that returns the current active track, updating on transitions AND on
+ * in-place mutations of the active track (favorite toggles).
  * @returns The current active track or undefined
  */
 export function useActiveTrack(): Track | undefined {
-  return useNativeUpdatedValue(getActiveTrack, onActiveTrackChanged, 'track')
+  return useNativeValueRefreshedBy(getActiveTrack, activeTrackInvalidators)
 }

package/src/features/queue/queue.ts

@@ -1,7 +1,8 @@
 import type { Track } from '../../types'
 import { nativeBrowser } from '../../native'
 import { NativeUpdatedValue } from '../../utils/NativeUpdatedValue'
-import { useNativeUpdatedValue } from '../../utils/useNativeUpdatedValue'
+import { useNativeValueRefreshedBy } from '../../utils/useNativeValueRefreshedBy'
+import { onFavoriteChanged } from '../favorites'
 
 // MARK: - Types
 
@@ -165,7 +166,9 @@ export const onQueueEnded =
 
 /**
  * Subscribes to queue change events.
- * Called when tracks are added, removed, reordered, or when track metadata changes.
+ * Called when tracks are added, removed, or reordered. An in-place mutation of
+ * a queued track's metadata (a favorite toggle) emits `onFavoriteChanged`
+ * instead; {@link useQueue} subscribes to both.
  * @param callback - Called with the updated queue
  * @returns An emitter — subscribe with `addListener(callback)`, which returns a cleanup function
  */
@@ -175,10 +178,14 @@ export const onQueueChanged = NativeUpdatedValue.emitterize<Track[]>(
 
 // MARK: - Hooks
 
+// Module-level so the hook's subscription identity is stable across renders.
+const queueInvalidators = [onQueueChanged, onFavoriteChanged]
+
 /**
- * Hook that returns the current queue and updates when it changes.
+ * Hook that returns the current queue, updating on queue changes AND on
+ * in-place mutations of queued tracks (favorite toggles).
  * @returns The current queue
  */
 export function useQueue(): Track[] {
-  return useNativeUpdatedValue(getQueue, onQueueChanged)
+  return useNativeValueRefreshedBy(getQueue, queueInvalidators)
 }

package/src/nitro-stub-drift.test.ts

@@ -234,4 +234,44 @@ describe('NitroTypeStubs mirror the generated Nitro types', () => {
         drift.join('\n')
     ).toEqual([])
   })
+
+  it('declares struct members in the generated initializer order', () => {
+    // Name/type parity is not enough: the stub struct's memberwise init must
+    // accept the same ARGUMENT ORDER as the generated labelled init, or shared
+    // sources compile under `swift test` and fail in the app build with
+    // "argument 'x' must precede argument 'y'" (nitrogen flattens `extends`
+    // own-properties-first, which is easy to get backwards — SectionStyle did).
+    // A stub may omit members; the ones it declares must be a subsequence of
+    // the generated order.
+    const misordered: string[] = []
+
+    for (const [name, stub] of stubs) {
+      if (name in NOT_GENERATED || stub.kind !== 'struct') continue
+      const real = parseGenerated(name)
+      if (real == null || real.kind !== 'struct') continue
+
+      const realOrder = [...real.members.keys()]
+      const stubOrder = [...stub.members.keys()].filter((member) =>
+        real.members.has(member)
+      )
+      let cursor = -1
+      for (const member of stubOrder) {
+        const index = realOrder.indexOf(member)
+        if (index < cursor) {
+          misordered.push(
+            `${name}: stub declares [${stubOrder.join(', ')}], ` +
+              `generated init order is [${realOrder.join(', ')}]`
+          )
+          break
+        }
+        cursor = index
+      }
+    }
+
+    expect(
+      misordered,
+      `Stub struct members are out of order relative to the generated init:\n` +
+        misordered.join('\n')
+    ).toEqual([])
+  })
 })

package/src/public-surface.test.ts

@@ -104,4 +104,44 @@ describe('public surface', () => {
   it('does not re-export the raw Nitro object', () => {
     expect(exports.map((e) => e.name)).not.toContain('nativeBrowser')
   })
+
+  it('every public module is covered by the typedoc entry points', () => {
+    // The API reference documents entryPoints, not the export graph — a public
+    // module missing from website/typedoc.json ships undocumented.
+    const config = JSON.parse(
+      readFileSync(join(process.cwd(), 'website', 'typedoc.json'), 'utf8')
+    ) as { entryPoints: string[] }
+    const entries = config.entryPoints.map(
+      (glob) =>
+        new RegExp(
+          '^' +
+            glob
+              .replace(/^\.\.\/src\//, '')
+              .replace(/[.]/g, '\\.')
+              .replace(/\*/g, '[^/]+') +
+            '$'
+        )
+    )
+    const covered = (file: string): boolean => {
+      if (entries.some((e) => e.test(file))) return true
+      // A directory barrel entry (…/index.ts) documents what it re-exports.
+      const dir = file.split('/').slice(0, -1)
+      while (dir.length > 0) {
+        if (entries.some((e) => e.test([...dir, 'index.ts'].join('/'))))
+          return true
+        dir.pop()
+      }
+      return false
+    }
+    const uncovered = [...new Set(exports.map((e) => e.file))].filter(
+      (file) => !covered(file)
+    )
+    expect(
+      uncovered,
+      'Exported to consumers but absent from the API reference. Add each ' +
+        'module (or its directory barrel) to website/typedoc.json ' +
+        'entryPoints:\n' +
+        uncovered.join('\n')
+    ).toEqual([])
+  })
 })

package/src/specs/audio-browser.nitro.ts

@@ -229,9 +229,10 @@ export interface AudioBrowser extends HybridObject<{
   seekTo(position: number): void
   seekBy(offset: number): void
   /**
-   * Jump to the live edge of the current track. No-op for non-live tracks.
-   * Live with a seekable window (HLS): seeks to the window end. Live without a
-   * window (non-seekable, e.g. ICY): reconnects to rejoin live.
+   * Jump to the live edge of the current track; no-op unless the track
+   * declares `live: true`. A stream with a seekable live window (HLS) seeks
+   * to the window's edge; a non-seekable stream (e.g. ICY radio) reconnects
+   * to rejoin live — an expired URL re-resolves through `media.resolve`.
    */
   seekToLiveEdge(): void
   setVolume(level: number): void

package/src/style-resolution.test.ts

@@ -0,0 +1,210 @@
+import { readFileSync } from 'node:fs'
+import { join } from 'node:path'
+import { describe, expect, it } from 'vitest'
+
+/**
+ * Completeness guards for the style declaration block (ADR 0011) — the checks
+ * Nitro's `extends`-flattening took out of the type system, in two parts:
+ * every key must be *resolved* by each platform's `StyleResolver`, and every
+ * key must be *accounted for* by each platform's `InertStyleDiagnostic`.
+ *
+ * Part one — inheritance completeness.
+ *
+ * `SectionStyle extends TrackStyle` in the spec, but Nitro flattens `extends`
+ * into independent structs on every platform — so nothing in any type system
+ * forces a platform's `StyleResolver` to read a newly added style key. A key
+ * the resolver forgets is silently dead: declared by consumers, decoded on the
+ * wire, never rendered. This test is the compile-time check the flattening
+ * took away:
+ *
+ * - every `SectionStyle` key must appear in each platform's
+ *   `sectionStyle(section, page)` merge;
+ * - every inherited `TrackStyle` key must appear in each platform's
+ *   `trackStyle(track, section)` merge;
+ * - `display` is positional (the deny-list): the track merge must resolve it
+ *   to nil/null and must not read it from any level.
+ */
+
+const ROOT = process.cwd()
+
+const RESOLVERS = [
+  {
+    file: 'ios/Browser/StyleResolver.swift',
+    sectionMarker: 'static func sectionStyle',
+    trackMarker: 'static func trackStyle',
+    positionalNil: 'display: nil'
+  },
+  {
+    file: 'android/src/main/java/com/audiobrowser/browser/StyleResolver.kt',
+    sectionMarker: 'fun sectionStyle',
+    trackMarker: 'fun trackStyle',
+    positionalNil: 'display = null'
+  }
+]
+
+/** Keys the spec deliberately excludes from item inheritance. */
+const POSITIONAL = ['display']
+
+function interfaceKeys(source: string, name: string): string[] {
+  const start = source.indexOf(`export interface ${name} `)
+  expect(
+    start,
+    `interface ${name} not found in browser-nodes.ts`
+  ).toBeGreaterThan(-1)
+  const end = source.indexOf('\n}', start)
+  const body = source.slice(start, end)
+  return [...body.matchAll(/^ {2}(\w+)\??:/gm)].flatMap((match) =>
+    match[1] === undefined ? [] : [match[1]]
+  )
+}
+
+/**
+ * The function's text from `marker` to the next function declaration (or end
+ * of file) — brace-agnostic, since Kotlin expression bodies have no braces.
+ */
+function functionBody(source: string, marker: string, file: string): string {
+  const start = source.indexOf(marker)
+  expect(start, `${marker} not found in ${file}`).toBeGreaterThan(-1)
+  const rest = source.slice(start + marker.length)
+  const next = rest.search(/\n\s*(?:static func|func|fun)\s/)
+  return marker + (next === -1 ? rest : rest.slice(0, next))
+}
+
+/** Comment-free view, so prose about a key doesn't count as reading it. */
+function stripComments(code: string): string {
+  return code
+    .replace(/\/\*[\s\S]*?\*\//g, '')
+    .split('\n')
+    .map((line) => line.replace(/\/\/.*$/, ''))
+    .join('\n')
+}
+
+const nodes = readFileSync(
+  join(ROOT, 'src', 'types', 'browser-nodes.ts'),
+  'utf8'
+)
+const trackKeys = interfaceKeys(nodes, 'TrackStyle')
+const sectionKeys = [...trackKeys, ...interfaceKeys(nodes, 'SectionStyle')]
+const inheritedKeys = trackKeys.filter((key) => !POSITIONAL.includes(key))
+
+describe('style block shape', () => {
+  it('has the positional key and at least one inherited key', () => {
+    expect(trackKeys).toContain('display')
+    expect(inheritedKeys.length).toBeGreaterThan(0)
+  })
+})
+
+for (const resolver of RESOLVERS) {
+  describe(resolver.file, () => {
+    const source = readFileSync(join(ROOT, resolver.file), 'utf8')
+    const sectionBody = stripComments(
+      functionBody(source, resolver.sectionMarker, resolver.file)
+    )
+    const trackBody = stripComments(
+      functionBody(source, resolver.trackMarker, resolver.file)
+    )
+
+    // Containment of `holder?.key` for BOTH holders — `display =
+    // section?.display` with the page half dropped must fail — AND in
+    // precedence order: the narrower holder must be read first, or the
+    // scope-override/inheritance direction is inverted (`page ?? section`
+    // would pass a bare containment check).
+    it.each(sectionKeys)('sectionStyle merges %s (section ?? page)', (key) => {
+      const section = sectionBody.indexOf(`section?.${key}`)
+      const page = sectionBody.indexOf(`page?.${key}`)
+      expect(section, `section?.${key} not read`).toBeGreaterThan(-1)
+      expect(page, `page?.${key} not read`).toBeGreaterThan(-1)
+      expect(section, `section?.${key} must precede page?.${key}`).toBeLessThan(
+        page
+      )
+    })
+
+    it.each(inheritedKeys)(
+      'trackStyle inherits %s (track ?? section)',
+      (key) => {
+        const track = trackBody.indexOf(`track?.${key}`)
+        const section = trackBody.indexOf(`section?.${key}`)
+        expect(track, `track?.${key} not read`).toBeGreaterThan(-1)
+        expect(section, `section?.${key} not read`).toBeGreaterThan(-1)
+        expect(
+          track,
+          `track?.${key} must precede section?.${key}`
+        ).toBeLessThan(section)
+      }
+    )
+
+    it('trackStyle excludes the positional display (deny-list)', () => {
+      expect(trackBody).toContain(resolver.positionalNil)
+      // The nil assignment must be the ONLY mention: reading display from any
+      // level here would item-inherit a positional key.
+      const mentions = trackBody.match(/display/g) ?? []
+      expect(mentions).toHaveLength(1)
+    })
+  })
+}
+
+/**
+ * Part two — diagnostic completeness.
+ *
+ * The block model traded compile-time invalid-combination errors for
+ * inertness, and the dev-mode `InertStyleDiagnostic` is the recovery. It is
+ * exposed to the same flattening problem as the resolvers, one level up: a
+ * key added to the spec has no type-system tie to the diagnostic's rule set,
+ * so a property could ship whose inert combinations nobody is warned about.
+ *
+ * Each platform therefore dispositions the whole vocabulary — every key is a
+ * `Property` with an inertness rule, `alwaysRenderable`, or `positional` —
+ * and this test reads those three declarations and asserts set equality with
+ * the spec, both directions: a new key must be dispositioned, and a key
+ * deleted from the spec must not linger in the rule set.
+ */
+const DIAGNOSTICS = [
+  {
+    file: 'ios/Browser/InertStyleDiagnostic.swift',
+    // `case gridWrap`, up to the first member after the case list.
+    ruled: (source: string) =>
+      keysIn(
+        source,
+        /enum Property[\s\S]*?var isItemProperty/,
+        /^\s*case (\w+)$/gm
+      )
+  },
+  {
+    file: 'android/src/main/java/com/audiobrowser/browser/InertStyleDiagnostic.kt',
+    // `GRID_WRAP("gridWrap", …)`, up to the `;` that ends the entry list.
+    ruled: (source: string) =>
+      keysIn(source, /enum class Property[\s\S]*?;/, /\w+\("(\w+)"/g)
+  }
+]
+
+/** The capture group of every `pattern` match within the first `region`. */
+function keysIn(source: string, region: RegExp, pattern: RegExp): string[] {
+  const found = region.exec(source)
+  expect(found, `region ${region} not found`).not.toBeNull()
+  return [...found![0].matchAll(pattern)].flatMap((match) =>
+    match[1] === undefined ? [] : [match[1]]
+  )
+}
+
+for (const diagnostic of DIAGNOSTICS) {
+  describe(diagnostic.file, () => {
+    // Comment-free, so prose naming a key doesn't pass for dispositioning it.
+    const source = stripComments(
+      readFileSync(join(ROOT, diagnostic.file), 'utf8')
+    )
+    // The two lists are spelled `alwaysRenderable`/`positional` in Swift and
+    // SCREAMING_CASE in Kotlin; both hold bare string literals.
+    const listed = [
+      ...source.matchAll(
+        /(?:alwaysRenderable|ALWAYS_RENDERABLE|positional|POSITIONAL)\s*=[^\n]*/gi
+      )
+    ].flatMap((match) =>
+      [...match[0].matchAll(/"(\w+)"/g)].map((key) => key[1])
+    )
+
+    it('dispositions every key of the block, and only those', () => {
+      const dispositioned = [...diagnostic.ruled(source), ...listed]
+      expect(new Set(dispositioned)).toEqual(new Set(sectionKeys))
+    })
+  })
+}

package/src/types/browser-native.ts

@@ -9,7 +9,7 @@
 import type {
   ArtworkRequestConfig,
   BrowserSourceCallback,
-  ResolveAlbumUrlCallback,
+  ResolveAlbumPathCallback,
   FormatNavigationErrorCallback,
   HandleTrackLoadCallback,
   MediaRequestConfig,
@@ -76,6 +76,6 @@ export interface NativeBrowserConfiguration {
 
   // CarPlay options
   carPlayLoadingTitle?: string
-  resolveAlbumUrl?: ResolveAlbumUrlCallback
+  resolveAlbumPath?: ResolveAlbumPathCallback
   formatNavigationError?: FormatNavigationErrorCallback
 }