fixes

backend/internal/api/hydration.go

···
 
 	missingDIDs := make([]string, 0)
 	for _, did := range dids {
-		if author, ok := Cache.Get(did); ok {
+		if author, ok := Cache.Get(did); ok && author.Handle != "" {
 			profiles[did] = author
 		} else {
 			missingDIDs = append(missingDIDs, did)
···
 
 		stillMissing := make([]string, 0)
 		for _, did := range missingDIDs {
-			if _, ok := profiles[did]; !ok {
+			if p, ok := profiles[did]; !ok || p.Handle == "" {
 				stillMissing = append(stillMissing, did)
 			}
 		}

web/src/components/feed/FeedItems.tsx

···
 
 const LIMIT = 50;
 
+const feedCache = new Map<
+  string,
+  {
+    items: AnnotationItem[];
+    hasMore: boolean;
+    offset: number;
+    timestamp: number;
+  }
+>();
+
 export interface FeedItemsProps extends Omit<
   GetFeedParams,
   "limit" | "offset"
···
 
   useEffect(() => {
     let cancelled = false;
+    const cacheKey = JSON.stringify({ type, motivation, tag, creator, source });
+    const cached = feedCache.get(cacheKey);
 
+    if (cached && Date.now() - cached.timestamp < 5 * 60 * 1000) {
+      setItems(cached.items);
+      setHasMore(cached.hasMore);
+      setOffset(cached.offset);
+      setLoading(false);
+
+      getFeed({ type, motivation, tag, creator, source, limit: LIMIT, offset: 0 })
+        .then((data) => {
+          if (cancelled) return;
+          const fetched = data.items;
+          setItems(fetched);
+          setHasMore(data.hasMore);
+          setOffset(data.fetchedCount);
+          feedCache.set(cacheKey, { items: fetched, hasMore: data.hasMore, offset: data.fetchedCount, timestamp: Date.now() });
+        })
+        .catch(console.error);
+        
+      return () => { cancelled = true; };
+    }
+
+    setLoading(true);
     getFeed({ type, motivation, tag, creator, source, limit: LIMIT, offset: 0 })
       .then((data) => {
         if (cancelled) return;
···
         setHasMore(data.hasMore);
         setOffset(data.fetchedCount);
         setLoading(false);
+        feedCache.set(cacheKey, { items: fetched, hasMore: data.hasMore, offset: data.fetchedCount, timestamp: Date.now() });
       })
       .catch((e) => {
         if (cancelled) return;
···
   const loadMore = useCallback(async () => {
     setLoadingMore(true);
     try {
+      const cacheKey = JSON.stringify({ type, motivation, tag, creator, source });
       const data = await getFeed({
         type,
         motivation,
···
         offset,
       });
       const fetched = data?.items || [];
-      setItems((prev) => [...prev, ...fetched]);
+      const newItems = [...items, ...fetched];
+      setItems(newItems);
       setHasMore(data.hasMore);
-      setOffset((prev) => prev + data.fetchedCount);
+      const newOffset = offset + data.fetchedCount;
+      setOffset(newOffset);
+      feedCache.set(cacheKey, { items: newItems, hasMore: data.hasMore, offset: newOffset, timestamp: Date.now() });
     } catch (e) {
       console.error(e);
     } finally {
       setLoadingMore(false);
     }
-  }, [type, motivation, tag, creator, source, offset]);
+  }, [type, motivation, tag, creator, source, offset, items]);
 
   const handleDelete = (uri: string) => {
     setItems((prev) => prev.filter((i) => i.uri !== uri));

web/src/pages/og-image.ts

···
       const item = await res.json();
       const author = item.author || item.creator || {};
       const handle = author.handle || "";
-      const displayName = author.displayName || handle || "someone";
+      const did = author.did || "";
+      const authorName = handle ? `@${handle}` : did || "someone";
+      const displayName = author.displayName || handle || did || "someone";
       const avatarURL = author.avatar || "";
       const targetSource = item.target?.source || item.url || item.source || "";
       const domain = targetSource
···
       ) {
         return {
           type: "highlight",
-          author: handle ? `@${handle}` : "someone",
+          author: authorName,
           displayName,
           avatarURL,
           text: targetTitle,
···
       if (uri.includes("/at.margin.bookmark/")) {
         return {
           type: "bookmark",
-          author: handle ? `@${handle}` : "someone",
+          author: authorName,
           displayName,
           avatarURL,
           text: item.title || targetTitle || "Bookmark",
···
 
       return {
         type: "annotation",
-        author: handle ? `@${handle}` : "someone",
+        author: authorName,
         displayName,
         avatarURL,
         text: bodyText,
···
       const item = await res.json();
       const author = item.author || item.creator || {};
       const handle = author.handle || "";
-      const displayName = author.displayName || handle || "someone";
+      const did = author.did || "";
+      const authorName = handle ? `@${handle}` : did || "someone";
+      const displayName = author.displayName || handle || did || "someone";
       const avatarURL = author.avatar || "";
 
       return {
         type: "collection",
-        author: handle ? `@${handle}` : "someone",
+        author: authorName,
         displayName,
         avatarURL,
         text: "",

web/src/store/auth.ts

···
 export const $user = atom<UserProfile | null>(null);
 export const $isLoading = atom<boolean>(true);
 
+$user.subscribe((user) => {
+  if (user) {
+    loadPreferences();
+  }
+});
+
 export async function initAuth() {
   $isLoading.set(true);
   const session = await checkSession();
   $user.set(session);
   $isLoading.set(false);
-  if (session) {
-    loadPreferences();
-  }
 }
 
 export function logout() {

web/src/views/collections/Collections.tsx

···
 import { clsx } from "clsx";
 import { Button, Input, EmptyState, Skeleton } from "../../components/ui";
 
+const collectionsCache = {
+  data: null as Collection[] | null,
+  timestamp: 0,
+};
+
 export default function Collections() {
   const user = useStore($user);
   const theme = useStore($theme);
···
   const [creating, setCreating] = useState(false);
 
   const fetchCollections = async () => {
+    if (collectionsCache.data && Date.now() - collectionsCache.timestamp < 5 * 60 * 1000) {
+      setCollections(collectionsCache.data);
+      setLoading(false);
+      
+      getCollections().then(data => {
+        setCollections(data);
+        collectionsCache.data = data;
+        collectionsCache.timestamp = Date.now();
+      }).catch(console.error);
+      return;
+    }
+
     try {
       setLoading(true);
       const data = await getCollections();
       setCollections(data);
+      collectionsCache.data = data;
+      collectionsCache.timestamp = Date.now();
     } catch (error) {
       console.error("Failed to load collections:", error);
     } finally {
···
 
     const res = await createCollection(newItemName, newItemDesc, finalIcon);
     if (res) {
-      setCollections([res, ...collections]);
+      const newCollections = [res, ...collections];
+      setCollections(newCollections);
+      collectionsCache.data = newCollections;
+      collectionsCache.timestamp = Date.now();
       setShowCreateModal(false);
       setNewItemName("");
       setNewItemDesc("");
···
     if (window.confirm("Delete this collection?")) {
       const success = await deleteCollection(id);
       if (success) {
-        setCollections((prev) => prev.filter((c) => c.id !== id));
+        setCollections((prev) => {
+          const updated = prev.filter((c) => c.id !== id);
+          collectionsCache.data = updated;
+          collectionsCache.timestamp = Date.now();
+          return updated;
+        });
       }
     }
   };

web/src/views/core/Notifications.tsx

···
 import { clsx } from "clsx";
 import { Avatar, EmptyState, Skeleton } from "../../components/ui";
 
+const notificationsCache = {
+  data: null as NotificationItem[] | null,
+  timestamp: 0,
+};
+
 function getContentType(
   uri: string,
 ): "annotation" | "highlight" | "bookmark" | "reply" | "unknown" {
···
 
   useEffect(() => {
     const load = async () => {
+      if (notificationsCache.data && Date.now() - notificationsCache.timestamp < 5 * 60 * 1000) {
+        setNotifications(notificationsCache.data);
+        setLoading(false);
+        
+        getNotifications().then(data => {
+          setNotifications(data);
+          notificationsCache.data = data;
+          notificationsCache.timestamp = Date.now();
+        }).catch(console.error);
+        
+        markNotificationsRead();
+        return;
+      }
+
       setLoading(true);
       const data = await getNotifications();
       setNotifications(data);
+      notificationsCache.data = data;
+      notificationsCache.timestamp = Date.now();
       setLoading(false);
       markNotificationsRead();
     };

web/src/views/core/Search.tsx

···
 import { $user } from "../../store/auth";
 import { $feedLayout } from "../../store/feedLayout";
 
+const searchCache = new Map<
+  string,
+  {
+    results: AnnotationItem[];
+    hasMore: boolean;
+    offset: number;
+    timestamp: number;
+  }
+>();
+
 interface SearchProps {
   initialQuery?: string;
 }
···
         setResults([]);
         return;
       }
+      
+      const cacheKey = JSON.stringify({ q: q.trim(), myItemsOnly: myItemsRef.current });
+      
+      if (!append && newOffset === 0) {
+        const cached = searchCache.get(cacheKey);
+        if (cached && Date.now() - cached.timestamp < 5 * 60 * 1000) {
+          setResults(cached.results);
+          setHasMore(cached.hasMore);
+          setOffset(cached.offset);
+          setLoading(false);
+          
+          const id = ++fetchIdRef.current;
+          searchItems(q.trim(), {
+            creator: myItemsRef.current && user ? user.did : undefined,
+            limit: 30,
+            offset: newOffset,
+          }).then(data => {
+            if (id !== fetchIdRef.current) return;
+            setResults(data.items);
+            setHasMore(data.hasMore);
+            setOffset(newOffset + data.items.length);
+            searchCache.set(cacheKey, { results: data.items, hasMore: data.hasMore, offset: newOffset + data.items.length, timestamp: Date.now() });
+          }).catch(console.error);
+          
+          return;
+        }
+      }
+
       const id = ++fetchIdRef.current;
       setLoading(true);
       const data = await searchItems(q.trim(), {
···
       });
       if (id !== fetchIdRef.current) return;
       if (append) {
-        setResults((prev) => [...prev, ...data.items]);
+        setResults((prev) => {
+          const newResults = [...prev, ...data.items];
+          searchCache.set(cacheKey, { results: newResults, hasMore: data.hasMore, offset: newOffset + data.items.length, timestamp: Date.now() });
+          return newResults;
+        });
       } else {
         setResults(data.items);
+        searchCache.set(cacheKey, { results: data.items, hasMore: data.hasMore, offset: newOffset + data.items.length, timestamp: Date.now() });
       }
       setHasMore(data.hasMore);
       setOffset(newOffset + data.items.length);

web/src/views/profile/Profile.tsx

···
   UserProfile,
 } from "../../types";
 
+const profileCache = new Map<
+  string,
+  {
+    profile: UserProfile;
+    labels: ContentLabel[];
+    relation: ModerationRelationship;
+    timestamp: number;
+  }
+>();
+
+const profileCollectionsCache = new Map<
+  string,
+  {
+    collections: Collection[];
+    timestamp: number;
+  }
+>();
+
 interface ProfileProps {
   did: string;
 }
···
     setLoading(true);
 
     const loadProfile = async () => {
+      const cached = profileCache.get(did);
+      if (cached && Date.now() - cached.timestamp < 5 * 60 * 1000) {
+        setProfile(cached.profile);
+        setAccountLabels(cached.labels);
+        setModRelation(cached.relation);
+        setLoading(false);
+      } else {
+        setLoading(true);
+      }
+
       try {
         const marginPromise = getProfile(did);
         const bskyPromise = fetch(
···
           try {
             const rel = await getModerationRelationship(did);
             setModRelation(rel);
+            profileCache.set(did, { profile: merged, labels: marginData?.labels || [], relation: rel, timestamp: Date.now() });
           } catch {
-            // ignore
+            profileCache.set(did, { profile: merged, labels: marginData?.labels || [], relation: modRelation, timestamp: Date.now() });
           }
+        } else {
+          profileCache.set(did, { profile: merged, labels: marginData?.labels || [], relation: modRelation, timestamp: Date.now() });
         }
       } catch (e) {
         console.error("Profile load failed", e);
···
       setDataLoading(true);
       try {
         if (activeTab === "collections") {
+          const cached = profileCollectionsCache.get(resolvedDid);
+          if (cached && Date.now() - cached.timestamp < 5 * 60 * 1000) {
+            setCollections(cached.collections);
+            setDataLoading(false);
+          }
           const res = await getCollections(resolvedDid);
           setCollections(res);
+          profileCollectionsCache.set(resolvedDid, { collections: res, timestamp: Date.now() });
         }
       } catch (e) {
         console.error(e);