add useCallback to hook-returned functions

src/hooks/useFollows.ts

···
-import { useState } from "react";
+import { useState, useCallback } from "react";
 import { apiClient } from "../lib/api/client";
 import { FOLLOW_CONFIG } from "../config/constants";
 import { getAtprotoApp } from "../lib/utils/platform";
···
   const [isFollowing, setIsFollowing] = useState(false);
   const [isCheckingFollowStatus, setIsCheckingFollowStatus] = useState(false);
 
-  async function followSelectedUsers(
+  const followSelectedUsers = useCallback(async (
     onUpdate: (message: string) => void,
-  ): Promise<void> {
+  ): Promise<void> => {
     if (!session || isFollowing) return;
 
     const destinationApp = getAtprotoApp(destinationAppId);
···
     } finally {
       setIsFollowing(false);
     }
-  }
+  }, [session, searchResults, setSearchResults, destinationAppId, isFollowing]);
 
   return {
     isFollowing,

src/hooks/useSearch.ts

···
-import { useState } from "react";
+import { useState, useCallback } from "react";
 import { apiClient } from "../lib/api/client";
 import { SEARCH_CONFIG } from "../config/constants";
 import type { SearchResult, SearchProgress, AtprotoSession } from "../types";
···
     new Set(),
   );
 
-  async function searchAllUsers(
+  const searchAllUsers = useCallback(async (
     resultsToSearch: SearchResult[],
     onProgressUpdate: (message: string) => void,
     onComplete: () => void,
     followLexicon?: string,
-  ) {
+  ) => {
     if (!session || resultsToSearch.length === 0) return;
 
     setIsSearchingAll(true);
···
       `Search complete! Found ${totalFound} matches out of ${totalSearched} users searched.`,
     );
     onComplete();
-  }
+  }, [session]);
 
-  function toggleMatchSelection(resultIndex: number, did: string) {
+  const toggleMatchSelection = useCallback((resultIndex: number, did: string) => {
     setSearchResults((prev) => {
       // Only update the specific item instead of mapping entire array
       const newResults = [...prev];
···
       newResults[resultIndex] = { ...result, selectedMatches: newSelectedMatches };
       return newResults;
     });
-  }
+  }, []);
 
-  function toggleExpandResult(index: number) {
+  const toggleExpandResult = useCallback((index: number) => {
     setExpandedResults((prev) => {
       const next = new Set(prev);
       if (next.has(index)) next.delete(index);
       else next.add(index);
       return next;
     });
-  }
+  }, []);
 
-  function selectAllMatches(onUpdate: (message: string) => void) {
-    setSearchResults((prev) =>
-      prev.map((result) => {
+  const selectAllMatches = useCallback((onUpdate: (message: string) => void) => {
+    setSearchResults((prev) => {
+      const updated = prev.map((result) => {
         const newSelectedMatches = new Set<string>();
         if (result.atprotoMatches.length > 0) {
           newSelectedMatches.add(result.atprotoMatches[0].did);
···
           ...result,
           selectedMatches: newSelectedMatches,
         };
-      }),
-    );
+      });
 
-    const totalToSelect = searchResults.filter(
-      (r) => r.atprotoMatches.length > 0,
-    ).length;
-    onUpdate(`Selected ${totalToSelect} top matches`);
-  }
+      const totalToSelect = updated.filter(
+        (r) => r.atprotoMatches.length > 0,
+      ).length;
+      onUpdate(`Selected ${totalToSelect} top matches`);
+
+      return updated;
+    });
+  }, []);
 
-  function deselectAllMatches(onUpdate: (message: string) => void) {
+  const deselectAllMatches = useCallback((onUpdate: (message: string) => void) => {
     setSearchResults((prev) =>
       prev.map((result) => ({
         ...result,
···
       })),
     );
     onUpdate("Cleared all selections");
-  }
+  }, []);
 
   const totalSelected = searchResults.reduce(
     (total, result) => total + (result.selectedMatches?.size || 0),