Speed up avatar fetching

src/main.rs

···
             .service(routes::get_mst)
             .service(routes::init)
             .service(routes::get_avatar)
+            .service(routes::get_avatar_batch)
             .service(routes::validate_url)
             .service(routes::get_record)
             .service(routes::auth_status)

src/routes.rs

···
 use atrium_oauth::{AuthorizeOptions, CallbackParams, KnownScope, OAuthSession, Scope};
 use dashmap::DashMap;
 use futures_util::future;
+use futures_util::stream::{FuturesUnordered, StreamExt};
 use once_cell::sync::Lazy;
 use serde::Deserialize;
 use serde::Serialize;
-use std::collections::HashMap;
+use std::collections::{HashMap, HashSet};
 use std::sync::{Arc, Mutex};
-use std::time::Instant;
+use std::time::{Duration, Instant};
 
 use crate::constants;
 use crate::firehose::FirehoseManager;
···
 
 static DID_CACHE: Lazy<DashMap<String, CachedDid>> = Lazy::new(DashMap::new);
 
+static HTTP_CLIENT: Lazy<reqwest::Client> = Lazy::new(|| {
+    reqwest::Client::builder()
+        .user_agent("at-me/1.0 (+https://at-me.zzstoatzz.io)")
+        .pool_idle_timeout(Some(Duration::from_secs(30)))
+        .connect_timeout(Duration::from_secs(4))
+        .timeout(Duration::from_secs(6))
+        .build()
+        .expect("failed to build shared http client")
+});
+
+async fn http_get(url: &str) -> Result<reqwest::Response, reqwest::Error> {
+    HTTP_CLIENT.get(url).send().await
+}
+
 // Guestbook signature struct
 #[derive(Serialize, Clone)]
 #[serde(rename_all = "camelCase")]
···
         // Handle provided - resolve to DID
         let resolve_url = format!("{}?handle={}", constants::BSKY_API_RESOLVE_HANDLE, handle);
 
