react-native-audio-browser 0.2.0-next.28 → 0.2.0-next.29

package/ios/Browser/{BrowserManager+URLResolution.swift → RequestPipeline.swift}

@@ -1,9 +1,151 @@
 import Foundation
 import NitroModules
+import os.log
+
+/// Builds and runs the browser's HTTP requests: the Request-Config Layers for browse, search,
+/// media and artwork, and the API fetches.
+@MainActor
+final class RequestPipeline {
+  let logger = Logger(subsystem: "com.audiobrowser", category: "RequestPipeline")
+  private let httpClient = HttpClient()
+  /// The request/browse thunks resolve once per content generation.
+  private let layers = GenerationMemo<ResolvedLayers>()
+
+  /// Set by `BrowserManager`; a new config resolves the layers again.
+  var config = BrowserConfig() {
+    didSet { layers.invalidate() }
+  }
+
+  nonisolated init() {}
+
+  /// Resolves the request and browse layers again on next use (e.g. after a locale change).
+  func invalidateLayers() {
+    layers.invalidate()
+  }
 
-// MARK: - URL Resolution
+  struct ResolvedLayers {
+    let request: TransformableRequestConfig?
+    let browse: TransformableRequestConfig?
+  }
+
+  /// The request and browse layers of the current config: each resolver's result, or the
+  /// static layer when it has none. The resolvers run one after the other, request first, as on
+  /// Android and web, and a config change or `clearContentCache` while they run resolves them
+  /// again.
+  func resolvedLayers() async throws -> ResolvedLayers {
+    try await layers.value { [weak self] in
+      guard let self else { throw CancellationError() }
+      // Read on every run: a retry after a config change must resolve the new config's layers.
+      let config = self.config
+      // The resolver is Promise-only (the TS layer wraps a sync-or-async thunk in
+      // Promise.resolve), so its result is the JS promise behind the bridge promise.
+      let request = try await config.requestResolver?().await().await() ?? config.request
+      let browse = try await config.browseResolver?().await().await() ?? config.browse
+      return ResolvedLayers(request: request, browse: browse)
+    }
+  }
+
+  /// Applies one Request-Config Layer (request / browse / route) onto `base`: its transforms
+  /// (async, then sync) when it has any, else its static fields (`RequestLayer.apply`).
+  func applyLayer(
+    _ layer: TransformableRequestConfig?,
+    to base: RequestConfig,
+    params: [String: String],
+  ) async throws -> RequestConfig {
+    guard let layer else { return base }
+    var transforms: [nonisolated(nonsending)(RequestConfig) async throws -> RequestConfig] = []
+    if let transform = layer.transform {
+      transforms.append { try await self.awaitAsyncConfig(transform($0, params)) }
+    }
+    if let transformSync = layer.transformSync {
+      transforms.append { try await self.awaitSyncConfig(transformSync($0, params)) }
+    }
+    let fields = RequestConfig(
+      method: layer.method, path: nil, baseUrl: layer.baseUrl, headers: layer.headers,
+      query: layer.query, body: layer.body, contentType: layer.contentType, userAgent: layer.userAgent,
+    )
+    return try await RequestLayer.apply(fields, transforms: transforms, to: base)
+  }
+
+  /// Builds the HTTP request for an API-backed route by layering
+  /// request → kind → route configs. `initialQuery` seeds request-level query
+  /// params (e.g. search q/mode/…) onto the base before the route layer, so they
+  /// survive into `request.query` even when a layer's transform "wins
+  /// completely" (it is handed only the base, so the route config's own static
+  /// query would otherwise be dropped). `routeConfig` is nil for the implicit
+  /// browse default; `kind` names the per-kind layer, nil for kinds with none. The request and
+  /// kind layers come from one resolution; `routeConfig` from the caller's config.
+  func buildApiRequest(
+    kind: KeyPath<ResolvedLayers, TransformableRequestConfig?>?,
+    _ routeConfig: TransformableRequestConfig?,
+    path: String,
+    params: [String: String],
+    initialQuery: [String: String]? = nil,
+  ) async throws -> HttpClient.HttpRequest {
+    var merged = RequestConfig(
+      method: nil, path: path, baseUrl: nil, headers: nil,
+      query: nil, body: nil, contentType: nil, userAgent: nil,
+    )
+    let layers = try await resolvedLayers()
+    merged = try await applyLayer(layers.request, to: merged, params: params)
+    if let initialQuery, !initialQuery.isEmpty {
+      merged = merged.copying(query: RequestLayer.mergeDicts(merged.query, initialQuery))
+    }
+    merged = try await applyLayer(kind.flatMap { layers[keyPath: $0] }, to: merged, params: params)
+    merged = try await applyLayer(routeConfig, to: merged, params: params)
+
+    guard merged.baseUrl != nil else {
+      throw BrowserError.invalidConfiguration("No URL configured for route")
+    }
+    return HttpClient.HttpRequest(
+      url: RequestLayer.buildUrl(merged, defaultPath: path),
+      method: merged.method?.stringValue ?? "GET",
+      headers: merged.headers,
+      body: merged.body,
+      contentType: merged.contentType ?? HttpClient.defaultContentType,
+      userAgent: merged.userAgent ?? HttpClient.defaultUserAgent,
+    )
+  }
+
+  /// Fetches a page object (`{title,path,children:[…]}`) through the request → browse → route
+  /// layers.
+  func fetchPage(
+    _ routeConfig: TransformableRequestConfig?,
+    path: String,
+    params: [String: String],
+  ) async throws -> ResolvedTrack {
+    let request = try await buildApiRequest(
+      kind: \.browse, routeConfig, path: path, params: params,
+    )
+
+    logger.debug("Resolving content from API")
+    logger.debug("  path: \(path)")
+    logger.debug("  url: \(request.url)")
+
+    let result: JsonResolvedTrack = try await httpClient.requestJson(request, as: JsonResolvedTrack.self)
+    let nitroResult = result.toNitro()
+
+    logger.debug("Resolved: \(nitroResult.title)")
+    if let sections = nitroResult.normalizedSections {
+      logger.debug("  children: \(sections.reduce(0) { $0 + $1.children.count }) tracks")
+    }
+
+    return nitroResult
+  }
+
+  /// Fetches a search route's bare Track array through the request → search route layers. The
+  /// search params go through `initialQuery`, so they reach the URL even when a transform wins;
+  /// the config's static path seeds the base, since a layer's static path never applies.
+  func fetchSearch(_ searchConfig: TransformableRequestConfig, params: SearchParams) async throws -> [Track] {
+    let request = try await buildApiRequest(
+      kind: nil, searchConfig, path: searchConfig.path ?? "", params: ["q": params.query],
+      initialQuery: PageResolver.searchQueryParams(params),
+    )
+    logger.debug("Searching via API: \(request.url)")
+    let jsonTracks: [JsonTrack] = try await httpClient.requestJson(request, as: [JsonTrack].self)
+    return jsonTracks.map { $0.toNitro() }
+  }
 
-extension BrowserManager {
   // MARK: - Media URL Resolution
 
   /// Resolves a media URL using the configured media transform.
@@ -11,7 +153,7 @@ extension BrowserManager {
   ///
   /// Resolution layers, least- to most-specific: shared `request` layer →
   /// `media` transform / static fields → `media.resolve(track)`. The final
-  /// `resolve` layer (if configured) is merged last via `mergeRequestConfig`,
+  /// `resolve` layer (if configured) is merged last,
   /// so its fields win. The `track` is only used to feed `resolve`; we do NOT
   /// auto-merge `track.request` here.
   func resolveMediaUrl(_ originalUrl: String, track: Track? = nil) async -> MediaResolvedUrl {
@@ -23,9 +165,8 @@ extension BrowserManager {
     // `media` config is present, so a relative src still gets baseUrl.
     let baseRequest: RequestConfig
     do {
-      try await ensureLayersResolved()
       baseRequest = try await applyLayer(
-        resolvedRequestLayer,
+        resolvedLayers().request,
         to: RequestConfig(
           method: nil, path: originalUrl, baseUrl: nil, headers: nil,
           query: nil, body: nil, contentType: nil, userAgent: nil,
@@ -56,8 +197,8 @@ extension BrowserManager {
       if let mediaConfig = config.media {
         merged = try await applyMediaLayer(mediaConfig, to: merged)
       }
-      merged = applyMediaResolveLayer(base: merged, resolve: resolveLayer)
-      let finalUrl = buildUrl(from: merged)
+      if let resolveLayer { merged = RequestLayer.merge(merged, resolveLayer) }
+      let finalUrl = RequestLayer.buildUrl(merged)
       logger.debug("Media URL resolved: \(originalUrl) -> \(finalUrl)")
       return MediaResolvedUrl(
         url: finalUrl,
@@ -70,46 +211,21 @@ extension BrowserManager {
     }
   }
 
-  /// Media-kind Request-Config Layer application: a transform (async and/or sync)
-  /// wins completely — async first, then sync, each result copied out of the Nitro
-  /// bridge immediately (extractConfig, via awaitAsync/SyncConfig) — otherwise the
-  /// media config's static fields merge over the base with `path` carried from the
-  /// base (only a transform may change it). The same rule as `applyLayer`; matches
-  /// the web stub and Android.
+  /// The media kind's Request-Config Layer over `base`: its transforms, when it has any, else
+  /// its static fields (`RequestLayer.apply`).
   private func applyMediaLayer(_ media: MediaRequestConfig, to base: RequestConfig) async throws -> RequestConfig {
-    if media.transform != nil || media.transformSync != nil {
-      var result = base
-      if let transform = media.transform {
-        result = try await awaitAsyncConfig(transform(result, nil))
-      }
-      if let transformSync = media.transformSync {
-        result = try await awaitSyncConfig(transformSync(result, nil))
-      }
-      return result
+    var transforms: [nonisolated(nonsending)(RequestConfig) async throws -> RequestConfig] = []
+    if let transform = media.transform {
+      transforms.append { try await self.awaitAsyncConfig(transform($0, nil)) }
     }
-    let staticMerged = mergeRequestConfig(
-      base: base,
-      override: RequestConfig(
-        method: media.method,
-        path: media.path,
-        baseUrl: media.baseUrl,
-        headers: media.headers,
-        query: media.query,
-        body: media.body,
-        contentType: media.contentType,
-        userAgent: media.userAgent,
-      ),
-    )
-    return RequestConfig(
-      method: staticMerged.method,
-      path: base.path,
-      baseUrl: staticMerged.baseUrl,
-      headers: staticMerged.headers,
-      query: staticMerged.query,
-      body: staticMerged.body,
-      contentType: staticMerged.contentType,
-      userAgent: staticMerged.userAgent,
+    if let transformSync = media.transformSync {
+      transforms.append { try await self.awaitSyncConfig(transformSync($0, nil)) }
+    }
+    let fields = RequestConfig(
+      method: media.method, path: nil, baseUrl: media.baseUrl, headers: media.headers,
+      query: media.query, body: media.body, contentType: media.contentType, userAgent: media.userAgent,
     )
+    return try await RequestLayer.apply(fields, transforms: transforms, to: base)
   }
 
   /// Invokes the consumer-supplied `media.resolve`/`resolveSync(track)` and merges
@@ -122,17 +238,7 @@ extension BrowserManager {
     if let resolve = media.resolve { asyncResolved = try await awaitAsyncConfig(resolve(track)) }
     var syncResolved: RequestConfig?
     if let resolveSync = media.resolveSync { syncResolved = try await awaitSyncConfig(resolveSync(track)) }
-    return MediaResolveComposer.composeResolved(
-      async: asyncResolved, sync: syncResolved,
-      combine: { self.mergeRequestConfig(base: $0, override: $1) },
-    )
-  }
-
-  /// Merges the resolve layer (most specific, override-wins) over `base`.
-  /// A no-op when `resolve` is nil.
-  private func applyMediaResolveLayer(base: RequestConfig, resolve: RequestConfig?) -> RequestConfig {
-    guard let resolve else { return base }
-    return mergeRequestConfig(base: base, override: resolve)
+    return RequestLayer.mergeResolved(async: asyncResolved, sync: syncResolved)
   }
 
   // MARK: - Artwork URL Resolution
@@ -176,9 +282,8 @@ extension BrowserManager {
       // Base config via the shared `request` layer (its transform runs for
       // artwork too), with track.artwork as the default path. Artwork then
       // shapes further via its own resolve / static fields / transform.
-      try await ensureLayersResolved()
       var mergedConfig = try await applyLayer(
-        resolvedRequestLayer,
+        resolvedLayers().request,
         to: RequestConfig(
           method: nil, path: track.artwork?.url, baseUrl: nil, headers: nil,
           query: nil, body: nil, contentType: nil, userAgent: nil,
@@ -200,18 +305,15 @@ extension BrowserManager {
         contentType: artworkConfig.contentType,
         userAgent: artworkConfig.userAgent,
       )
-      mergedConfig = mergeRequestConfig(base: mergedConfig, override: artworkStaticConfig)
+      mergedConfig = RequestLayer.merge(mergedConfig, artworkStaticConfig)
 
       if artworkConfig.resolve != nil || artworkConfig.resolveSync != nil {
         var asyncResolved: RequestConfig?
         if let resolve = artworkConfig.resolve { asyncResolved = try await awaitAsyncConfig(resolve(track)) }
         var syncResolved: RequestConfig?
         if let resolveSync = artworkConfig.resolveSync { syncResolved = try await awaitSyncConfig(resolveSync(track)) }
-        if let resolved = MediaResolveComposer.composeResolved(
-          async: asyncResolved, sync: syncResolved,
-          combine: { self.mergeRequestConfig(base: $0, override: $1) },
-        ) {
-          mergedConfig = mergeRequestConfig(base: mergedConfig, override: resolved)
+        if let resolved = RequestLayer.mergeResolved(async: asyncResolved, sync: syncResolved) {
+          mergedConfig = RequestLayer.merge(mergedConfig, resolved)
         } else if track.artwork == nil {
           // A resolver ran but produced nothing, and there's no artwork URL either
           // → no artwork (matches the web stub).
@@ -232,20 +334,7 @@ extension BrowserManager {
 
         if !contextQuery.isEmpty {
           logger.debug("Adding image query params: \(contextQuery)")
-          var existingQuery = mergedConfig.query ?? [:]
-          for (key, value) in contextQuery {
-            existingQuery[key] = value
-          }
-          mergedConfig = RequestConfig(
-            method: mergedConfig.method,
-            path: mergedConfig.path,
-            baseUrl: mergedConfig.baseUrl,
-            headers: mergedConfig.headers,
-            query: existingQuery,
-            body: mergedConfig.body,
-            contentType: mergedConfig.contentType,
-            userAgent: mergedConfig.userAgent,
-          )
+          mergedConfig = mergedConfig.copying(query: RequestLayer.mergeDicts(mergedConfig.query, contextQuery))
         }
       }
 
@@ -276,7 +365,7 @@ extension BrowserManager {
         return nil
       }
 
-      let uri = buildUrl(from: mergedConfig)
+      let uri = RequestLayer.buildUrl(mergedConfig)
 
       // Build headers map, merging explicit headers with userAgent
       var headers = mergedConfig.headers ?? [:]
@@ -303,22 +392,6 @@ extension BrowserManager {
     }
   }
 
-  // MARK: - URL Building
-
-  private func buildUrl(from config: RequestConfig) -> String {
-    let path = config.path ?? ""
-    let baseUrl = config.baseUrl
-
-    var url = BrowserPathHelper.buildUrl(baseUrl: baseUrl, path: path)
-
-    // Add query parameters if any
-    if let query = config.query, !query.isEmpty {
-      url = BrowserPathHelper.appendQuery(query, to: url)
-    }
-
-    return url
-  }
-
   // MARK: - Config Utilities
 
   /// Replaces the `{id}` token with the track id in a request config's path, query values, and
@@ -354,7 +427,6 @@ extension BrowserManager {
 
   /// Extracts all values from a RequestConfig into a new instance to avoid
   /// memory corruption in Nitro's Swift-C++ bridge when the Promise is deallocated.
-  /// Internal so `applyLayer` (in BrowserManager.swift) can copy transform results.
   func extractConfig(_ config: RequestConfig) -> RequestConfig {
     RequestConfig(
       method: config.method,
@@ -367,18 +439,14 @@ extension BrowserManager {
       userAgent: config.userAgent,
     )
   }
+}
 
-  /// Merges two RequestConfig objects, with override values taking precedence.
-  private func mergeRequestConfig(base: RequestConfig, override: RequestConfig) -> RequestConfig {
-    RequestConfig(
-      method: override.method ?? base.method,
-      path: override.path ?? base.path,
-      baseUrl: override.baseUrl ?? base.baseUrl,
-      headers: mergeDicts(base.headers, override.headers),
-      query: mergeDicts(base.query, override.query),
-      body: override.body ?? base.body,
-      contentType: override.contentType ?? base.contentType,
-      userAgent: override.userAgent ?? base.userAgent,
-    )
+extension RequestConfig: RequestFields {}
+
+extension RequestPipeline: MediaResolving {
+  /// Runs the `nowPlayingArtwork` config for every playing track, id or not: an id-less track
+  /// leaves an `{id}` token unfilled, so the request visibly fails rather than being skipped.
+  func resolveNowPlayingArtwork(track: Track, imageContext: ImageContext?) async -> ImageSource? {
+    await resolveArtworkUrl(track: track, perRouteConfig: config.nowPlayingArtwork, imageContext: imageContext)
   }
 }

package/ios/CarPlay/CPInterfaceController+Safe.swift

@@ -64,6 +64,17 @@ extension CPInterfaceController {
     }
   }
 
+  /// Replaces `expected` with `template` while `expected` is still the top template, restoring
+  /// it if the push fails; a no-op once the user has moved on.
+  func safeReplaceTop(_ expected: CPTemplate, with template: CPTemplate, animated: Bool) {
+    whenStackSettled { controller in
+      guard controller.topTemplate === expected else { return }
+      controller.topReplacer.push(
+        template, replacingTopOf: GuardedTemplateStack(controller: controller), animated: animated,
+      )
+    }
+  }
+
   /// Pushes `template`, skipping the raise cases (already in the hierarchy,
   /// stack at the depth limit).
   fileprivate func guardedPush(_ template: CPTemplate, animated: Bool, completion: ((Bool, Error?) -> Void)?) {
@@ -150,30 +161,6 @@ extension CPInterfaceController {
       }
     }
   }
-
-  func safePresent(_ template: CPTemplate, animated: Bool, completion: ((Bool, Error?) -> Void)? = nil) {
-    presentTemplate(template, animated: animated) { presented, error in
-      if let error {
-        Self.stackLogger.error("presentTemplate \(Self.name(of: template)) failed: \(error.localizedDescription)")
-      }
-      completion?(presented, error)
-    }
-  }
-
-  /// Dismisses the presented template, skipping when nothing is presented.
-  func safeDismiss(animated: Bool, completion: ((Bool, Error?) -> Void)? = nil) {
-    guard presentedTemplate != nil else {
-      Self.stackLogger.debug("dismiss skipped: no presented template")
-      completion?(false, nil)
-      return
-    }
-    dismissTemplate(animated: animated) { dismissed, error in
-      if let error {
-        Self.stackLogger.error("dismissTemplate failed: \(error.localizedDescription)")
-      }
-      completion?(dismissed, error)
-    }
-  }
 }
 
 /// The guarded pop and push a replacement is made of, so a push that still

package/ios/CarPlay/CarPlayArtworkResolver.swift

@@ -1,108 +1,60 @@
 import Foundation
 
-/// Represents a resolved artwork image URL with optional headers.
+/// An artwork URL and the headers to fetch it with.
 struct ArtworkResolvedImage: Equatable, Sendable {
   let uri: String
   let headers: [String: String]?
 }
 
-/// Describes what action to take for loading artwork.
-/// Produced by `CarPlayArtworkResolver`, consumed by `CarPlayImageLoader`.
+/// How `CarPlayImageLoader` loads one artwork.
 enum ArtworkLoadAction: Equatable, Sendable {
-  /// Render an SF Symbol from the artwork string at the given canvas size
+  /// Render the `sf:` artwork at this canvas size.
   case sfSymbol(artwork: String, width: Double, height: Double)
-  /// Fetch an image from a URL, optionally with headers, tinting, and SVG processing
   case fetch(uri: String, headers: [String: String]?, shouldTint: Bool, isSvg: Bool)
-  /// No artwork available
   case none
 }
 
-/// Determines artwork loading strategy without UIKit dependencies.
-///
-/// Encapsulates the decision tree for how to load artwork:
-/// 1. SF Symbol artwork → render directly
-/// 2. URL resolver available → resolve, then fetch from resolved URL
-/// 3. Fallback → fetch directly from artwork/artworkSource URL
+/// Decides how CarPlay loads a track's artwork, given what the Browser layer's
+/// `resolveArtworkUrl` returned for it.
 enum CarPlayArtworkResolver {
-  /// Resolves the artwork loading strategy for a track.
-  ///
-  /// - Parameters:
-  ///   - artwork: The track's `artwork` field (may be an SF Symbol string or URL)
-  ///   - artworkSourceUri: The track's `artworkSource?.uri` field
-  ///   - stencil: Whether the artwork renders as a monochrome glyph tinted to
-  ///     the surface appearance (`style.artworkRendering: 'stencil'`)
-  ///   - targetWidth: Target width in points
-  ///   - targetHeight: Target height in points
-  ///   - displayScale: The CarPlay display scale factor
-  ///   - urlResolver: Optional closure that resolves artwork URLs (wraps BrowserManager)
-  static func resolve(
-    artwork: String?,
-    artworkSourceUri: String?,
-    stencil: Bool,
-    targetWidth: Double,
-    targetHeight: Double,
-    displayScale: Double,
-    urlResolver: ((Double, Double) async -> ArtworkResolvedImage?)?,
-  ) async -> ArtworkLoadAction {
-    // 1. Primary SF symbol check
-    if let artwork, artwork.hasPrefix("sf:") {
-      return .sfSymbol(artwork: artwork, width: targetWidth, height: targetHeight)
-    }
-
-    // 2. Try URL resolution via resolver
-    if let urlResolver {
-      let pixelWidth = targetWidth * displayScale
-      let pixelHeight = targetHeight * displayScale
-      if let resolved = await urlResolver(pixelWidth, pixelHeight) {
-        guard let resolvedUrl = URL(string: resolved.uri) else {
-          return resolveDirectFallback(
-            artwork: artwork,
-            artworkSourceUri: artworkSourceUri,
-            stencil: stencil,
-            targetWidth: targetWidth,
-            targetHeight: targetHeight,
-          )
-        }
-        let isSvg = resolvedUrl.pathExtension.lowercased() == "svg"
-        return .fetch(
-          uri: resolved.uri,
-          headers: resolved.headers,
-          shouldTint: stencil,
-          isSvg: isSvg,
-        )
-      }
-    }
-
-    // 3. Direct fallback
-    return resolveDirectFallback(
-      artwork: artwork,
-      artworkSourceUri: artworkSourceUri,
-      stencil: stencil,
-      targetWidth: targetWidth,
-      targetHeight: targetHeight,
-    )
+  /// Whether to ask the Browser layer at all: CarPlay renders an SF Symbol itself.
+  static func needsResolve(artwork: String?) -> Bool {
+    !isSFSymbol(artwork)
   }
 
-  private static func resolveDirectFallback(
+  /// An SF Symbol renders; otherwise the resolved URL is fetched, falling back to the track's
+  /// `artwork`, then its `artworkSource` with that source's headers. `stencil` tints the image
+  /// to the surface's appearance.
+  static func action(
     artwork: String?,
-    artworkSourceUri: String?,
+    artworkSource: ArtworkResolvedImage?,
+    resolved: ArtworkResolvedImage?,
     stencil: Bool,
-    targetWidth: Double,
-    targetHeight: Double,
+    width: Double,
+    height: Double,
   ) -> ArtworkLoadAction {
-    guard let directUri = artwork ?? artworkSourceUri else { return .none }
-
-    if directUri.hasPrefix("sf:") {
-      return .sfSymbol(artwork: directUri, width: targetWidth, height: targetHeight)
+    if isSFSymbol(artwork), let artwork {
+      return .sfSymbol(artwork: artwork, width: width, height: height)
+    }
+    if let resolved, let action = fetch(resolved, stencil: stencil) {
+      return action
+    }
+    let direct = artwork.map { ArtworkResolvedImage(uri: $0, headers: nil) } ?? artworkSource
+    guard let direct else { return .none }
+    if isSFSymbol(direct.uri) {
+      return .sfSymbol(artwork: direct.uri, width: width, height: height)
     }
+    return fetch(direct, stencil: stencil) ?? .none
+  }
 
-    guard let directUrl = URL(string: directUri) else { return .none }
-    let isSvg = directUrl.pathExtension.lowercased() == "svg"
+  private static func fetch(_ image: ArtworkResolvedImage, stencil: Bool) -> ArtworkLoadAction? {
+    guard let url = URL(string: image.uri) else { return nil }
     return .fetch(
-      uri: directUri,
-      headers: nil,
-      shouldTint: stencil,
-      isSvg: isSvg,
+      uri: image.uri, headers: image.headers, shouldTint: stencil, isSvg: url.pathExtension.lowercased() == "svg",
     )
   }
+
+  private static func isSFSymbol(_ artwork: String?) -> Bool {
+    artwork?.hasPrefix("sf:") == true
+  }
 }