fix: speed up pubky profile loading

Bitkit/AppScene.swift

@@ -442,7 +442,7 @@ struct AppScene: View {
                     paykitPaymentRequestManager.clear()
                 }
             }
-            .onReceive(contactsManager.$contacts) { contacts in
+            .onReceive(contactsManager.savedContactsChangedPublisher) { contacts in
                 guard PaykitFeatureFlags.isUIEnabled,
                       wallet.walletExists == true,
                       pubkyProfile.authState == .authenticated

Bitkit/Components/PubkyChoiceRow.swift

@@ -8,6 +8,9 @@ struct PubkyChoiceRow: View {
     let title: String
     var avatarName: String?
     var avatarImageUrl: String?
+    var isLoading = false
+    var isLookingUp = false
+    var lookupAccessibilityId: String?
     let accessibilityId: String
     let action: () -> Void
 
@@ -26,7 +29,13 @@ struct PubkyChoiceRow: View {
 
                 Spacer()
 
-                if let avatarName {
+                if isLookingUp {
+                    ActivityIndicator(size: 20)
+                        .frame(width: 32, height: 32)
+                        .accessibilityElement()
+                        .accessibilityLabel(t("profile__choice_loading_profile"))
+                        .accessibilityIdentifier(lookupAccessibilityId ?? "")
+                } else if let avatarName {
                     PubkyContactAvatar(name: avatarName, imageUrl: avatarImageUrl, size: 32)
                 }
             }
@@ -39,7 +48,9 @@ struct PubkyChoiceRow: View {
 
     private var iconView: some View {
         Group {
-            if let icon {
+            if isLoading {
+                ActivityIndicator(size: 20)
+            } else if let icon {
                 Image(icon)
                     .resizable()
                     .scaledToFit()

Bitkit/Components/PubkyImage.swift

@@ -1,5 +1,6 @@
 import CryptoKit
 import ImageIO
+import Paykit
 import SwiftUI
 
 /// Loads and displays an image from a `pubky://` URI using Paykit's Pubky file fetch.
@@ -60,28 +61,52 @@ struct PubkyImage: View {
                 try await Self.loadImageOffMain(uri: uri)
             }.value
             uiImage = image
+        } catch PubkyImageError.recentlyFailed {
+            hasFailed = true
         } catch {
             Logger.error("Failed to load pubky image: \(error)", context: "PubkyImage")
             hasFailed = true
         }
     }
 
-    /// All heavy work (disk cache, network/FFI) runs off the main actor.
-    private nonisolated static func loadImageOffMain(uri: String) async throws -> UIImage {
-        if let cached = await PubkyImageCache.shared.image(for: uri) {
+    /// All heavy work (disk cache, network/FFI) runs off the main actor. A URI whose fetch failed recently fails at once
+    /// without the network, while a disk cache hit still wins.
+    nonisolated static func loadImageOffMain(
+        uri: String,
+        cache: PubkyImageCache = .shared,
+        fetchFile: @escaping @Sendable (_ uri: String, _ maxBytes: UInt64) async throws -> Data = {
+            try await PubkyService.fetchFile(uri: $0, maxBytes: $1)
+        }
+    ) async throws -> UIImage {
+        let cacheGeneration = cache.generation
+        if let cached = await cache.image(for: uri, generation: cacheGeneration) {
             return cached
         }
+        guard !cache.hasRecentFailure(for: uri) else {
+            throw PubkyImageError.recentlyFailed
+        }
 
-        let data = try await PubkyService.fetchFile(uri: uri, maxBytes: PubkyImagePolicy.maxDownloadBytes)
-        let blobData = try await resolveImageData(data, originalUri: uri)
+        do {
+            let data = try await fetchFile(uri, PubkyImagePolicy.maxDownloadBytes)
+            let blobData = try await resolveImageData(data, originalUri: uri, fetchFile: fetchFile)
 
-        let image = try PubkyImageDecoder.image(from: blobData)
+            let image = try PubkyImageDecoder.image(from: blobData)
 
-        PubkyImageCache.shared.store(image, data: blobData, for: uri)
-        return image
+            cache.store(image, data: blobData, for: uri, generation: cacheGeneration)
+            return image
+        } catch {
+            if !Task.isCancelled {
+                cache.rememberFailure(error, for: uri, generation: cacheGeneration)
+            }
+            throw error
+        }
     }
 
-    private nonisolated static func resolveImageData(_ data: Data, originalUri: String) async throws -> Data {
+    private nonisolated static func resolveImageData(
+        _ data: Data,
+        originalUri: String,
+        fetchFile: @Sendable (_ uri: String, _ maxBytes: UInt64) async throws -> Data
+    ) async throws -> Data {
         guard let json = try? JSONSerialization.jsonObject(with: data) as? [String: Any],
               let src = json["src"] as? String,
               src.hasPrefix("pubky://")
@@ -97,7 +122,7 @@ struct PubkyImage: View {
         }
 
         Logger.debug("File descriptor found, fetching blob from: \(src)", context: "PubkyImage")
-        return try await PubkyService.fetchFile(uri: src, maxBytes: PubkyImagePolicy.maxDownloadBytes)
+        return try await fetchFile(src, PubkyImagePolicy.maxDownloadBytes)
     }
 }
 
@@ -106,6 +131,8 @@ enum PubkyImagePolicy {
     static let maxPixelSize = 512
     static let memoryCacheBytes = 32 * 1024 * 1024
     static let diskCacheBytes = 32 * 1024 * 1024
+    /// How long an image whose fetch failed for a reason that can pass, such as a network error, is not fetched again.
+    static let transientFailureTTL: TimeInterval = 60
 }
 
 enum PubkyImageDecoder {
@@ -131,6 +158,7 @@ private enum PubkyImageError: LocalizedError {
     case decodingFailed(Int)
     case fileTooLarge(Int)
     case crossUserRedirect
+    case recentlyFailed
 
     var errorDescription: String? {
         switch self {
@@ -140,12 +168,19 @@ private enum PubkyImageError: LocalizedError {
             return "Image blob exceeds the byte limit (\(bytes) bytes)"
         case .crossUserRedirect:
             return "Image descriptor references a different user's namespace"
+        case .recentlyFailed:
+            return "Image fetch failed recently"
         }
     }
 }
 
 /// Two-tier cache (memory + disk) so profile images persist across app launches
 /// and multiple PubkyImage views with the same URI don't re-fetch.
+///
+/// It also remembers failed fetches by URI, so an image that cannot load is not fetched again each time it is shown. A
+/// missing file and a file over `PubkyImagePolicy.maxDownloadBytes` are remembered until `clear()`, which sign-out and
+/// a switch to another identity run, and any other failure for `PubkyImagePolicy.transientFailureTTL`. For a file
+/// descriptor, a failed blob fetch counts as a failure of the descriptor URI.
 final class PubkyImageCache: @unchecked Sendable {
     static let shared = PubkyImageCache()
 
@@ -155,27 +190,37 @@ final class PubkyImageCache: @unchecked Sendable {
         var lastAccess: UInt64
     }
 
+    private struct Failure {
+        let expiresAt: Date?
+    }
+
     private var memoryCache: [String: MemoryEntry] = [:]
+    /// Guarded by `memoryLock`, like the memory cache, so `clear()` empties both at once.
+    private var failures: [String: Failure] = [:]
     private var memoryCost = 0
     private var accessSequence: UInt64 = 0
+    private var clearGeneration: UInt64 = 0
     private let memoryLock = NSLock()
     private let diskQueue = DispatchQueue(label: "pubky-image-cache-disk", qos: .utility)
     private let diskDirectory: URL
     private let maxFileBytes: Int
     private let maxMemoryBytes: Int
     private let maxDiskBytes: Int
+    private let currentDate: @Sendable () -> Date
 
     init(
         diskDirectory: URL? = nil,
         maxFileBytes: Int = Int(PubkyImagePolicy.maxDownloadBytes),
         memoryCostLimit: Int = PubkyImagePolicy.memoryCacheBytes,
-        diskByteLimit: Int = PubkyImagePolicy.diskCacheBytes
+        diskByteLimit: Int = PubkyImagePolicy.diskCacheBytes,
+        currentDate: @escaping @Sendable () -> Date = { Date() }
     ) {
         let caches = FileManager.default.urls(for: .cachesDirectory, in: .userDomainMask).first!
         self.diskDirectory = diskDirectory ?? caches.appendingPathComponent("pubky-images", isDirectory: true)
         self.maxFileBytes = maxFileBytes
         maxMemoryBytes = memoryCostLimit
         maxDiskBytes = diskByteLimit
+        self.currentDate = currentDate
         try? FileManager.default.createDirectory(at: self.diskDirectory, withIntermediateDirectories: true)
         diskQueue.async { [self] in
             trimDiskCache()
@@ -194,7 +239,8 @@ final class PubkyImageCache: @unchecked Sendable {
     }
 
     /// Full lookup (memory + disk). Disk I/O runs on a dedicated queue to avoid blocking cooperative threads.
-    func image(for uri: String) async -> UIImage? {
+    /// A disk hit is promoted to memory only while `generation` is still current, as with `store`.
+    func image(for uri: String, generation: UInt64) async -> UIImage? {
         if let memoryHit = memoryImage(for: uri) {
             return memoryHit
         }
@@ -219,24 +265,76 @@ final class PubkyImageCache: @unchecked Sendable {
                 }
 
                 try? FileManager.default.setAttributes([.modificationDate: Date()], ofItemAtPath: path.path)
-                storeInMemory(diskImage, for: uri)
+                storeInMemory(diskImage, for: uri, generation: generation)
                 continuation.resume(returning: diskImage)
             }
         }
     }
 
-    func store(_ image: UIImage, data: Data, for uri: String) {
+    /// Bumped by `clear()`. Capture it before fetching and pass it to `store`, so a fetch that finishes after a sign-out
+    /// or wipe cannot put the previous identity's image back.
+    var generation: UInt64 {
+        memoryLock.lock()
+        defer { memoryLock.unlock() }
+        return clearGeneration
+    }
+
+    /// Drops the write, in memory and on disk, when `clear()` ran after `generation` was captured.
+    func store(_ image: UIImage, data: Data, for uri: String, generation: UInt64) {
         guard data.count <= maxFileBytes else { return }
 
-        storeInMemory(image, for: uri)
+        storeInMemory(image, for: uri, generation: generation)
 
         diskQueue.async { [self] in
+            guard generation == self.generation else { return }
             let path = diskPath(for: uri)
             try? data.write(to: path, options: .atomic)
             trimDiskCache()
         }
     }
 
+    /// True while a failed fetch of `uri` is remembered, so the image shows its failed state without fetching again.
+    func hasRecentFailure(for uri: String) -> Bool {
+        memoryLock.lock()
+        defer { memoryLock.unlock() }
+        guard let failure = failures[uri] else { return false }
+        if let expiresAt = failure.expiresAt, currentDate() >= expiresAt {
+            failures[uri] = nil
+            return false
+        }
+        return true
+    }
+
+    /// Remembers that a fetch of `uri` failed with `error`. Like `store`, it is dropped when `clear()` ran after
+    /// `generation` was captured, and a cancelled fetch is not remembered.
+    func rememberFailure(_ error: Error, for uri: String, generation: UInt64) {
+        guard !(error is CancellationError) else { return }
+        let expiresAt = Self.isPermanentFailure(error) ? nil : currentDate().addingTimeInterval(PubkyImagePolicy.transientFailureTTL)
+
+        memoryLock.lock()
+        defer { memoryLock.unlock() }
+        guard generation == clearGeneration else { return }
+        failures[uri] = Failure(expiresAt: expiresAt)
+    }
+
+    /// A missing file, or one over the download limit, stays that way until the profile points at another image.
+    private static func isPermanentFailure(_ error: Error) -> Bool {
+        if case .profileNotFound? = error as? PubkyServiceError {
+            return true
+        }
+        if case .fileTooLarge? = error as? PubkyImageError {
+            return true
+        }
+        switch error as? PaykitError {
+        case .NotFound?:
+            return true
+        case let .Protocol(_, context)?:
+            return context.contains("exceeds maximum size")
+        default:
+            return false
+        }
+    }
+
     func clear() async {
         clearMemoryCache()
 
@@ -251,7 +349,9 @@ final class PubkyImageCache: @unchecked Sendable {
 
     private func clearMemoryCache() {
         memoryLock.lock()
+        clearGeneration &+= 1
         memoryCache.removeAll()
+        failures.removeAll()
         memoryCost = 0
         memoryLock.unlock()
     }
@@ -270,12 +370,13 @@ final class PubkyImageCache: @unchecked Sendable {
         return cgImage.bytesPerRow * cgImage.height
     }
 
-    private func storeInMemory(_ image: UIImage, for uri: String) {
+    private func storeInMemory(_ image: UIImage, for uri: String, generation: UInt64) {
         let cost = Self.memoryCost(of: image)
 
         memoryLock.lock()
         defer { memoryLock.unlock() }
 
+        guard generation == clearGeneration else { return }
         if let replaced = memoryCache.removeValue(forKey: uri) {
             memoryCost -= replaced.cost
         }