From 13653b4995f702eda1d8ed63fe0766f9e0e371fb Mon Sep 17 00:00:00 2001
From: Kieran Klukas <me@dunkirk.sh>
Date: Mon, 23 Mar 2026 22:54:49 -0400
Subject: [PATCH] feat: interleave loading front and behind

---
 cull/Services/ThumbnailCache.swift | 10 ++++++++--
 cull/Views/PhotoViewer.swift       | 23 +++++++++++++++++------
 2 files changed, 25 insertions(+), 8 deletions(-)

diff --git a/cull/Services/ThumbnailCache.swift b/cull/Services/ThumbnailCache.swift
index 72fde26..5122574 100644
--- a/cull/Services/ThumbnailCache.swift
+++ b/cull/Services/ThumbnailCache.swift
@@ -7,6 +7,7 @@ final class ThumbnailCache {
     private let memoryCache = NSCache<NSString, NSImage>()
     private let previewCache = NSCache<NSString, NSImage>()
     private var previewKeys = Set<String>()
+    private var preloadTask: Task<Void, Never>?
     private let diskCacheURL: URL
     private let maxPixelSize: Int
 
@@ -206,7 +207,10 @@ final class ThumbnailCache {
     }
 
     /// Fire-and-forget: preload previews in background. Used during navigation.
+    /// Cancels any previous preload so stale work doesn't compete.
     func preloadPreviews(photos: [Photo]) {
+        preloadTask?.cancel()
+
         let work: [(String, URL)] = photos.compactMap { photo in
             let key = photo.url.absoluteString
             guard previewCache.object(forKey: key as NSString) == nil else { return nil }
@@ -216,13 +220,15 @@ final class ThumbnailCache {
 
         let pc = previewCache
 
-        Task.detached(priority: .utility) {
+        preloadTask = Task.detached(priority: .utility) {
             for batchStart in stride(from: 0, to: work.count, by: 4) {
+                guard !Task.isCancelled else { return }
                 let batch = Array(work[batchStart..<min(batchStart + 4, work.count)])
                 await withTaskGroup(of: (String, NSImage?).self) { group in
                     for (key, url) in batch {
                         group.addTask {
-                            (key, Self.loadFullPreviewSync(from: url))
+                            guard !Task.isCancelled else { return (key, nil) }
+                            return (key, Self.loadFullPreviewSync(from: url))
                         }
                     }
                     for await (key, image) in group {
diff --git a/cull/Views/PhotoViewer.swift b/cull/Views/PhotoViewer.swift
index 8fb19f3..3aa4ac6 100644
--- a/cull/Views/PhotoViewer.swift
+++ b/cull/Views/PhotoViewer.swift
@@ -72,6 +72,15 @@ struct PhotoViewer: View {
             guard let photo = session.selectedPhoto else { return }
             let photoID = photo.id
 
+            // If full-res is already cached, show it immediately
+            if let cached = cache.cachedPreview(for: photo) {
+                displayImage = cached
+            }
+
+            // Wait for user to stop navigating before doing any loading
+            try? await Task.sleep(for: .milliseconds(100))
+            guard !Task.isCancelled, displayedPhotoID == photoID else { return }
+
             // Load current photo's full-res preview
             if cache.cachedPreview(for: photo) == nil {
                 if let full = await cache.previewImage(for: photo) {
@@ -80,15 +89,17 @@ struct PhotoViewer: View {
                 }
             }
 
-            // Debounce: wait briefly before preloading window
-            // If user is holding arrow keys, this task gets cancelled before preload fires
-            guard displayedPhotoID == photoID else { return }
-            try? await Task.sleep(for: .milliseconds(150))
+            // Preload window fanning out from current position (closest first)
             guard !Task.isCancelled, displayedPhotoID == photoID else { return }
-
             let ahead = session.photosAhead(lookaheadCount)
             let behind = session.photosBehind(lookbehindCount)
-            let window = behind + [photo] + ahead
+            var fanOut: [Photo] = []
+            let maxLen = max(ahead.count, behind.count)
+            for i in 0..<maxLen {
+                if i < ahead.count { fanOut.append(ahead[i]) }
+                if i < behind.count { fanOut.append(behind[i]) }
+            }
+            let window = [photo] + fanOut
             cache.preloadPreviews(photos: window)
             cache.evictPreviews(keeping: window)
         }
-- 
2.51.2