⚡ Bolt: [performance improvement] Optimize map bucketing memory and deduplicate getMapData promises

Co-authored-by: ralksta <16941050+ralksta@users.noreply.github.com>

.jules/bolt.md

@@ -14,3 +14,7 @@
 ## 2026-04-24 - [OOM prevention through promise chunking]
 **Learning:** When fetching unbounded large collections (like photo albums and their assets), using concurrent `Promise.all` over the entire array can cause Node.js Out of Memory (OOM) crashes.
 **Action:** Instead of `Promise.all(array.map(...))`, use a chunked data fetching approach (e.g., `Promise.all` within a `for` loop processing chunks of e.g. 10 items) to balance memory constraints with concurrent network speed.
+
+## 2024-05-30 - [O(1) Memory Bucketing for Coordinate Aggregation]
+**Learning:** When bucketing or grouping large datasets (e.g., thousands of map coordinates into geographical clusters), array allocations (`[].push()`) followed by `reduce` operations create an O(N) memory overhead per bucket and expensive post-processing loops.
+**Action:** Replace memory-heavy array collections with running statistical accumulators (e.g., `latSum`, `lngSum`, `count`) directly on the bucket. This reduces bucket memory from O(N) to O(1).

lib/mapService.ts

@@ -17,12 +17,18 @@ export interface MapLocation {
  * Aggregate all geotagged photos into location-level markers.
  * Returns one entry per unique city+country with averaged lat/lng.
  */
+let pendingMapDataPromise: Promise<MapLocation[]> | null = null;
+
 export async function getMapData(): Promise<MapLocation[]> {
   const config = getConfig();
   const cacheKey = 'map-data';
   const cached = cache.get<MapLocation[]>(cacheKey);
   if (cached) return cached;
 
+  if (pendingMapDataPromise) return pendingMapDataPromise;
+
+  pendingMapDataPromise = (async () => {
+    try {
       const albums = await immich.getAlbums();
 
       // Build a lookup: album ID → { name, slug, subpageSlug? }
@@ -47,7 +53,13 @@ export async function getMapData(): Promise<MapLocation[]> {
       // Bucket assets by city+country
       const buckets = new Map<
         string,
-    { lats: number[]; lngs: number[]; count: number; coverAssetId: string; albumIds: Set<string> }
+        {
+          latSum: number;
+          lngSum: number;
+          count: number;
+          coverAssetId: string;
+          albumIds: Set<string>;
+        }
       >();
 
       for (const album of fullAlbums) {
@@ -59,11 +71,17 @@ export async function getMapData(): Promise<MapLocation[]> {
           const key = `${exif.city}|${exif.country}`;
           let bucket = buckets.get(key);
           if (!bucket) {
-        bucket = { lats: [], lngs: [], count: 0, coverAssetId: asset.id, albumIds: new Set() };
+            bucket = {
+              latSum: 0,
+              lngSum: 0,
+              count: 0,
+              coverAssetId: asset.id,
+              albumIds: new Set(),
+            };
             buckets.set(key, bucket);
           }
-      bucket.lats.push(exif.latitude);
+          bucket.latSum += exif.latitude;
-      bucket.lngs.push(exif.longitude);
+          bucket.lngSum += exif.longitude;
           bucket.count++;
           bucket.albumIds.add(album.id);
         }
@@ -73,8 +91,8 @@ export async function getMapData(): Promise<MapLocation[]> {
       const locations: MapLocation[] = [];
       for (const [key, bucket] of buckets) {
         const [city, country] = key.split('|');
-    const lat = bucket.lats.reduce((a, b) => a + b, 0) / bucket.lats.length;
+        const lat = bucket.latSum / bucket.count;
-    const lng = bucket.lngs.reduce((a, b) => a + b, 0) / bucket.lngs.length;
+        const lng = bucket.lngSum / bucket.count;
         locations.push({
           city,
           country,
@@ -90,4 +108,10 @@ export async function getMapData(): Promise<MapLocation[]> {
 
       cache.set(cacheKey, locations, config.cacheTtl);
       return locations;
+    } finally {
+      pendingMapDataPromise = null;
+    }
+  })();
+
+  return pendingMapDataPromise;
 }