react-native-audio-browser 0.2.0-next.10 → 0.2.0-next.12

package/ios/CarPlay/CarPlayController.swift

@@ -89,21 +89,24 @@ public final class RNABCarPlayController: NSObject {
     audioBrowser?.browserManager.config ?? BrowserConfig()
   }
 
+  /// The configured list playing-indicator location, in CarPlay-framework terms.
+  private var playingIndicatorLocation: CPListItemPlayingIndicatorLocation {
+    switch audioBrowser?.carPlayPlayingIndicatorLocation {
+    case .trailing: .trailing
+    case .leading, nil: .leading
+    }
+  }
+
   /// Whether a list item identifies the currently active (loaded) track.
   ///
-  /// Identity is the stable `Track.id` when both sides carry one — the active
+  /// Compares track identities (`id` when non-blank, else `src`): the active
   /// track may have been loaded outside the browse tree (the consumer's own
   /// `load`/`setQueue`) with a `src` that differs textually from the browse
   /// row's (absolute vs relative, extra query params) while being the same
-  /// item. Exact `src` equality remains the fallback for consumers that don't
-  /// assign ids.
-  private func isActiveTrack(id: String?, src: String?) -> Bool {
-    guard let currentTrack = audioBrowser?.getPlayer()?.currentTrack else { return false }
-    if let id, !id.isEmpty, let currentId = currentTrack.id, !currentId.isEmpty {
-      return id == currentId
-    }
-    guard let src else { return false }
-    return currentTrack.src == src
+  /// item. A nil identity on either side never matches.
+  private func isActiveTrack(identity: String?) -> Bool {
+    guard let identity, let currentTrack = audioBrowser?.getPlayer()?.currentTrack else { return false }
+    return currentTrack.identity == identity
   }
 
   // MARK: - Initialization
@@ -118,8 +121,8 @@ public final class RNABCarPlayController: NSObject {
       self?.listItemFactory?.createListItem(for: track, handler: handler)
         ?? CPListItem(text: track.title, detailText: nil)
     }
-    nowPlayingManager.navigateToUrl = { [weak self] url, title in
-      Task { @MainActor in await self?.navigateToUrl(url, title: title) }
+    nowPlayingManager.navigateToPath = { [weak self] path, title in
+      Task { @MainActor in await self?.navigateToPath(path, title: title) }
     }
   }
 
@@ -178,12 +181,13 @@ public final class RNABCarPlayController: NSObject {
 
       // Create list item factory
       let factory = CarPlayListItemFactory(
-        isActiveTrack: { [weak self] id, src in self?.isActiveTrack(id: id, src: src) ?? false },
+        isActiveTrack: { [weak self] identity in self?.isActiveTrack(identity: identity) ?? false },
         onItemSelected: { [weak self] track, completion in
           self?.handleItemSelection(track: track, completion: completion)
         },
       )
       factory.imageLoader = self.imageLoader
+      factory.playingIndicatorLocation = self.playingIndicatorLocation
       self.listItemFactory = factory
 
       self.setupContentSubscriptions()
@@ -261,7 +265,7 @@ public final class RNABCarPlayController: NSObject {
     }
 
     // Subscribe to config changes (for Now Playing buttons and per-track
-    // button state — e.g. resolveAlbumUrl appearing/disappearing)
+    // button state — e.g. resolveAlbumPath appearing/disappearing)
     audioBrowser.browserManager.onConfigChanged = { [weak self] _ in
       Task { @MainActor in
         self?.nowPlayingManager.setupNowPlayingButtons()
@@ -269,13 +273,22 @@ public final class RNABCarPlayController: NSObject {
       }
     }
 
-    // Now-playing buttons + Up Next are runtime-updatable via updateOptions();
-    // refresh them when player options change (configureBrowser is no longer
-    // the only path that can change them).
+    // Now-playing buttons + Up Next + the list playing-indicator location are
+    // runtime-updatable via updateOptions(); refresh them when player options
+    // change (configureBrowser is no longer the only path that can change them).
     let optionsToken = audioBrowser.playerOptionsChangedEmitter.addListener { [weak self] in
       Task { @MainActor in
-        self?.nowPlayingManager.setupNowPlayingButtons()
-        self?.nowPlayingManager.updateNowPlayingButtonStates()
+        guard let self else { return }
+        self.nowPlayingManager.setupNowPlayingButtons()
+        self.nowPlayingManager.updateNowPlayingButtonStates()
+        // The factory's copy doubles as the last-applied value: sweep the
+        // templates only when the location actually changed, not on every
+        // updateOptions() call.
+        let location = self.playingIndicatorLocation
+        if let factory = self.listItemFactory, factory.playingIndicatorLocation != location {
+          factory.playingIndicatorLocation = location
+          self.updatePlayingIndicators()
+        }
       }
     }
     listenerRemovals.append { [weak audioBrowser] in
@@ -409,9 +422,7 @@ public final class RNABCarPlayController: NSObject {
   private func buildInitialInterface() async {
     guard let audioBrowser else {
       logger.error("AudioBrowser not available")
-      await showRootNavigationError(
-        NavigationError(code: .unknownError, message: "", statusCode: nil, statusCodeSuccess: nil),
-      )
+      await showRootNavigationError(.code(.unknownError))
       return
     }
 
@@ -430,16 +441,10 @@ public final class RNABCarPlayController: NSObject {
         showLoadingTemplate()
       }
       do {
+        // An empty query result routes to the .emptyContent error page inside
+        // showTabBar, shared with runtime tab changes.
         let queriedTabs = try await audioBrowser.browserManager.queryTabs()
-        if !queriedTabs.isEmpty {
-          await showTabBar(tabs: queriedTabs)
-        } else {
-          // Empty is a navigation error (.emptyContent) so it formats through
-          // the app's formatNavigationError like every other failure (ADR 0001).
-          await showRootNavigationError(
-            NavigationError(code: .emptyContent, message: "", statusCode: nil, statusCodeSuccess: nil),
-          )
-        }
+        await showTabBar(tabs: queriedTabs)
       } catch {
         logger.error("Failed to query tabs: \(error.localizedDescription)")
         await showRootNavigationError(NavigationError.from(error))
@@ -459,7 +464,13 @@ public final class RNABCarPlayController: NSObject {
   // MARK: - Tab Bar
 
   @MainActor
-  private func showTabBar(tabs: [Track]) async {
+  private func showTabBar(tabs allTabs: [Track]) async {
+    // A disabled tab hides — CPTabBarTemplate has no gray affordance, so per
+    // Track.disabled's rendering ladder an unavailable tab must not render as
+    // a normal-looking control (matches Android Auto, which filters before
+    // its 4-tab cap).
+    let tabs = allTabs.filter { $0.disabled != true }
+
     // Serialize concurrent tab-bar builds across BOTH the gated and non-gated
     // paths with one shared generation token: bump at entry, capture, and bail
     // before any template mutation once a newer build supersedes us. Both paths
@@ -473,6 +484,17 @@ public final class RNABCarPlayController: NSObject {
     gateBuildGeneration &+= 1
     let generation = gateBuildGeneration
 
+    // A zero-tab CPTabBarTemplate renders blank, with no copy, so empty routes
+    // to the .emptyContent error page like every other failure (formatted
+    // through the app's formatNavigationError, ADR 0001). The guard lives at
+    // this choke point — both the initial build and runtime tab changes pass
+    // through here — and sits before the gate check, since a gated build from
+    // zero tabs is equally blank.
+    guard !tabs.isEmpty else {
+      await showRootNavigationError(.code(.emptyContent))
+      return
+    }
+
     // While gated, each tab path is resolved per-request: a gated tab renders
     // the gate page with that request's chrome; an allowed tab shows real
     // content. This generalizes the old "all tabs show the gate" — a path the
@@ -501,8 +523,8 @@ public final class RNABCarPlayController: NSObject {
     interfaceController.safeSetRoot(tabBar, animated: true)
 
     // Load content for the first tab only - others load lazily when selected
-    if let firstTemplate = tabTemplates.first, let firstTab = tabs.first, let url = firstTab.url {
-      await loadContent(for: url, into: firstTemplate)
+    if let firstTemplate = tabTemplates.first, let firstTab = tabs.first, let path = firstTab.path {
+      await loadContent(for: path, into: firstTemplate)
     }
   }
 
@@ -540,7 +562,7 @@ public final class RNABCarPlayController: NSObject {
     var templates: [CPListTemplate] = []
     for tab in limitedTabs {
       let outcome = await audioBrowser.gateDecision(
-        for: NativeGateRequest(reason: .browse, path: tab.url, search: nil),
+        for: NativeGateRequest(reason: .browse, path: tab.path, search: nil),
       )
       guard gateBuildGeneration == generation else { return } // superseded by a newer build
       if outcome.gated {
@@ -566,8 +588,8 @@ public final class RNABCarPlayController: NSObject {
     // Eagerly fill any allowed (content) tabs: templateDidAppear isn't
     // guaranteed to re-fire for templates swapped in via updateTemplates.
     for (tab, template) in zip(limitedTabs, templates) {
-      guard getPath(from: template) != nil, let url = tab.url else { continue }
-      await loadContent(for: url, into: template)
+      guard getPath(from: template) != nil, let path = tab.path else { continue }
+      await loadContent(for: path, into: template)
     }
   }
 
@@ -576,7 +598,7 @@ public final class RNABCarPlayController: NSObject {
   /// until its content lazy-loads on first appearance.
   private func createTabTemplate(for track: Track) -> CPListTemplate {
     // The path stored on the template drives lazy loading and refresh.
-    let template = makeLoadingTemplate(title: track.title, path: track.url)
+    let template = makeLoadingTemplate(title: track.title, path: track.path)
     applyTabBarEntry(to: template, for: track)
     return template
   }
@@ -682,14 +704,13 @@ public final class RNABCarPlayController: NSObject {
       // even with no rows — the "Ask Siri to Play" cell IS its content — so it
       // renders rather than falling through to the empty-content state.
       let hasAssistantCell = resolved.carPlaySiriListButton != nil
-      if resolved.children?.isEmpty ?? true, !hasAssistantCell {
+      // A page of empty sections is still empty.
+      let hasChildren = resolved.normalizedSections?.contains { !$0.children.isEmpty } ?? false
+      if !hasChildren, !hasAssistantCell {
         // Empty is modeled as a navigation error (code .emptyContent) so it goes
         // through the same path-aware formatter as failures — letting an app give
         // an empty Favorites tab different copy than an empty search. ADR 0001.
-        let empty = NavigationError(
-          code: .emptyContent, message: "", statusCode: nil, statusCodeSuccess: nil,
-        )
-        await showNavigationErrorView(empty, path: path, on: template)
+        await showNavigationErrorView(.code(.emptyContent), path: path, on: template)
       } else {
         updateTemplate(template, with: resolved)
       }
@@ -749,7 +770,7 @@ public final class RNABCarPlayController: NSObject {
     }
 
     // If this track is already loaded, resume playback and show Now Playing.
-    if track.src != nil, isActiveTrack(id: track.id, src: track.src) {
+    if track.src != nil, isActiveTrack(identity: track.identity) {
       try? audioBrowser.play()
       nowPlayingManager.showNowPlaying()
       completion()
@@ -777,7 +798,7 @@ public final class RNABCarPlayController: NSObject {
 
     // Release CarPlay immediately so the list never locks up. Apple's handler
     // guidance is to finish processing the tap promptly; for a browse we "finish"
-    // by pushing the destination and filling it in (see navigateToUrl), and for
+    // by pushing the destination and filling it in (see navigateToPath), and for
     // playback the Now Playing surface owns its own loading state.
     completion()
 
@@ -790,8 +811,8 @@ public final class RNABCarPlayController: NSObject {
         self.nowPlayingManager.showNowPlaying(popToFront: false)
       case .intercepted:
         self.nowPlayingManager.showNowPlaying(popToFront: false)
-      case let .browse(url):
-        await self.navigateToUrl(url, title: track.title)
+      case let .browse(path):
+        await self.navigateToPath(path, title: track.title)
       case .none:
         break
       }
@@ -809,24 +830,24 @@ public final class RNABCarPlayController: NSObject {
     }
   }
 
-  /// Pushes a browsable URL's destination immediately as an empty, spinning list
+  /// Pushes a browsable path's destination immediately as an empty, spinning list
   /// template — so the list the user tapped from is never blocked. The content is
   /// filled by `templateDidAppear` → `loadContentIfNeeded` → `loadContent`, which
   /// runs once the template is on screen (the timing CarPlay needs: updates made
   /// right after a push are dropped). Backing out and re-tapping retries.
   @MainActor
-  private func navigateToUrl(_ url: String, title: String) async {
+  private func navigateToPath(_ path: String, title: String) async {
     // The gate is resolved per-request: a gated path pushes the gate page
     // (with this request's chrome) instead of browsing into content; this also
     // blocks indirect entries like the Now Playing album line. An allowed path
     // browses normally even while a gate is active.
     if isGated, let audioBrowser {
       let outcome = await audioBrowser.gateDecision(
-        for: NativeGateRequest(reason: .browse, path: url, search: nil),
+        for: NativeGateRequest(reason: .browse, path: path, search: nil),
       )
       if outcome.gated {
         audioBrowser.onGate(GateEvent(reason: .browse))
-        if let top = interfaceController.topTemplate, getPath(from: top) == url { return }
+        if let top = interfaceController.topTemplate, getPath(from: top) == path { return }
         interfaceController.safePush(
           makeGateTemplate(gate: outcome.chrome, tab: nil), animated: true,
         )
@@ -834,24 +855,24 @@ public final class RNABCarPlayController: NSObject {
       }
     }
     // Avoid pushing a duplicate if the top template already shows this path.
-    if let top = interfaceController.topTemplate, getPath(from: top) == url {
+    if let top = interfaceController.topTemplate, getPath(from: top) == path {
       return
     }
     // …and guard a rapid double-tap whose first push hasn't appeared yet (so the
     // check above can't see it). Cleared when the pushed template appears.
-    guard !navigatingPaths.contains(url) else { return }
-    navigatingPaths.insert(url)
+    guard !navigatingPaths.contains(path) else { return }
+    navigatingPaths.insert(path)
 
-    let template = makeLoadingTemplate(title: title, path: url)
+    let template = makeLoadingTemplate(title: title, path: path)
     interfaceController.safePush(template, animated: true) { [weak self] pushed, error in
       guard !pushed else { return }
       // The push can fail (e.g. CarPlay's template stack depth limit). The
       // appear callback that normally clears the guard will never fire, so
       // clear it here — otherwise the destination stays unreachable until
       // CarPlay reconnects.
-      self?.navigatingPaths.remove(url)
+      self?.navigatingPaths.remove(path)
       if let error {
-        self?.logger.error("pushTemplate failed for \(url): \(error.localizedDescription)")
+        self?.logger.error("pushTemplate failed for \(path): \(error.localizedDescription)")
       }
     }
   }
@@ -930,14 +951,14 @@ public final class RNABCarPlayController: NSObject {
   @MainActor
   private func handleTabsChanged(_ tabs: [Track]) {
     logger.debug("Tabs changed: \(tabs.count) tabs")
-    // Same tabs by URL while ungated → only the tab-bar entries changed
+    // Same tabs by path while ungated → only the tab-bar entries changed
     // (e.g. titles after a locale switch): restamp them in place. No rebuild,
     // so the selected tab and any pushed navigation stack survive. (Gate
     // templates carry no path, so a gated tab bar never matches here.)
     if !isGated,
        let tabBar = interfaceController.rootTemplate as? CPTabBarTemplate,
        tabBar.templates.count == min(tabs.count, CPTabBarTemplate.maximumTabCount),
-       zip(tabBar.templates, tabs).allSatisfy({ getPath(from: $0) == $1.url })
+       zip(tabBar.templates, tabs).allSatisfy({ getPath(from: $0) == $1.path })
     {
       for (template, tab) in zip(tabBar.templates, tabs) {
         applyTabBarEntry(to: template, for: tab)
@@ -978,7 +999,7 @@ public final class RNABCarPlayController: NSObject {
     // This callback fires when the main browser's content changes.
     // For CarPlay-specific refreshes (e.g., favorites), use notifyContentChanged instead.
     guard let content else { return }
-    refreshTemplatesForPath(content.url, with: content)
+    refreshTemplatesForPath(content.path, with: content)
   }
 
   @MainActor
@@ -990,9 +1011,11 @@ public final class RNABCarPlayController: NSObject {
     nowPlayingManager.handleActiveTrackChanged()
   }
 
-  /// Updates the isPlaying state on all list items based on the current active track.
+  /// Updates the isPlaying state (and indicator location, which options can
+  /// change at runtime) on all list items based on the current active track.
   @MainActor
   fileprivate func updatePlayingIndicators() {
+    let location = playingIndicatorLocation
     var templates: [CPListTemplate] = []
 
     if let tabBar = interfaceController.rootTemplate as? CPTabBarTemplate {
@@ -1015,16 +1038,20 @@ public final class RNABCarPlayController: NSObject {
         for item in section.items {
           guard let listItem = item as? CPListItem,
                 let info = listItem.carPlayItemInfo,
-                info.src != nil
+                info.identity != nil
           else { continue }
 
-          let isPlaying = isActiveTrack(id: info.id, src: info.src)
+          let isPlaying = isActiveTrack(identity: info.identity)
           if listItem.isPlaying != isPlaying {
             logger.debug(
-              "Updating isPlaying for \(info.id ?? info.src ?? ""): \(listItem.isPlaying) → \(isPlaying)")
+              "Updating isPlaying for \(info.identity ?? ""): \(listItem.isPlaying) → \(isPlaying)")
             listItem.isPlaying = isPlaying
             templateChanged = true
           }
+          if listItem.playingIndicatorLocation != location {
+            listItem.playingIndicatorLocation = location
+            templateChanged = true
+          }
         }
       }
       // Setting isPlaying on an already-displayed item does not reliably reach
@@ -1336,12 +1363,23 @@ private extension RNABCarPlayController {
   }
 }
 
+// MARK: - NavigationError Shorthand
+
+extension NavigationError {
+  /// A code-only error: the user-facing copy comes from the app's
+  /// formatNavigationError (ADR 0001), so no message travels with it.
+  static func code(_ code: NavigationErrorType) -> NavigationError {
+    NavigationError(code: code, message: "", statusCode: nil, statusCodeSuccess: nil)
+  }
+}
+
 // MARK: - UIImage Resize
 
 extension UIImage {
-  /// Draws the image centered within the target size, maintaining aspect ratio
-  func resized(to targetSize: CGSize) -> UIImage? {
-    UIGraphicsBeginImageContextWithOptions(targetSize, false, 0.0)
+  /// Draws the image centered within the target size, maintaining aspect
+  /// ratio, at the given display scale (the car screen's, not the phone's).
+  func resized(to targetSize: CGSize, scale: CGFloat) -> UIImage? {
+    UIGraphicsBeginImageContextWithOptions(targetSize, false, scale)
     defer { UIGraphicsEndImageContext() }
 
     // Scale to fit while maintaining aspect ratio

package/ios/CarPlay/CarPlayImageLoader.swift

@@ -36,30 +36,39 @@ final class CarPlayImageLoader {
     return sfSymbolImageForSize(symbolName, canvasSize: canvasSize, backgroundColor: bg, symbolColor: fg)
   }
 
-  /// Cached empty placeholder image to reserve space while artwork loads
-  lazy var placeholderImage: UIImage? = {
-    let size = CPListItem.maximumImageSize
-    let scale = carTraitCollection.displayScale
-    UIGraphicsBeginImageContextWithOptions(size, false, scale)
+  /// Cached empty placeholders, keyed by point size — list items and image-row
+  /// cells reserve different footprints.
+  private var placeholders: [String: UIImage] = [:]
+
+  /// Empty placeholder image reserving a `size`-point slot while artwork loads.
+  func placeholderImage(size: CGSize) -> UIImage? {
+    let key = "\(size.width)×\(size.height)"
+    if let cached = placeholders[key] { return cached }
+    UIGraphicsBeginImageContextWithOptions(size, false, carTraitCollection.displayScale)
     defer { UIGraphicsEndImageContext() }
-    return UIGraphicsGetImageFromCurrentImageContext()
-  }()
+    guard let image = UIGraphicsGetImageFromCurrentImageContext() else { return nil }
+    placeholders[key] = image
+    return image
+  }
 
   // MARK: - Artwork Loading
 
   /// Loads artwork for a track with size context, using the artwork transform if configured.
   /// - Parameters:
   ///   - track: The track to load artwork for
+  ///   - style: The track's resolved style block (inherited values folded in).
+  ///     nil = the track's own declaration — callers without a section context
+  ///     (tabs, now-playing) have no inheritance to resolve.
   ///   - size: The target size in points (will be multiplied by CarPlay display scale)
   ///   - completion: Called with the loaded image, or nil on failure
-  func loadArtwork(for track: Track, size: CGSize, completion: @escaping @Sendable (UIImage?) -> Void) {
+  func loadArtwork(for track: Track, style: TrackStyle? = nil, size: CGSize, completion: @escaping @Sendable (UIImage?) -> Void) {
     // A track that ships one image per appearance is loaded as two ordinary
     // single-URL loads and combined below. Recursing rather than branching
     // inside the loader means each variant still goes through the whole
     // pipeline — route config, headers, SVG rasterising, the resolve transform
     // — instead of a second, thinner fetch path that would drift from it.
     if let variants = track.artwork?.variants {
-      loadVariants(for: track, variants: variants, size: size, completion: completion)
+      loadVariants(for: track, style: style, variants: variants, size: size, completion: completion)
       return
     }
 
@@ -77,7 +86,7 @@ final class CarPlayImageLoader {
       let action = await CarPlayArtworkResolver.resolve(
         artwork: track.artwork?.url,
         artworkSourceUri: track.artworkSource?.uri,
-        artworkCarPlayTinted: track.artworkCarPlayTinted,
+        stencil: (style ?? track.style)?.artworkRendering == .stencil,
         targetWidth: Double(size.width),
         targetHeight: Double(size.height),
         displayScale: Double(self.carTraitCollection.displayScale),
@@ -88,7 +97,7 @@ final class CarPlayImageLoader {
       case let .sfSymbol(artwork, width, height):
         completion(self.sfSymbolImage(forArtwork: artwork, canvasSize: CGSize(width: width, height: height)))
       case let .fetch(uri, headers, shouldTint, isSvg):
-        let image = await self.fetchImage(uri: uri, headers: headers, isSvg: isSvg)
+        let image = await self.fetchImage(uri: uri, headers: headers, isSvg: isSvg, size: size)
         if let image, shouldTint {
           completion(self.createAdaptiveImage(image, carTraitCollection: self.carTraitCollection))
         } else {
@@ -115,13 +124,18 @@ final class CarPlayImageLoader {
   /// beats an empty slot, and this is usually a transient fetch failure.
   private func loadVariants(
     for track: Track,
+    style: TrackStyle?,
     variants: ArtworkVariants,
     size: CGSize,
     completion: @escaping @Sendable (UIImage?) -> Void,
   ) {
     Task {
-      async let light = self.loadArtworkAsync(for: track.copying(artwork: .some(.first(variants.light))), size: size)
-      async let dark = self.loadArtworkAsync(for: track.copying(artwork: .some(.first(variants.dark))), size: size)
+      async let light = self.loadArtworkAsync(
+        for: track.copying(artwork: .some(.first(variants.light))), style: style, size: size,
+      )
+      async let dark = self.loadArtworkAsync(
+        for: track.copying(artwork: .some(.first(variants.dark))), style: style, size: size,
+      )
       let (lightImage, darkImage) = await (light, dark)
 
       guard let lightImage, let darkImage else {
@@ -137,19 +151,25 @@ final class CarPlayImageLoader {
   }
 
   /// `loadArtwork` as an awaitable, so the two variants can load concurrently.
-  private func loadArtworkAsync(for track: Track, size: CGSize) async -> UIImage? {
+  private func loadArtworkAsync(for track: Track, style: TrackStyle?, size: CGSize) async -> UIImage? {
     await withCheckedContinuation { continuation in
-      self.loadArtwork(for: track, size: size) { image in
+      self.loadArtwork(for: track, style: style, size: size) { image in
         continuation.resume(returning: image)
       }
     }
   }
 
   /// Fetches an image from a URL with optional headers and SVG processing.
-  private func fetchImage(uri: String, headers: [String: String]?, isSvg: Bool) async -> UIImage? {
+  /// Rasters are downsampled to `size` points at the car's display scale —
+  /// CPListItem.h: "size them to the display scale of the car screen". SVGs
+  /// already rasterize at car scale via SVGProcessor.
+  private func fetchImage(uri: String, headers: [String: String]?, isSvg: Bool, size: CGSize) async -> UIImage? {
     let source = ImageSource(uri: uri, method: nil, headers: headers, body: nil)
-    let svgScale: CGFloat? = isSvg ? carTraitCollection.displayScale : nil
-    return await ArtworkImageFetcher.fetchImage(from: source, svgScale: svgScale)
+    let scale = carTraitCollection.displayScale
+    if isSvg {
+      return await ArtworkImageFetcher.fetchImage(from: source, svgScale: scale)
+    }
+    return await ArtworkImageFetcher.fetchImage(from: source, downsampleTo: (size, scale))
   }
 
   /// Creates an SF Symbol image rendered at the given canvas size.