better debug, change button sorting

2 files changed, 93 insertions, 7 deletions

diff --git a/src/lib/cache/autoCacheService.ts b/src/lib/cache/autoCacheService.ts
index 6d29598..b144f1d 100644
--- a/src/lib/cache/autoCacheService.ts
+++ b/src/lib/cache/autoCacheService.ts
@@ -45,6 +45,9 @@ class AutoCacheService {
   /** The AbortController for the current background download. */
   private _currentAbort: AbortController | undefined;
 
+  /** Current download speed in bytes/sec. 0 when idle. */
+  private _downloadSpeed = 0;
+
   /** The image list to work through (newest first). */
   private _images: FlashAirFileEntry[] = [];
 
@@ -100,6 +103,11 @@ class AutoCacheService {
     return this._images.length;
   }
 
+  /** Current download speed in bytes/second. 0 when not downloading. */
+  get downloadSpeed(): number {
+    return this._downloadSpeed;
+  }
+
   /** Check if a path has been confirmed fully cached. */
   isCached(path: string): boolean {
     return this._cachedPaths.has(path);
@@ -245,7 +253,7 @@ class AutoCacheService {
       if (reader === undefined) {
         const blob = await res.blob();
         if (abort.signal.aborted) return false;
-        void imageCache.put('full', image.path, blob);
+        void imageCache.put('full', image.path, blob, undefined, image.date.getTime());
         this._progressMap.set(image.path, 1);
         this._notify();
         return true;
@@ -253,6 +261,8 @@ class AutoCacheService {
 
       const chunks: Uint8Array[] = [];
       let received = 0;
+      let speedStartTime = performance.now();
+      let speedStartBytes = 0;
 
       while (true) {
         const { done, value } = await reader.read();
@@ -261,6 +271,17 @@ class AutoCacheService {
         received += value.byteLength;
         const progress = totalBytes > 0 ? received / totalBytes : 0;
         this._progressMap.set(image.path, progress);
+
+        // Calculate speed every ~500ms to avoid excessive jitter
+        const now = performance.now();
+        const elapsed = now - speedStartTime;
+        if (elapsed >= 500) {
+          const bytesInWindow = received - speedStartBytes;
+          this._downloadSpeed = Math.round(bytesInWindow / (elapsed / 1000));
+          speedStartTime = now;
+          speedStartBytes = received;
+        }
+
         this._notify();
       }
 
@@ -278,6 +299,7 @@ class AutoCacheService {
       return false;
     } finally {
       this._downloading = false;
+      this._downloadSpeed = 0;
       this._currentAbort = undefined;
     }
   }
diff --git a/src/lib/cache/imageCache.ts b/src/lib/cache/imageCache.ts
index 5ff7393..0ccb975 100644
--- a/src/lib/cache/imageCache.ts
+++ b/src/lib/cache/imageCache.ts
@@ -15,6 +15,8 @@ export interface CachedImage {
   readonly meta: ThumbnailMeta | undefined;
   /** Unix timestamp (ms) when this entry was stored. */
   readonly storedAt: number;
+  /** Unix timestamp (ms) of the file's date on the camera. Used for eviction priority. */
+  readonly fileDate: number | undefined;
 }
 
 type CacheKey = `${'thumbnail' | 'full'}:${string}`;
@@ -86,6 +88,7 @@ interface StoredRecord {
   readonly blob: Blob;
   readonly meta: ThumbnailMeta | undefined;
   readonly storedAt: number;
+  readonly fileDate: number | undefined;
 }
 
 /** Read a single record from IndexedDB. Returns undefined on any failure. */
@@ -162,8 +165,44 @@ async function idbDelete(key: CacheKey): Promise<void> {
   });
 }
 
-/** 30 days in milliseconds. */
-const CACHE_TTL_MS = 30 * 24 * 60 * 60 * 1000;
+/** 3 days in milliseconds. */
+const CACHE_TTL_MS = 3 * 24 * 60 * 60 * 1000;
+
+/** Maximum total size of cached blobs (memory + IDB). 850 MB. */
+const MAX_CACHE_BYTES = 850 * 1024 * 1024;
+
+/** Current total bytes tracked in the memory cache. */
+let memoryCacheTotalBytes = 0;
+
+/**
+ * Evict the oldest entries from the cache until we're under the size budget.
+ * Evicts from both memory and IndexedDB.
+ */
+async function evictIfOverBudget(): Promise<void> {
+  if (memoryCacheTotalBytes <= MAX_CACHE_BYTES) return;
+
+  // Sort entries for eviction: oldest camera file date first.
+  // Full images before thumbnails (evict large items first for faster budget recovery).
+  // Entries without fileDate are evicted first (they're from older cache formats).
+  const entries = [...memoryCache.entries()].sort((a, b) => {
+    // Full images before thumbnails
+    if (a[1].kind !== b[1].kind) {
+      return a[1].kind === 'full' ? -1 : 1;
+    }
+    // Entries without fileDate go first (unknown = low priority)
+    const aDate = a[1].fileDate ?? 0;
+    const bDate = b[1].fileDate ?? 0;
+    // Oldest file date first (smallest timestamp = taken earliest = evict first)
+    return aDate - bDate;
+  });
+
+  for (const [key, entry] of entries) {
+    if (memoryCacheTotalBytes <= MAX_CACHE_BYTES) break;
+    memoryCacheTotalBytes -= entry.blob.size;
+    memoryCache.delete(key);
+    void idbDelete(key);
+  }
+}
 
 function isExpired(storedAt: number): boolean {
   return Date.now() - storedAt > CACHE_TTL_MS;
@@ -183,6 +222,7 @@ export const imageCache = {
     const mem = memoryCache.get(key);
     if (mem !== undefined) {
       if (isExpired(mem.storedAt)) {
+        memoryCacheTotalBytes -= mem.blob.size;
         memoryCache.delete(key);
         void idbDelete(key);
         return undefined;
@@ -204,9 +244,11 @@ export const imageCache = {
       blob: record.blob,
       meta: record.meta,
       storedAt: record.storedAt,
+      fileDate: record.fileDate,
     };
     // Promote to memory for future fast lookups
     memoryCache.set(key, cached);
+    memoryCacheTotalBytes += cached.blob.size;
     return cached;
   },
 
@@ -218,17 +260,31 @@ export const imageCache = {
    * instantly visible to subsequent get() calls.
    * IndexedDB persistence happens in the background.
    */
-  async put(kind: 'thumbnail' | 'full', path: string, blob: Blob, meta?: ThumbnailMeta): Promise<void> {
+  async put(
+    kind: 'thumbnail' | 'full',
+    path: string,
+    blob: Blob,
+    meta?: ThumbnailMeta,
+    fileDate?: number,
+  ): Promise<void> {
     const key = makeCacheKey(kind, path);
     const storedAt = Date.now();
 
-    const cached: CachedImage = { path, kind, blob, meta, storedAt };
+    const cached: CachedImage = { path, kind, blob, meta, storedAt, fileDate };
 
-    // Instant: write to memory
+    // Instant: write to memory (replace existing if present)
+    const existing = memoryCache.get(key);
+    if (existing !== undefined) {
+      memoryCacheTotalBytes -= existing.blob.size;
+    }
     memoryCache.set(key, cached);
+    memoryCacheTotalBytes += blob.size;
+
+    // Evict oldest entries if over budget
+    void evictIfOverBudget();
 
     // Background: persist to IndexedDB
-    const record: StoredRecord = { key, path, kind, blob, meta, storedAt };
+    const record: StoredRecord = { key, path, kind, blob, meta, storedAt, fileDate };
     await idbPut(record);
   },
 
@@ -237,6 +293,10 @@ export const imageCache = {
    */
   async delete(kind: 'thumbnail' | 'full', path: string): Promise<void> {
     const key = makeCacheKey(kind, path);
+    const existing = memoryCache.get(key);
+    if (existing !== undefined) {
+      memoryCacheTotalBytes -= existing.blob.size;
+    }
     memoryCache.delete(key);
     await idbDelete(key);
   },
@@ -248,6 +308,7 @@ export const imageCache = {
     // Prune in-memory
     for (const [key, entry] of memoryCache) {
       if (isExpired(entry.storedAt)) {
+        memoryCacheTotalBytes -= entry.blob.size;
         memoryCache.delete(key);
       }
     }
@@ -294,6 +355,7 @@ export const imageCache = {
     fullCount: number;
     thumbCount: number;
     totalBytes: number;
+    maxBytes: number;
     idbEntries: number;
     idbBytes: number;
     idbError: string | undefined;
@@ -348,6 +410,7 @@ export const imageCache = {
       fullCount,
       thumbCount,
       totalBytes,
+      maxBytes: MAX_CACHE_BYTES,
       idbEntries,
       idbBytes,
       idbError,
@@ -361,6 +424,7 @@ export const imageCache = {
    */
   async clear(): Promise<void> {
     memoryCache.clear();
+    memoryCacheTotalBytes = 0;
 
     const db = await openDb();
     if (db === undefined) return;