-        match reqwest::get(&resolve_url).await {
+        match http_get(&resolve_url).await {
             Ok(response) => match response.json::<serde_json::Value>().await {
                 Ok(data) => match data["did"].as_str() {
                     Some(did) => did.to_string(),
···
 async fn try_resolve_handle_to_did(handle: &str) -> Option<String> {
     let resolve_url = format!("{}?handle={}", constants::BSKY_API_RESOLVE_HANDLE, handle);
 
-    match reqwest::get(&resolve_url).await {
+    match http_get(&resolve_url).await {
         Ok(response) => match response.json::<serde_json::Value>().await {
             Ok(data) => data["did"].as_str().map(String::from),
             Err(_) => None,
···
 
     // Fetch DID document
     let did_doc_url = format!("{}/{}", constants::PLC_DIRECTORY, did);
-    let did_doc_response = match reqwest::get(&did_doc_url).await {
+    let did_doc_response = match http_get(&did_doc_url).await {
         Ok(r) => r,
         Err(e) => {
             return HttpResponse::InternalServerError().json(serde_json::json!({
···
 
     // Fetch collections from PDS
     let repo_url = format!("{}/xrpc/com.atproto.repo.describeRepo?repo={}", pds, did);
-    let repo_response = match reqwest::get(&repo_url).await {
+    let repo_response = match http_get(&repo_url).await {
         Ok(r) => r,
         Err(e) => {
             return HttpResponse::InternalServerError().json(serde_json::json!({
···
 
 async fn fetch_user_avatar(did: &str) -> Option<String> {
     let profile_url = format!("{}?actor={}", constants::BSKY_API_GET_PROFILE, did);
-    if let Ok(response) = reqwest::get(&profile_url).await {
+    if let Ok(response) = http_get(&profile_url).await {
         if let Ok(profile) = response.json::<serde_json::Value>().await {
             return profile["avatar"].as_str().map(String::from);
         }
···
 #[derive(Deserialize)]
 pub struct AvatarQuery {
     namespace: String,
+}
+
+#[derive(Deserialize)]
+pub struct AvatarBatchRequest {
+    namespaces: Vec<String>,
 }
 
 #[get("/api/avatar")]
···
         }))
 }
 
-async fn fetch_avatar_for_namespace(namespace: &str) -> Option<String> {
-    // Reverse namespace to get domain (e.g., io.zzstoatzz -> zzstoatzz.io)
-    let reversed: String = namespace.split('.').rev().collect::<Vec<&str>>().join(".");
-    let handles = [reversed.clone(), format!("{}.bsky.social", reversed)];
+#[post("/api/avatar/batch")]
+pub async fn get_avatar_batch(payload: web::Json<AvatarBatchRequest>) -> HttpResponse {
+    let mut requested: Vec<String> = Vec::new();
+    let mut seen = HashSet::new();
 
-    // Try all handles concurrently
-    let futures: Vec<_> = handles
-        .iter()
-        .map(|handle| try_fetch_avatar_for_handle(handle))
-        .collect();
+    for raw in &payload.namespaces {
+        let trimmed = raw.trim();
+        if trimmed.is_empty() {
+            continue;
+        }
+        if seen.insert(trimmed.to_string()) {
+            requested.push(trimmed.to_string());
+        }
+    }
 
-    // Wait for all futures and return first successful result
-    let results = future::join_all(futures).await;
+    let mut avatars: HashMap<String, Option<String>> = HashMap::new();
+    let mut to_fetch: Vec<String> = Vec::new();
 
-    results.into_iter().flatten().next()
-}
+    {
+        let cache = AVATAR_CACHE.lock().unwrap();
+        for namespace in &requested {
+            if let Some(entry) = cache.get(namespace) {
+                if entry.timestamp.elapsed() < constants::CACHE_TTL {
+                    avatars.insert(namespace.clone(), entry.url.clone());
+                    continue;
+                }
+            }
+            to_fetch.push(namespace.clone());
+        }
+    }
 
-async fn try_fetch_avatar_for_handle(handle: &str) -> Option<String> {
-    // Try to resolve handle to DID
-    let resolve_url = format!("{}?handle={}", constants::BSKY_API_RESOLVE_HANDLE, handle);
+    if !to_fetch.is_empty() {
+        let mut futures: FuturesUnordered<_> = to_fetch
+            .into_iter()
+            .map(|namespace| async move {
+                let avatar_url = fetch_avatar_for_namespace(&namespace).await;
+                (namespace, avatar_url)
+            })
+            .collect();
 
-    let did = match reqwest::get(&resolve_url).await {
-        Ok(response) => match response.json::<serde_json::Value>().await {
-            Ok(data) => data["did"].as_str()?.to_string(),
-            Err(_) => return None,
-        },
-        Err(_) => return None,
-    };
+        while let Some((namespace, avatar_url)) = futures.next().await {
+            {
+                let mut cache = AVATAR_CACHE.lock().unwrap();
+                cache.insert(
+                    namespace.clone(),
+                    CachedAvatar {
+                        url: avatar_url.clone(),
+                        timestamp: Instant::now(),
+                    },
+                );
+            }
+            avatars.insert(namespace, avatar_url);
+        }
+    }
 
-    // Try to get profile
-    let profile_url = format!("{}?actor={}", constants::BSKY_API_GET_PROFILE, did);
+    HttpResponse::Ok()
+        .insert_header(("Cache-Control", constants::HTTP_CACHE_CONTROL))
+        .json(serde_json::json!({
+            "avatars": avatars
+        }))
+}
 
-    match reqwest::get(&profile_url).await {
-        Ok(response) => match response.json::<serde_json::Value>().await {
-            Ok(profile) => profile["avatar"].as_str().map(String::from),
-            Err(_) => None,
-        },
-        Err(_) => None,
+async fn fetch_avatar_for_namespace(namespace: &str) -> Option<String> {
+    if let Some(did) = resolve_namespace_to_did(namespace).await {
+        return fetch_user_avatar(&did).await;
     }
+    None
 }
 
 #[derive(Deserialize)]
···
         query.pds, query.did, query.collection, query.rkey
     );
 
-    match reqwest::get(&record_url).await {
+    match http_get(&record_url).await {
         Ok(response) => {
             if !response.status().is_success() {
                 return HttpResponse::Ok().json(serde_json::json!({
···
 async fn fetch_profile_info(did: &str) -> (Option<String>, Option<String>) {
     // Fetch DID document for handle
     let did_doc_url = format!("{}/{}", constants::PLC_DIRECTORY, did);
-    let handle = if let Ok(response) = reqwest::get(&did_doc_url).await {
+    let handle = if let Ok(response) = http_get(&did_doc_url).await {
         if let Ok(doc) = response.json::<serde_json::Value>().await {
             doc["alsoKnownAs"]
                 .as_array()
···
 
     log::info!("Fetching guestbook signatures from UFOs API");
 
-    let response = reqwest::get(&ufos_url)
+    let response = http_get(&ufos_url)
         .await
         .map_err(|e| format!("failed to fetch from UFOs API: {}", e))?;
 
···
 
     // Fetch DID document to get PDS URL
     let did_doc_url = format!("{}/{}", constants::PLC_DIRECTORY, did);
-    let pds = match reqwest::get(&did_doc_url).await {
+    let pds = match http_get(&did_doc_url).await {
         Ok(response) => match response.json::<serde_json::Value>().await {
             Ok(doc) => doc["service"]
                 .as_array()
···
         constants::GUESTBOOK_COLLECTION
     );
 
-    match reqwest::get(&records_url).await {
+    match http_get(&records_url).await {
         Ok(response) => {
             if !response.status().is_success() {
                 // No records found or collection doesn't exist
···
 
     // Fetch DID document to get PDS
     let did_doc_url = format!("{}/{}", constants::PLC_DIRECTORY, did);
-    let did_doc = match reqwest::get(&did_doc_url).await {
+    let did_doc = match http_get(&did_doc_url).await {
         Ok(r) => match r.json::<serde_json::Value>().await {
             Ok(d) => d,
             Err(e) => {
···
 
     // Fetch collections from PDS
     let repo_url = format!("{}/xrpc/com.atproto.repo.describeRepo?repo={}", pds, did);
-    let mut collections = match reqwest::get(&repo_url).await {
+    let mut collections = match http_get(&repo_url).await {
         Ok(r) => match r.json::<serde_json::Value>().await {
             Ok(repo_data) => repo_data["collections"]
                 .as_array()

src/templates/landing.html

···
             }
         }
 
-        async function fetchAppAvatar(namespace) {
-            const reversed = namespace.split('.').reverse().join('.');
-            const handles = [reversed, `${reversed}.bsky.social`];
+        async function fetchAppAvatars(namespaces) {
+            if (!Array.isArray(namespaces) || !namespaces.length) return {};
+            const deduped = [...new Set(namespaces.filter(Boolean))];
+            if (!deduped.length) return {};
 
-            for (const handle of handles) {
-                try {
-                    const didRes = await fetch(`https://public.api.bsky.app/xrpc/com.atproto.identity.resolveHandle?handle=${handle}`);
-                    if (!didRes.ok) continue;
-
-                    const { did } = await didRes.json();
-                    const profileRes = await fetch(`https://public.api.bsky.app/xrpc/app.bsky.actor.getProfile?actor=${did}`);
-                    if (!profileRes.ok) continue;
-
-                    const profile = await profileRes.json();
-                    if (profile.avatar) return profile.avatar;
-                } catch (e) {
-                    continue;
-                }
+            try {
+                const response = await fetch('/api/avatar/batch', {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({ namespaces: deduped })
+                });
+                if (!response.ok) return {};
+                const data = await response.json();
+                return data.avatars || {};
+            } catch (e) {
+                return {};
             }
-            return null;
         }
 
         async function renderAtmosphere() {
···
 
             const atmosphere = document.getElementById('atmosphere');
             const maxSize = Math.max(...data.map(d => d.dids_total));
+
+            const namespaces = data.map(app => app.namespace);
+            const avatarPromise = fetchAppAvatars(namespaces);
+            const orbRegistry = [];
 
             data.forEach((app, i) => {
                 const orb = document.createElement('div');
···
 
                 atmosphere.appendChild(orb);
 
-                // Fetch and apply avatar
-                fetchAppAvatar(app.namespace).then(avatarUrl => {
+                orbRegistry.push({ orb, tooltip, namespace: app.namespace });
+            });
+
+            avatarPromise.then(avatarMap => {
+                orbRegistry.forEach(({ orb, tooltip, namespace }) => {
+                    const avatarUrl = avatarMap[namespace];
                     if (avatarUrl) {
-                        orb.innerHTML = `<img src="${avatarUrl}" alt="${app.namespace}" />`;
+                        orb.innerHTML = `<img src="${avatarUrl}" alt="${namespace}" />`;
                         orb.appendChild(tooltip);
                     }
                 });

static/app.js

···
     }
 }
 
+async function fetchAppAvatars(namespaces) {
+    if (!Array.isArray(namespaces) || namespaces.length === 0) return {};
+    const uniqueNamespaces = [...new Set(namespaces.filter(Boolean))];
+    if (!uniqueNamespaces.length) return {};
+
+    try {
+        const response = await fetch('/api/avatar/batch', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ namespaces: uniqueNamespaces })
+        });
+        if (!response.ok) return {};
+        const data = await response.json();
+        return data.avatars || {};
+    } catch (e) {
+        return {};
+    }
+}
+
 // Info modal handlers
 document.getElementById('infoBtn').addEventListener('click', () => {
     document.getElementById('infoModal').classList.add('visible');
···
             return { div, namespace };
         });
 
-        // Fetch all avatars concurrently
-        Promise.all(appNames.map(namespace => fetchAppAvatar(namespace)))
-            .then(avatarUrls => {
-                avatarUrls.forEach((avatarUrl, i) => {
-                    if (avatarUrl) {
-                        const circle = appDivs[i].div.querySelector('.app-circle');
-                        circle.innerHTML = `<img src="${avatarUrl}" class="app-logo" alt="${appDivs[i].namespace}" />`;
-                    }
-                });
+        // Fetch all avatars concurrently via batch endpoint
+        fetchAppAvatars(appNames).then(avatarMap => {
+            appDivs.forEach(({ div, namespace }) => {
+                const avatarUrl = avatarMap[namespace];
+                if (avatarUrl) {
+                    const circle = div.querySelector('.app-circle');
+                    circle.innerHTML = `<img src="${avatarUrl}" class="app-logo" alt="${namespace}" />`;
+                }
             });
+        });
 
         appDivs.forEach(({ div, namespace }, i) => {
             // Reverse namespace for display and create URL

static/login.js

···
     }
 }
 
-// Try to fetch app avatar
-async function fetchAppAvatar(namespace) {
-    const reversed = namespace.split('.').reverse().join('.');
-    const handles = [reversed, `${reversed}.bsky.social`];
+async function fetchAppAvatars(namespaces) {
+    if (!Array.isArray(namespaces) || !namespaces.length) return {};
+    const deduped = [...new Set(namespaces.filter(Boolean))];
+    if (!deduped.length) return {};
 
-    for (const handle of handles) {
-        try {
-            const didRes = await fetch(`https://public.api.bsky.app/xrpc/com.atproto.identity.resolveHandle?handle=${handle}`);
-            if (!didRes.ok) continue;
-
-            const { did } = await didRes.json();
-            const profileRes = await fetch(`https://public.api.bsky.app/xrpc/app.bsky.actor.getProfile?actor=${did}`);
-            if (!profileRes.ok) continue;
-
-            const profile = await profileRes.json();
-            if (profile.avatar) return profile.avatar;
-        } catch (e) {
-            // Silently continue to next handle
-            continue;
-        }
+    try {
+        const response = await fetch('/api/avatar/batch', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ namespaces: deduped })
+        });
+        if (!response.ok) return {};
+        const data = await response.json();
+        return data.avatars || {};
+    } catch (e) {
+        return {};
     }
-    return null;
 }
 
 // Render atmosphere
···
 
     const atmosphere = document.getElementById('atmosphere');
     const maxSize = Math.max(...data.map(d => d.dids_total));
+
+    const namespaces = data.map(app => app.namespace);
+    const avatarPromise = fetchAppAvatars(namespaces);
+    const orbRegistry = [];
 
     data.forEach((app, i) => {
         const orb = document.createElement('div');
···
 
         atmosphere.appendChild(orb);
 
-        // Fetch and apply avatar
-        fetchAppAvatar(app.namespace).then(avatarUrl => {
+        orbRegistry.push({ orb, tooltip, namespace: app.namespace });
+    });
+
+    avatarPromise.then(avatarMap => {
+        orbRegistry.forEach(({ orb, tooltip, namespace }) => {
+            const avatarUrl = avatarMap[namespace];
             if (avatarUrl) {
-                orb.innerHTML = `<img src="${avatarUrl}" alt="${app.namespace}" />`;
+                orb.innerHTML = `<img src="${avatarUrl}" alt="${namespace}" />`;
                 orb.appendChild(tooltip);
             }
         });