we linted

src/App.tsx

···
   const { isDark, reducedMotion, toggleTheme, toggleMotion } = useTheme();
 
   // Add state to track current platform
-  const [currentPlatform, setCurrentPlatform] = useState<string>('tiktok');
+  const [currentPlatform, setCurrentPlatform] = useState<string>("tiktok");
   const saveCalledRef = useRef<string | null>(null); // Track by uploadId
 
   // Settings state
   const [userSettings, setUserSettings] = useState<UserSettings>(() => {
-    const saved = localStorage.getItem('atlast_settings');
+    const saved = localStorage.getItem("atlast_settings");
     return saved ? JSON.parse(saved) : DEFAULT_SETTINGS;
   });
 
   // Save settings to localStorage whenever they change
   useEffect(() => {
-    localStorage.setItem('atlast_settings', JSON.stringify(userSettings));
+    localStorage.setItem("atlast_settings", JSON.stringify(userSettings));
   }, [userSettings]);
 
   const handleSettingsUpdate = (newSettings: Partial<UserSettings>) => {
-    setUserSettings(prev => ({ ...prev, ...newSettings }));
+    setUserSettings((prev) => ({ ...prev, ...newSettings }));
   };
 
   // Search hook
···
   } = useSearch(session);
 
   // Follow hook
-  const {
-    isFollowing,
-    followSelectedUsers,
-  } = useFollow(session, searchResults, setSearchResults);
+  const { isFollowing, followSelectedUsers } = useFollow(
+    session,
+    searchResults,
+    setSearchResults,
+  );
 
   // File upload hook
-  const {
-    handleFileUpload: processFileUpload,
-  } = useFileUpload(
+  const { handleFileUpload: processFileUpload } = useFileUpload(
     (initialResults, platform) => {
       setCurrentPlatform(platform);
 
       setSearchResults(initialResults);
-      setCurrentStep('loading');
+      setCurrentStep("loading");
 
       const uploadId = crypto.randomUUID();
 
-      searchAllUsers(
-        initialResults,
-        setStatusMessage,
-        () => {
-          setCurrentStep('results');
-          // Prevent duplicate saves
-          if (saveCalledRef.current !== uploadId) {
-            saveCalledRef.current = uploadId;
-            // Need to wait for React to finish updating searchResults state
-            // Use a longer delay and access via setSearchResults callback to get final state
-            setTimeout(() => {
-              setSearchResults(currentResults => {
-                if (currentResults.length > 0) {
-                  apiClient.saveResults(uploadId, platform, currentResults).catch(err => {
-                    console.error('Background save failed:', err);
+      searchAllUsers(initialResults, setStatusMessage, () => {
+        setCurrentStep("results");
+        // Prevent duplicate saves
+        if (saveCalledRef.current !== uploadId) {
+          saveCalledRef.current = uploadId;
+          // Need to wait for React to finish updating searchResults state
+          // Use a longer delay and access via setSearchResults callback to get final state
+          setTimeout(() => {
+            setSearchResults((currentResults) => {
+              if (currentResults.length > 0) {
+                apiClient
+                  .saveResults(uploadId, platform, currentResults)
+                  .catch((err) => {
+                    console.error("Background save failed:", err);
                   });
-                }
-                return currentResults; // Don't modify, just return as-is
-              });
-            }, 1000); // Longer delay to ensure all state updates complete
-          }
+              }
+              return currentResults; // Don't modify, just return as-is
+            });
+          }, 1000); // Longer delay to ensure all state updates complete
         }
-      );
+      });
     },
-    setStatusMessage
+    setStatusMessage,
   );
 
   // Load previous upload handler
   const handleLoadUpload = async (uploadId: string) => {
     try {
-      setStatusMessage('Loading previous upload...');
-      setCurrentStep('loading');
-      
+      setStatusMessage("Loading previous upload...");
+      setCurrentStep("loading");
+
       const data = await apiClient.getUploadDetails(uploadId);
-      
-      if (data.results.length === 0){
+
+      if (data.results.length === 0) {
         setSearchResults([]);
-        setCurrentPlatform('tiktok');
-        setCurrentStep('home');
-        setStatusMessage('No previous results found.');
+        setCurrentPlatform("tiktok");
+        setCurrentStep("home");
+        setStatusMessage("No previous results found.");
         return;
       }
 
-      const platform = 'tiktok'; // Default, will be updated when we add platform to upload details
+      const platform = "tiktok"; // Default, will be updated when we add platform to upload details
       setCurrentPlatform(platform);
       saveCalledRef.current = null;
 
       // Convert the loaded results to SearchResult format with selectedMatches
-      const loadedResults = data.results.map(result => ({
+      const loadedResults = data.results.map((result) => ({
         ...result,
         sourcePlatform: platform,
         isSearching: false,
         selectedMatches: new Set<string>(
           result.atprotoMatches
-            .filter(match => !match.followed)
+            .filter((match) => !match.followed)
             .slice(0, 1)
-            .map(match => match.did)
+            .map((match) => match.did),
         ),
       }));
-      
+
       setSearchResults(loadedResults);
-      setCurrentStep('results');
-      setStatusMessage(`Loaded ${loadedResults.length} results from previous upload`);
+      setCurrentStep("results");
+      setStatusMessage(
+        `Loaded ${loadedResults.length} results from previous upload`,
+      );
     } catch (error) {
-      console.error('Failed to load upload:', error);
-      setStatusMessage('Failed to load previous upload');
-      setCurrentStep('home');
-      alert('Failed to load previous upload. Please try again.');
+      console.error("Failed to load upload:", error);
+      setStatusMessage("Failed to load previous upload");
+      setCurrentStep("home");
+      alert("Failed to load previous upload. Please try again.");
     }
   };
 
···
       alert("Please enter your handle");
       return;
     }
-    
+
     try {
       await login(handle);
     } catch (err) {
-      console.error('OAuth error:', err);
-      const errorMsg = `Error starting OAuth: ${err instanceof Error ? err.message : 'Unknown error'}`;
+      console.error("OAuth error:", err);
+      const errorMsg = `Error starting OAuth: ${err instanceof Error ? err.message : "Unknown error"}`;
       setStatusMessage(errorMsg);
       alert(errorMsg);
     }
···
     try {
       await logout();
       setSearchResults([]);
-      setCurrentPlatform('tiktok');
+      setCurrentPlatform("tiktok");
     } catch (error) {
-      alert('Failed to logout. Please try again.');
+      alert("Failed to logout. Please try again.");
     }
   };
 
···
       )}
 
       {/* Status message for screen readers */}
-      <div 
-        role="status" 
-        aria-live="polite" 
+      <div
+        role="status"
+        aria-live="polite"
         aria-atomic="true"
         className="sr-only"
       >
···
       </div>
 
       {/* Skip to main content link */}
-      <a 
-        href="#main-content" 
+      <a
+        href="#main-content"
         className="sr-only focus:not-sr-only focus:absolute focus:top-4 focus:left-4 focus:z-50 focus:bg-firefly-orange focus:text-white focus:px-4 focus:py-2 focus:rounded-lg"
       >
         Skip to main content
···
 
       <main id="main-content">
         {/* Checking Session */}
-        {currentStep === 'checking' && (
+        {currentStep === "checking" && (
           <div className="p-6 max-w-md mx-auto mt-8">
             <div className="bg-white dark:bg-gray-800 rounded-2xl shadow-lg p-8 text-center space-y-4">
               <div className="w-16 h-16 bbg-firefly-banner dark:bg-firefly-banner-dark text-white rounded-2xl mx-auto flex items-center justify-center">
                 <ArrowRight className="w-8 h-8 text-white animate-pulse" />
               </div>
-              <h2 className="text-xl font-bold text-gray-900 dark:text-gray-100">Loading...</h2>
-              <p className="text-gray-600 dark:text-gray-300">Checking your session</p>
+              <h2 className="text-xl font-bold text-gray-900 dark:text-gray-100">
+                Loading...
+              </h2>
+              <p className="text-gray-600 dark:text-gray-300">
+                Checking your session
+              </p>
             </div>
           </div>
         )}
 
         {/* Login Page */}
-        {currentStep === 'login' && (
-          <LoginPage 
+        {currentStep === "login" && (
+          <LoginPage
             onSubmit={handleLogin}
             session={session}
             onNavigate={setCurrentStep}
···
         )}
 
         {/* Home/Dashboard Page */}
-        {currentStep === 'home' && (
+        {currentStep === "home" && (
           <HomePage
             session={session}
             onLogout={handleLogout}
···
         )}
 
         {/* Loading Page */}
-        {currentStep === 'loading' && (
+        {currentStep === "loading" && (
           <LoadingPage
             session={session}
             onLogout={handleLogout}
···
         )}
 
         {/* Results Page */}
-        {currentStep === 'results' && (
+        {currentStep === "results" && (
           <ResultsPage
             session={session}
             onLogout={handleLogout}
···
       </main>
     </div>
   );
-}
+}

src/components/Firefly.tsx

···
   };
 
   return (
-    <div 
+    <div
       className="absolute w-1 h-1 bg-firefly-amber dark:bg-firefly-glow rounded-full opacity-40 pointer-events-none"
       style={style}
       aria-hidden="true"
···
       <div className="absolute inset-0 bg-firefly-glow dark:bg-firefly-amber rounded-full animate-pulse blur-sm" />
     </div>
   );
-}
+}

src/constants/platforms.ts

···
-import { Twitter, Instagram, Video, Hash, Gamepad2, LucideIcon } from "lucide-react";
+import {
+  Twitter,
+  Instagram,
+  Video,
+  Hash,
+  Gamepad2,
+  LucideIcon,
+} from "lucide-react";
 
 export interface PlatformConfig {
   name: string;
···
 
 export const PLATFORMS: Record<string, PlatformConfig> = {
   twitter: {
-    name: 'Twitter/X',
+    name: "Twitter/X",
     icon: Twitter,
-    color: 'from-blue-400 to-blue-600',
-    accentBg: 'bg-blue-500',
-    fileHint: 'following.txt, data.json, or data.zip',
+    color: "from-blue-400 to-blue-600",
+    accentBg: "bg-blue-500",
+    fileHint: "following.txt, data.json, or data.zip",
     enabled: false,
-    defaultApp: 'bluesky',
+    defaultApp: "bluesky",
   },
   instagram: {
-    name: 'Instagram',
+    name: "Instagram",
     icon: Instagram,
-    color: 'from-pink-500 via-purple-500 to-orange-500',
-    accentBg: 'bg-pink-500',
-    fileHint: 'following.html or data ZIP',
+    color: "from-pink-500 via-purple-500 to-orange-500",
+    accentBg: "bg-pink-500",
+    fileHint: "following.html or data ZIP",
     enabled: true,
-    defaultApp: 'bluesky',
+    defaultApp: "bluesky",
   },
   tiktok: {
-    name: 'TikTok',
+    name: "TikTok",
     icon: Video,
-    color: 'from-black via-gray-800 to-cyan-400',
-    accentBg: 'bg-black',
-    fileHint: 'Following.txt or data ZIP',
+    color: "from-black via-gray-800 to-cyan-400",
+    accentBg: "bg-black",
+    fileHint: "Following.txt or data ZIP",
     enabled: true,
-    defaultApp: 'spark',
+    defaultApp: "spark",
   },
   tumblr: {
-    name: 'Tumblr',
+    name: "Tumblr",
     icon: Hash,
-    color: 'from-indigo-600 to-blue-800',
-    accentBg: 'bg-indigo-600',
-    fileHint: 'following.csv or data export',
+    color: "from-indigo-600 to-blue-800",
+    accentBg: "bg-indigo-600",
+    fileHint: "following.csv or data export",
     enabled: false,
-    defaultApp: 'bluesky',
+    defaultApp: "bluesky",
   },
   twitch: {
-    name: 'Twitch',
+    name: "Twitch",
     icon: Gamepad2,
-    color: 'from-purple-600 to-purple-800',
-    accentBg: 'bg-purple-600',
-    fileHint: 'following.json or data export',
+    color: "from-purple-600 to-purple-800",
+    accentBg: "bg-purple-600",
+    fileHint: "following.json or data export",
     enabled: false,
-    defaultApp: 'bluesky'
+    defaultApp: "bluesky",
   },
   youtube: {
-    name: 'YouTube',
+    name: "YouTube",
     icon: Video,
-    color: 'from-red-600 to-red-700',
-    accentBg: 'bg-red-600',
-    fileHint: 'subscriptions.csv or Takeout ZIP',
+    color: "from-red-600 to-red-700",
+    accentBg: "bg-red-600",
+    fileHint: "subscriptions.csv or Takeout ZIP",
     enabled: false,
-    defaultApp: 'bluesky'
+    defaultApp: "bluesky",
   },
 };
 
···
 
 export const FOLLOW_CONFIG = {
   BATCH_SIZE: 50,
-};
+};

src/hooks/useFileUpload.ts

···
-import { parseDataFile } from '../lib/fileExtractor';
-import type { SearchResult } from '../types';
+import { parseDataFile } from "../lib/fileExtractor";
+import type { SearchResult } from "../types";
 
 export function useFileUpload(
   onSearchStart: (results: SearchResult[], platform: string) => void,
-  onStatusUpdate: (message: string) => void
+  onStatusUpdate: (message: string) => void,
 ) {
-  async function handleFileUpload(e: React.ChangeEvent<HTMLInputElement>, platform: string = 'tiktok') {
+  async function handleFileUpload(
+    e: React.ChangeEvent<HTMLInputElement>,
+    platform: string = "tiktok",
+  ) {
     const file = e.target.files?.[0];
     if (!file) return;
 
···
 
     try {
       usernames = await parseDataFile(file, platform);
-      
+
       console.log(`Loaded ${usernames.length} users from ${platform} data`);
       onStatusUpdate(`Loaded ${usernames.length} users from ${platform} data`);
     } catch (error) {
       console.error("Error processing file:", error);
-      
-      const errorMsg = error instanceof Error 
-        ? error.message
-        : "There was a problem processing the file. Please check that it's a valid data export.";
-      
+
+      const errorMsg =
+        error instanceof Error
+          ? error.message
+          : "There was a problem processing the file. Please check that it's a valid data export.";
+
       onStatusUpdate(errorMsg);
       alert(errorMsg);
       return;
     }
-    
+
     if (usernames.length === 0) {
       const errorMsg = "No users found in the file.";
       onStatusUpdate(errorMsg);
···
     }
 
     // Initialize search results - convert usernames to SearchResult format
-    const initialResults: SearchResult[] = usernames.map(username => ({
+    const initialResults: SearchResult[] = usernames.map((username) => ({
       sourceUser: {
         username: username,
-        date: ''
+        date: "",
       },
       atprotoMatches: [],
       isSearching: false,
       selectedMatches: new Set<string>(),
-      sourcePlatform: platform
+      sourcePlatform: platform,
     }));
 
     onStatusUpdate(`Starting search for ${usernames.length} users...`);
···
   return {
     handleFileUpload,
   };
-}
+}

src/hooks/useFollows.ts

···
-import { useState } from 'react';
-import { apiClient } from '../lib/apiClient';
-import { FOLLOW_CONFIG } from '../constants/platforms';
-import type { SearchResult, AtprotoSession } from '../types';
+import { useState } from "react";
+import { apiClient } from "../lib/apiClient";
+import { FOLLOW_CONFIG } from "../constants/platforms";
+import type { SearchResult, AtprotoSession } from "../types";
 
 export function useFollow(
   session: AtprotoSession | null,
   searchResults: SearchResult[],
-  setSearchResults: (results: SearchResult[] | ((prev: SearchResult[]) => SearchResult[])) => void
+  setSearchResults: (
+    results: SearchResult[] | ((prev: SearchResult[]) => SearchResult[]),
+  ) => void,
 ) {
   const [isFollowing, setIsFollowing] = useState(false);
 
   async function followSelectedUsers(
-    onUpdate: (message: string) => void
+    onUpdate: (message: string) => void,
   ): Promise<void> {
     if (!session || isFollowing) return;
 
-    const selectedUsers = searchResults.flatMap((result, resultIndex) => 
+    const selectedUsers = searchResults.flatMap((result, resultIndex) =>
       result.atprotoMatches
-        .filter(match => result.selectedMatches?.has(match.did))
-        .map(match => ({ ...match, resultIndex }))
+        .filter((match) => result.selectedMatches?.has(match.did))
+        .map((match) => ({ ...match, resultIndex })),
     );
 
     if (selectedUsers.length === 0) {
···
 
     try {
       const { BATCH_SIZE } = FOLLOW_CONFIG;
-      
+
       for (let i = 0; i < selectedUsers.length; i += BATCH_SIZE) {
         const batch = selectedUsers.slice(i, i + BATCH_SIZE);
-        const dids = batch.map(user => user.did);
-        
+        const dids = batch.map((user) => user.did);
+
         try {
           const data = await apiClient.batchFollowUsers(dids);
           totalFollowed += data.succeeded;
           totalFailed += data.failed;
-          
+
           // Mark successful follows in UI
           data.results.forEach((result) => {
             if (result.success) {
-              const user = batch.find(u => u.did === result.did);
+              const user = batch.find((u) => u.did === result.did);
               if (user) {
-                setSearchResults(prev => prev.map((searchResult, index) => 
-                  index === user.resultIndex 
-                    ? { 
-                        ...searchResult, 
-                        atprotoMatches: searchResult.atprotoMatches.map(match => 
-                          match.did === result.did ? { ...match, followed: true } : match
-                        )
-                      }
-                    : searchResult
-                ));
+                setSearchResults((prev) =>
+                  prev.map((searchResult, index) =>
+                    index === user.resultIndex
+                      ? {
+                          ...searchResult,
+                          atprotoMatches: searchResult.atprotoMatches.map(
+                            (match) =>
+                              match.did === result.did
+                                ? { ...match, followed: true }
+                                : match,
+                          ),
+                        }
+                      : searchResult,
+                  ),
+                );
               }
             }
           });
-          
-          onUpdate(`Followed ${totalFollowed} of ${selectedUsers.length} users`);
+
+          onUpdate(
+            `Followed ${totalFollowed} of ${selectedUsers.length} users`,
+          );
         } catch (error) {
           totalFailed += batch.length;
-          console.error('Batch follow error:', error);
+          console.error("Batch follow error:", error);
         }
-        
+
         // Rate limit handling is in the backend
       }
-      
-      const finalMsg = `Successfully followed ${totalFollowed} users${totalFailed > 0 ? `. ${totalFailed} failed.` : ''}`;
+
+      const finalMsg = `Successfully followed ${totalFollowed} users${totalFailed > 0 ? `. ${totalFailed} failed.` : ""}`;
       onUpdate(finalMsg);
     } catch (error) {
       console.error("Batch follow error:", error);
···
     isFollowing,
     followSelectedUsers,
   };
-}
+}

src/hooks/useSearch.ts

···
-import { useState } from 'react';
-import { apiClient } from '../lib/apiClient';
-import { SEARCH_CONFIG } from '../constants/platforms';
-import type { SearchResult, SearchProgress, AtprotoSession } from '../types';
+import { useState } from "react";
+import { apiClient } from "../lib/apiClient";
+import { SEARCH_CONFIG } from "../constants/platforms";
+import type { SearchResult, SearchProgress, AtprotoSession } from "../types";
 
 function sortSearchResults(results: SearchResult[]): SearchResult[] {
   return [...results].sort((a, b) => {
···
     const aHasMatches = a.atprotoMatches.length > 0 ? 0 : 1;
     const bHasMatches = b.atprotoMatches.length > 0 ? 0 : 1;
     if (aHasMatches !== bHasMatches) return aHasMatches - bHasMatches;
-    
+
     // 2. For matched users, sort by highest posts count of their top match
     if (a.atprotoMatches.length > 0 && b.atprotoMatches.length > 0) {
       const aTopPosts = a.atprotoMatches[0]?.postCount || 0;
       const bTopPosts = b.atprotoMatches[0]?.postCount || 0;
       if (aTopPosts !== bTopPosts) return bTopPosts - aTopPosts;
-      
+
       // 3. Then by followers count
       const aTopFollowers = a.atprotoMatches[0]?.followerCount || 0;
       const bTopFollowers = b.atprotoMatches[0]?.followerCount || 0;
       if (aTopFollowers !== bTopFollowers) return bTopFollowers - aTopFollowers;
     }
-    
+
     // 4. Username as tiebreaker
     return a.sourceUser.username.localeCompare(b.sourceUser.username);
   });
···
 export function useSearch(session: AtprotoSession | null) {
   const [searchResults, setSearchResults] = useState<SearchResult[]>([]);
   const [isSearchingAll, setIsSearchingAll] = useState(false);
-  const [searchProgress, setSearchProgress] = useState<SearchProgress>({ 
-    searched: 0, 
-    found: 0, 
-    total: 0 
+  const [searchProgress, setSearchProgress] = useState<SearchProgress>({
+    searched: 0,
+    found: 0,
+    total: 0,
   });
-  const [expandedResults, setExpandedResults] = useState<Set<number>>(new Set());
+  const [expandedResults, setExpandedResults] = useState<Set<number>>(
+    new Set(),
+  );
 
   async function searchAllUsers(
     resultsToSearch: SearchResult[],
     onProgressUpdate: (message: string) => void,
-    onComplete: () => void
+    onComplete: () => void,
   ) {
     if (!session || resultsToSearch.length === 0) return;
-    
+
     setIsSearchingAll(true);
     setSearchProgress({ searched: 0, found: 0, total: resultsToSearch.length });
     onProgressUpdate(`Starting search for ${resultsToSearch.length} users...`);
-    
+
     const { BATCH_SIZE, MAX_MATCHES } = SEARCH_CONFIG;
     let totalSearched = 0;
     let totalFound = 0;
···
 
     for (let i = 0; i < resultsToSearch.length; i += BATCH_SIZE) {
       if (totalFound >= MAX_MATCHES) {
-        console.log(`Reached limit of ${MAX_MATCHES} matches. Stopping search.`);
-        onProgressUpdate(`Search complete. Found ${totalFound} matches out of ${MAX_MATCHES} maximum.`);
+        console.log(
+          `Reached limit of ${MAX_MATCHES} matches. Stopping search.`,
+        );
+        onProgressUpdate(
+          `Search complete. Found ${totalFound} matches out of ${MAX_MATCHES} maximum.`,
+        );
         break;
       }
 
       const batch = resultsToSearch.slice(i, i + BATCH_SIZE);
-      const usernames = batch.map(r => r.sourceUser.username);
-      
+      const usernames = batch.map((r) => r.sourceUser.username);
+
       // Mark current batch as searching
-      setSearchResults(prev => prev.map((result, index) => 
-        i <= index && index < i + BATCH_SIZE 
-          ? { ...result, isSearching: true }
-          : result
-      ));
-      
+      setSearchResults((prev) =>
+        prev.map((result, index) =>
+          i <= index && index < i + BATCH_SIZE
+            ? { ...result, isSearching: true }
+            : result,
+        ),
+      );
+
       try {
         const data = await apiClient.batchSearchActors(usernames);
-        
+
         // Reset error counter on success
         consecutiveErrors = 0;
-        
+
         // Process batch results
         data.results.forEach((result) => {
           totalSearched++;
···
           }
         });
 
-        setSearchProgress({ searched: totalSearched, found: totalFound, total: resultsToSearch.length });
-        onProgressUpdate(`Searched ${totalSearched} of ${resultsToSearch.length} users. Found ${totalFound} matches.`);
+        setSearchProgress({
+          searched: totalSearched,
+          found: totalFound,
+          total: resultsToSearch.length,
+        });
+        onProgressUpdate(
+          `Searched ${totalSearched} of ${resultsToSearch.length} users. Found ${totalFound} matches.`,
+        );
 
         // Update results
-        setSearchResults(prev => prev.map((result, index) => {
-          const batchResultIndex = index - i;
-          if (batchResultIndex >= 0 && batchResultIndex < data.results.length) {
-            const batchResult = data.results[batchResultIndex];
-            const newSelectedMatches = new Set<string>();
-            
-            // Auto-select only the first (highest scoring) match
-            if (batchResult.actors.length > 0) {
-              newSelectedMatches.add(batchResult.actors[0].did);
+        setSearchResults((prev) =>
+          prev.map((result, index) => {
+            const batchResultIndex = index - i;
+            if (
+              batchResultIndex >= 0 &&
+              batchResultIndex < data.results.length
+            ) {
+              const batchResult = data.results[batchResultIndex];
+              const newSelectedMatches = new Set<string>();
+
+              // Auto-select only the first (highest scoring) match
+              if (batchResult.actors.length > 0) {
+                newSelectedMatches.add(batchResult.actors[0].did);
+              }
+
+              return {
+                ...result,
+                atprotoMatches: batchResult.actors,
+                isSearching: false,
+                error: batchResult.error,
+                selectedMatches: newSelectedMatches,
+              };
             }
+            return result;
+          }),
+        );
 
-            return {
-              ...result,
-              atprotoMatches: batchResult.actors,
-              isSearching: false,
-              error: batchResult.error,
-              selectedMatches: newSelectedMatches,
-            };
-          }
-          return result;
-        }));
+        setSearchResults((prev) =>
+          prev.map((result, index) => {
+            const batchResultIndex = index - i;
+            if (
+              batchResultIndex >= 0 &&
+              batchResultIndex < data.results.length
+            ) {
+              const batchResult = data.results[batchResultIndex];
+              const newSelectedMatches = new Set<string>();
 
-        setSearchResults(prev => prev.map((result, index) => {
-          const batchResultIndex = index - i;
-          if (batchResultIndex >= 0 && batchResultIndex < data.results.length) {
-            const batchResult = data.results[batchResultIndex];
-            const newSelectedMatches = new Set<string>();
-            
-            if (batchResult.actors.length > 0) {
-              newSelectedMatches.add(batchResult.actors[0].did);
+              if (batchResult.actors.length > 0) {
+                newSelectedMatches.add(batchResult.actors[0].did);
+              }
+
+              return {
+                ...result,
+                atprotoMatches: batchResult.actors,
+                isSearching: false,
+                error: batchResult.error,
+                selectedMatches: newSelectedMatches,
+              };
             }
-
-            return {
-              ...result,
-              atprotoMatches: batchResult.actors,
-              isSearching: false,
-              error: batchResult.error,
-              selectedMatches: newSelectedMatches,
-            };
-          }
-          return result;
-        }));
+            return result;
+          }),
+        );
 
         if (totalFound >= MAX_MATCHES) {
           break;
         }
-        
       } catch (error) {
-        console.error('Batch search error:', error);
+        console.error("Batch search error:", error);
         consecutiveErrors++;
-        
+
         // Mark batch as failed
-        setSearchResults(prev => prev.map((result, index) => 
-          i <= index && index < i + BATCH_SIZE 
-            ? { ...result, isSearching: false, error: 'Search failed' }
-            : result
-        ));
-        
+        setSearchResults((prev) =>
+          prev.map((result, index) =>
+            i <= index && index < i + BATCH_SIZE
+              ? { ...result, isSearching: false, error: "Search failed" }
+              : result,
+          ),
+        );
+
         // If we hit rate limits or repeated errors, add exponential backoff
         if (consecutiveErrors >= MAX_CONSECUTIVE_ERRORS) {
-          const backoffDelay = Math.min(1000 * Math.pow(2, consecutiveErrors - MAX_CONSECUTIVE_ERRORS), 5000);
-          console.log(`Rate limit detected. Backing off for ${backoffDelay}ms...`);
+          const backoffDelay = Math.min(
+            1000 * Math.pow(2, consecutiveErrors - MAX_CONSECUTIVE_ERRORS),
+            5000,
+          );
+          console.log(
+            `Rate limit detected. Backing off for ${backoffDelay}ms...`,
+          );
           onProgressUpdate(`Rate limit detected. Pausing briefly...`);
-          await new Promise(resolve => setTimeout(resolve, backoffDelay));
+          await new Promise((resolve) => setTimeout(resolve, backoffDelay));
         }
       }
     }
-    
+
     setIsSearchingAll(false);
-    onProgressUpdate(`Search complete! Found ${totalFound} matches out of ${totalSearched} users searched.`);
+    onProgressUpdate(
+      `Search complete! Found ${totalFound} matches out of ${totalSearched} users searched.`,
+    );
     onComplete();
   }
 
   function toggleMatchSelection(resultIndex: number, did: string) {
-    setSearchResults(prev => prev.map((result, index) => {
-      if (index === resultIndex) {
-        const newSelectedMatches = new Set(result.selectedMatches);
-        if (newSelectedMatches.has(did)) {
-          newSelectedMatches.delete(did);
-        } else {
-          newSelectedMatches.add(did);
+    setSearchResults((prev) =>
+      prev.map((result, index) => {
+        if (index === resultIndex) {
+          const newSelectedMatches = new Set(result.selectedMatches);
+          if (newSelectedMatches.has(did)) {
+            newSelectedMatches.delete(did);
+          } else {
+            newSelectedMatches.add(did);
+          }
+          return { ...result, selectedMatches: newSelectedMatches };
         }
-        return { ...result, selectedMatches: newSelectedMatches };
-      }
-      return result;
-    }));
+        return result;
+      }),
+    );
   }
 
   function toggleExpandResult(index: number) {
-    setExpandedResults(prev => {
+    setExpandedResults((prev) => {
       const next = new Set(prev);
       if (next.has(index)) next.delete(index);
       else next.add(index);
···
   }
 
   function selectAllMatches(onUpdate: (message: string) => void) {
-    setSearchResults(prev => prev.map(result => {
-      const newSelectedMatches = new Set<string>();
-      if (result.atprotoMatches.length > 0) {
-        newSelectedMatches.add(result.atprotoMatches[0].did);
-      }
-      return {
-        ...result,
-        selectedMatches: newSelectedMatches
-      };
-    }));
+    setSearchResults((prev) =>
+      prev.map((result) => {
+        const newSelectedMatches = new Set<string>();
+        if (result.atprotoMatches.length > 0) {
+          newSelectedMatches.add(result.atprotoMatches[0].did);
+        }
+        return {
+          ...result,
+          selectedMatches: newSelectedMatches,
+        };
+      }),
+    );
 
-    const totalToSelect = searchResults.filter(r => r.atprotoMatches.length > 0).length;
+    const totalToSelect = searchResults.filter(
+      (r) => r.atprotoMatches.length > 0,
+    ).length;
     onUpdate(`Selected ${totalToSelect} top matches`);
   }
 
   function deselectAllMatches(onUpdate: (message: string) => void) {
-    setSearchResults(prev => prev.map(result => ({
-      ...result,
-      selectedMatches: new Set<string>()
-    })));
-    onUpdate('Cleared all selections');
+    setSearchResults((prev) =>
+      prev.map((result) => ({
+        ...result,
+        selectedMatches: new Set<string>(),
+      })),
+    );
+    onUpdate("Cleared all selections");
   }
 
-  const totalSelected = searchResults.reduce((total, result) => 
-    total + (result.selectedMatches?.size || 0), 0
+  const totalSelected = searchResults.reduce(
+    (total, result) => total + (result.selectedMatches?.size || 0),
+    0,
   );
-  
-  const totalFound = searchResults.filter(r => r.atprotoMatches.length > 0).length;
+
+  const totalFound = searchResults.filter(
+    (r) => r.atprotoMatches.length > 0,
+  ).length;
 
   return {
     searchResults,
···
     totalSelected,
     totalFound,
   };
-}
+}

src/hooks/useTheme.ts

···
-import { useState, useEffect } from 'react';
+import { useState, useEffect } from "react";
 
 export function useTheme() {
   const [isDark, setIsDark] = useState(() => {
     // Check localStorage first, then system preference
-    const stored = localStorage.getItem('theme');
-    if (stored) return stored === 'dark';
-    return window.matchMedia('(prefers-color-scheme: dark)').matches;
+    const stored = localStorage.getItem("theme");
+    if (stored) return stored === "dark";
+    return window.matchMedia("(prefers-color-scheme: dark)").matches;
   });
 
   const [reducedMotion, setReducedMotion] = useState(() => {
-    return window.matchMedia('(prefers-reduced-motion: reduce)').matches;
+    return window.matchMedia("(prefers-reduced-motion: reduce)").matches;
   });
 
   useEffect(() => {
     // Apply theme to document
     if (isDark) {
-      document.documentElement.classList.add('dark');
+      document.documentElement.classList.add("dark");
     } else {
-      document.documentElement.classList.remove('dark');
+      document.documentElement.classList.remove("dark");
     }
-    localStorage.setItem('theme', isDark ? 'dark' : 'light');
+    localStorage.setItem("theme", isDark ? "dark" : "light");
   }, [isDark]);
 
   useEffect(() => {
     // Listen for system motion preference changes
-    const mediaQuery = window.matchMedia('(prefers-reduced-motion: reduce)');
+    const mediaQuery = window.matchMedia("(prefers-reduced-motion: reduce)");
     const handler = (e: MediaQueryListEvent) => setReducedMotion(e.matches);
-    mediaQuery.addEventListener('change', handler);
-    return () => mediaQuery.removeEventListener('change', handler);
+    mediaQuery.addEventListener("change", handler);
+    return () => mediaQuery.removeEventListener("change", handler);
   }, []);
 
   const toggleTheme = () => setIsDark(!isDark);
   const toggleMotion = () => setReducedMotion(!reducedMotion);
 
   return { isDark, reducedMotion, toggleTheme, toggleMotion };
-}
+}

src/lib/apiClient/index.ts

···
-import { isLocalMockMode } from '../config';
+import { isLocalMockMode } from "../config";
 
 // Import both clients
-import { apiClient as realApiClient } from './realApiClient';
-import { mockApiClient } from './mockApiClient';
+import { apiClient as realApiClient } from "./realApiClient";
+import { mockApiClient } from "./mockApiClient";
 
 // Export the appropriate client
 export const apiClient = isLocalMockMode() ? mockApiClient : realApiClient;
 
 // Also export both for explicit usage
-export { realApiClient, mockApiClient };
+export { realApiClient, mockApiClient };

src/lib/apiClient/mockApiClient.ts

···
-import type { 
-  AtprotoSession, 
-  BatchSearchResult, 
+import type {
+  AtprotoSession,
+  BatchSearchResult,
   BatchFollowResult,
   SearchResult,
-  SaveResultsResponse 
-} from '../../types';
+  SaveResultsResponse,
+} from "../../types";
 
 // Mock user data for testing
 const MOCK_SESSION: AtprotoSession = {
-  did: 'did:plc:mock123',
-  handle: 'developer.bsky.social',
-  displayName: 'Local Developer',
+  did: "did:plc:mock123",
+  handle: "developer.bsky.social",
+  displayName: "Local Developer",
   avatar: undefined,
-  description: 'Testing ATlast locally'
+  description: "Testing ATlast locally",
 };
 
 // Generate mock Bluesky matches
 function generateMockMatches(username: string): any[] {
-  const numMatches = Math.random() < 0.7 ? Math.floor(Math.random() * 3) + 1 : 0;
-  
+  const numMatches =
+    Math.random() < 0.7 ? Math.floor(Math.random() * 3) + 1 : 0;
+
   return Array.from({ length: numMatches }, (_, i) => ({
     did: `did:plc:mock${username}${i}`,
     handle: `${username}.bsky.social`,
     displayName: username.charAt(0).toUpperCase() + username.slice(1),
     avatar: `https://api.dicebear.com/7.x/avataaars/svg?seed=${username}${i}`,
-    matchScore: 100 - (i * 20),
+    matchScore: 100 - i * 20,
     description: `Mock profile for ${username}`,
     postCount: Math.floor(Math.random() * 1000),
     followerCount: Math.floor(Math.random() * 5000),
···
 }
 
 // Simulate network delay
-const delay = (ms: number = 500) => new Promise(resolve => setTimeout(resolve, ms));
+const delay = (ms: number = 500) =>
+  new Promise((resolve) => setTimeout(resolve, ms));
 
 export const mockApiClient = {
   async startOAuth(handle: string): Promise<{ url: string }> {
     await delay(300);
-    console.log('[MOCK] Starting OAuth for:', handle);
+    console.log("[MOCK] Starting OAuth for:", handle);
     // In mock mode, just return to home immediately
-    return { url: window.location.origin + '/?session=mock' };
+    return { url: window.location.origin + "/?session=mock" };
   },
 
   async getSession(): Promise<AtprotoSession> {
     await delay(200);
-    console.log('[MOCK] Getting session');
-    
+    console.log("[MOCK] Getting session");
+
     // Check if user has "logged in" via mock OAuth
     const params = new URLSearchParams(window.location.search);
-    if (params.get('session') === 'mock') {
+    if (params.get("session") === "mock") {
       return MOCK_SESSION;
     }
-    
+
     // Check localStorage for mock session
-    const mockSession = localStorage.getItem('mock_session');
+    const mockSession = localStorage.getItem("mock_session");
     if (mockSession) {
       return JSON.parse(mockSession);
     }
-    
-    throw new Error('No mock session');
+
+    throw new Error("No mock session");
   },
 
   async logout(): Promise<void> {
     await delay(200);
-    console.log('[MOCK] Logging out');
-    localStorage.removeItem('mock_session');
-    localStorage.removeItem('mock_uploads');
+    console.log("[MOCK] Logging out");
+    localStorage.removeItem("mock_session");
+    localStorage.removeItem("mock_uploads");
   },
 
   async getUploads(): Promise<{ uploads: any[] }> {
     await delay(300);
-    console.log('[MOCK] Getting uploads');
-    
-    const mockUploads = localStorage.getItem('mock_uploads');
+    console.log("[MOCK] Getting uploads");
+
+    const mockUploads = localStorage.getItem("mock_uploads");
     if (mockUploads) {
       return { uploads: JSON.parse(mockUploads) };
     }
-    
+
     return { uploads: [] };
   },
 
-  async getUploadDetails(uploadId: string, page: number = 1, pageSize: number = 50): Promise<{
+  async getUploadDetails(
+    uploadId: string,
+    page: number = 1,
+    pageSize: number = 50,
+  ): Promise<{
     results: SearchResult[];
     pagination?: any;
   }> {
     await delay(500);
-    console.log('[MOCK] Getting upload details:', uploadId);
-    
+    console.log("[MOCK] Getting upload details:", uploadId);
+
     const mockData = localStorage.getItem(`mock_upload_${uploadId}`);
     if (mockData) {
       const results = JSON.parse(mockData);
       return { results };
     }
-    
+
     return { results: [] };
   },
 
-  async getAllUploadDetails(uploadId: string): Promise<{ results: SearchResult[] }> {
+  async getAllUploadDetails(
+    uploadId: string,
+  ): Promise<{ results: SearchResult[] }> {
     return this.getUploadDetails(uploadId);
   },
 
-  async batchSearchActors(usernames: string[]): Promise<{ results: BatchSearchResult[] }> {
+  async batchSearchActors(
+    usernames: string[],
+  ): Promise<{ results: BatchSearchResult[] }> {
     await delay(800); // Simulate API delay
-    console.log('[MOCK] Searching for:', usernames);
-    
-    const results: BatchSearchResult[] = usernames.map(username => ({
+    console.log("[MOCK] Searching for:", usernames);
+
+    const results: BatchSearchResult[] = usernames.map((username) => ({
       username,
       actors: generateMockMatches(username),
-      error: undefined
+      error: undefined,
     }));
-    
+
     return { results };
   },
 
···
     results: BatchFollowResult[];
   }> {
     await delay(1000);
-    console.log('[MOCK] Following users:', dids);
-    
-    const results: BatchFollowResult[] = dids.map(did => ({
+    console.log("[MOCK] Following users:", dids);
+
+    const results: BatchFollowResult[] = dids.map((did) => ({
       did,
       success: true,
-      error: null
+      error: null,
     }));
-    
+
     return {
       success: true,
       total: dids.length,
       succeeded: dids.length,
       failed: 0,
-      results
+      results,
     };
   },
 
   async saveResults(
-    uploadId: string, 
-    sourcePlatform: string, 
-    results: SearchResult[]
+    uploadId: string,
+    sourcePlatform: string,
+    results: SearchResult[],
   ): Promise<SaveResultsResponse> {
     await delay(500);
-    console.log('[MOCK] Saving results:', { uploadId, sourcePlatform, count: results.length });
-    
+    console.log("[MOCK] Saving results:", {
+      uploadId,
+      sourcePlatform,
+      count: results.length,
+    });
+
     // Save to localStorage
     localStorage.setItem(`mock_upload_${uploadId}`, JSON.stringify(results));
-    
+
     // Add to uploads list
-    const uploads = JSON.parse(localStorage.getItem('mock_uploads') || '[]');
-    const matchedUsers = results.filter(r => r.atprotoMatches.length > 0).length;
-    
+    const uploads = JSON.parse(localStorage.getItem("mock_uploads") || "[]");
+    const matchedUsers = results.filter(
+      (r) => r.atprotoMatches.length > 0,
+    ).length;
+
     uploads.unshift({
       uploadId,
       sourcePlatform,
       createdAt: new Date().toISOString(),
       totalUsers: results.length,
       matchedUsers,
-      unmatchedUsers: results.length - matchedUsers
+      unmatchedUsers: results.length - matchedUsers,
     });
-    
-    localStorage.setItem('mock_uploads', JSON.stringify(uploads));
-    
+
+    localStorage.setItem("mock_uploads", JSON.stringify(uploads));
+
     return {
       success: true,
       uploadId,
       totalUsers: results.length,
       matchedUsers,
-      unmatchedUsers: results.length - matchedUsers
+      unmatchedUsers: results.length - matchedUsers,
     };
   },
 
   cache: {
-    clear: () => console.log('[MOCK] Cache cleared'),
-    invalidate: (key: string) => console.log('[MOCK] Cache invalidated:', key),
-    invalidatePattern: (pattern: string) => console.log('[MOCK] Cache pattern invalidated:', pattern),
-  }
-}
+    clear: () => console.log("[MOCK] Cache cleared"),
+    invalidate: (key: string) => console.log("[MOCK] Cache invalidated:", key),
+    invalidatePattern: (pattern: string) =>
+      console.log("[MOCK] Cache pattern invalidated:", pattern),
+  },
+};

src/lib/apiClient/realApiClient.ts

···
-import type { AtprotoSession, BatchSearchResult, BatchFollowResult, SaveResultsResponse, SearchResult } from '../../types';
+import type {
+  AtprotoSession,
+  BatchSearchResult,
+  BatchFollowResult,
+  SaveResultsResponse,
+  SearchResult,
+} from "../../types";
 
 // Client-side cache with TTL
 interface CacheEntry<T> {
···
   // OAuth and Authentication
   async startOAuth(handle: string): Promise<{ url: string }> {
     const currentOrigin = window.location.origin;
-    
-    const res = await fetch('/.netlify/functions/oauth-start', {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ 
+
+    const res = await fetch("/.netlify/functions/oauth-start", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
         login_hint: handle,
-        origin: currentOrigin
+        origin: currentOrigin,
       }),
     });
 
     if (!res.ok) {
       const errorData = await res.json();
-      throw new Error(errorData.error || 'Failed to start OAuth flow');
+      throw new Error(errorData.error || "Failed to start OAuth flow");
     }
 
     return res.json();
   },
 
-  async getSession(): Promise<{ did: string; handle: string; displayName?: string; avatar?: string; description?: string }> {
+  async getSession(): Promise<{
+    did: string;
+    handle: string;
+    displayName?: string;
+    avatar?: string;
+    description?: string;
+  }> {
     // Check cache first
-    const cacheKey = 'session';
+    const cacheKey = "session";
     const cached = cache.get<AtprotoSession>(cacheKey);
     if (cached) {
-      console.log('Returning cached session');
+      console.log("Returning cached session");
       return cached;
     }
 
-    const res = await fetch('/.netlify/functions/session', {
-      credentials: 'include'
+    const res = await fetch("/.netlify/functions/session", {
+      credentials: "include",
     });
 
     if (!res.ok) {
-      throw new Error('No valid session');
+      throw new Error("No valid session");
     }
 
     const data = await res.json();
-    
+
     // Cache the session data for 5 minutes
     cache.set(cacheKey, data, 5 * 60 * 1000);
-    
+
     return data;
   },
 
···
   },
 
   async logout(): Promise<void> {
-    const res = await fetch('/.netlify/functions/logout', {
-      method: 'POST',
-      credentials: 'include'
+    const res = await fetch("/.netlify/functions/logout", {
+      method: "POST",
+      credentials: "include",
     });
 
     if (!res.ok) {
-      throw new Error('Logout failed');
+      throw new Error("Logout failed");
     }
 
     // Clear all caches on logout
···
     }>;
   }> {
     // Check cache first
-    const cacheKey = 'uploads';
+    const cacheKey = "uploads";
     const cached = cache.get<any>(cacheKey, 2 * 60 * 1000); // 2 minute cache for uploads list
     if (cached) {
-      console.log('Returning cached uploads');
+      console.log("Returning cached uploads");
       return cached;
     }
 
-    const res = await fetch('/.netlify/functions/get-uploads', {
-      credentials: 'include'
+    const res = await fetch("/.netlify/functions/get-uploads", {
+      credentials: "include",
     });
 
     if (!res.ok) {
-      throw new Error('Failed to fetch uploads');
+      throw new Error("Failed to fetch uploads");
     }
 
     const data = await res.json();
-    
+
     // Cache uploads list for 2 minutes
     cache.set(cacheKey, data, 2 * 60 * 1000);
-    
+
     return data;
   },
 
   async getUploadDetails(
-    uploadId: string, 
-    page: number = 1, 
-    pageSize: number = 50
+    uploadId: string,
+    page: number = 1,
+    pageSize: number = 50,
   ): Promise<{
     results: SearchResult[];
     pagination?: {
···
     const cacheKey = `upload-details-${uploadId}-p${page}-s${pageSize}`;
     const cached = cache.get<any>(cacheKey, 10 * 60 * 1000);
     if (cached) {
-      console.log('Returning cached upload details for', uploadId, 'page', page);
+      console.log(
+        "Returning cached upload details for",
+        uploadId,
+        "page",
+        page,
+      );
       return cached;
     }
 
     const res = await fetch(
-      `/.netlify/functions/get-upload-details?uploadId=${uploadId}&page=${page}&pageSize=${pageSize}`, 
-      { credentials: 'include' }
+      `/.netlify/functions/get-upload-details?uploadId=${uploadId}&page=${page}&pageSize=${pageSize}`,
+      { credentials: "include" },
     );
 
     if (!res.ok) {
-      throw new Error('Failed to fetch upload details');
+      throw new Error("Failed to fetch upload details");
     }
 
     const data = await res.json();
-    
+
     // Cache upload details page for 10 minutes
     cache.set(cacheKey, data, 10 * 60 * 1000);
-    
+
     return data;
   },
 
   // Helper to load all pages (for backwards compatibility)
-  async getAllUploadDetails(uploadId: string): Promise<{ results: SearchResult[] }> {
+  async getAllUploadDetails(
+    uploadId: string,
+  ): Promise<{ results: SearchResult[] }> {
     const firstPage = await this.getUploadDetails(uploadId, 1, 100);
-    
+
     if (!firstPage.pagination || firstPage.pagination.totalPages === 1) {
       return { results: firstPage.results };
     }
···
     // Load remaining pages
     const allResults = [...firstPage.results];
     const promises = [];
-    
+
     for (let page = 2; page <= firstPage.pagination.totalPages; page++) {
       promises.push(this.getUploadDetails(uploadId, page, 100));
     }
···
   },
 
   // Search Operations
-  async batchSearchActors(usernames: string[]): Promise<{ results: BatchSearchResult[] }> {
+  async batchSearchActors(
+    usernames: string[],
+  ): Promise<{ results: BatchSearchResult[] }> {
     // Create cache key from sorted usernames (so order doesn't matter)
-    const cacheKey = `search-${usernames.slice().sort().join(',')}`;
+    const cacheKey = `search-${usernames.slice().sort().join(",")}`;
     const cached = cache.get<any>(cacheKey, 10 * 60 * 1000);
     if (cached) {
-      console.log('Returning cached search results for', usernames.length, 'users');
+      console.log(
+        "Returning cached search results for",
+        usernames.length,
+        "users",
+      );
       return cached;
     }
 
-    const res = await fetch('/.netlify/functions/batch-search-actors', {
-      method: 'POST',
-      credentials: 'include',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ usernames })
+    const res = await fetch("/.netlify/functions/batch-search-actors", {
+      method: "POST",
+      credentials: "include",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ usernames }),
     });
 
     if (!res.ok) {
···
     }
 
     const data = await res.json();
-    
+
     // Cache search results for 10 minutes
     cache.set(cacheKey, data, 10 * 60 * 1000);
-    
+
     return data;
   },
 
   // Follow Operations
-  async batchFollowUsers(dids: string[]): Promise<{ 
+  async batchFollowUsers(dids: string[]): Promise<{
     success: boolean;
     total: number;
     succeeded: number;
     failed: number;
     results: BatchFollowResult[];
   }> {
-    const res = await fetch('/.netlify/functions/batch-follow-users', {
-      method: 'POST',
-      credentials: 'include',
-      headers: { 'Content-Type': 'application/json' },
+    const res = await fetch("/.netlify/functions/batch-follow-users", {
+      method: "POST",
+      credentials: "include",
+      headers: { "Content-Type": "application/json" },
       body: JSON.stringify({ dids }),
     });
 
     if (!res.ok) {
-      throw new Error('Batch follow failed');
+      throw new Error("Batch follow failed");
     }
 
     const data = await res.json();
-    
+
     // Invalidate uploads cache after following
-    cache.invalidate('uploads');
-    cache.invalidatePattern('upload-details');
-    
+    cache.invalidate("uploads");
+    cache.invalidatePattern("upload-details");
+
     return data;
   },
 
   // Save Results
   async saveResults(
-    uploadId: string, 
-    sourcePlatform: string, 
-    results: SearchResult[]
+    uploadId: string,
+    sourcePlatform: string,
+    results: SearchResult[],
   ): Promise<SaveResultsResponse | null> {
     try {
       const resultsToSave = results
-        .filter(r => !r.isSearching)
-        .map(r => ({
+        .filter((r) => !r.isSearching)
+        .map((r) => ({
           sourceUser: r.sourceUser,
-          atprotoMatches: r.atprotoMatches || []
+          atprotoMatches: r.atprotoMatches || [],
         }));
-      
+
       console.log(`Saving ${resultsToSave.length} results in background...`);
-      
-      const res = await fetch('/.netlify/functions/save-results', {
-        method: 'POST',
-        credentials: 'include',
-        headers: { 'Content-Type': 'application/json' },
+
+      const res = await fetch("/.netlify/functions/save-results", {
+        method: "POST",
+        credentials: "include",
+        headers: { "Content-Type": "application/json" },
         body: JSON.stringify({
           uploadId,
           sourcePlatform,
-          results: resultsToSave
-        })
+          results: resultsToSave,
+        }),
       });
 
       if (res.ok) {
         const data = await res.json();
         console.log(`Successfully saved ${data.matchedUsers} matches`);
-        
+
         // Invalidate caches after saving
-        cache.invalidate('uploads');
-        cache.invalidatePattern('upload-details');
-        
+        cache.invalidate("uploads");
+        cache.invalidatePattern("upload-details");
+
         return data;
       } else {
-        console.error('Failed to save results:', res.status, await res.text());
+        console.error("Failed to save results:", res.status, await res.text());
         return null;
       }
     } catch (error) {
-      console.error('Error saving results (will continue in background):', error);
+      console.error(
+        "Error saving results (will continue in background):",
+        error,
+      );
       return null;
     }
   },
···
     clear: () => cache.clear(),
     invalidate: (key: string) => cache.invalidate(key),
     invalidatePattern: (pattern: string) => cache.invalidatePattern(pattern),
-  }
-};
+  },
+};

src/lib/config.ts

···
 export const ENV = {
   // Detect if we're in local mock mode
-  IS_LOCAL_MOCK: import.meta.env.VITE_LOCAL_MOCK === 'true',
-  
+  IS_LOCAL_MOCK: import.meta.env.VITE_LOCAL_MOCK === "true",
+
   // API base URL
-  API_BASE: import.meta.env.VITE_API_BASE || '/.netlify/functions',
-  
+  API_BASE: import.meta.env.VITE_API_BASE || "/.netlify/functions",
+
   // Feature flags
-  ENABLE_OAUTH: import.meta.env.VITE_ENABLE_OAUTH !== 'false',
-  ENABLE_DATABASE: import.meta.env.VITE_ENABLE_DATABASE !== 'false',
+  ENABLE_OAUTH: import.meta.env.VITE_ENABLE_OAUTH !== "false",
+  ENABLE_DATABASE: import.meta.env.VITE_ENABLE_DATABASE !== "false",
 } as const;
 
 export function isLocalMockMode(): boolean {
···
 
 export function getApiUrl(endpoint: string): string {
   return `${ENV.API_BASE}/${endpoint}`;
-}
+}

src/lib/fileExtractor.ts

···
-import JSZip from 'jszip';
-import { ParseRule, getRulesForPlatform, FileFormat } from './platformDefinitions';
-import { parseContent } from './parserLogic';
+import JSZip from "jszip";
+import {
+  ParseRule,
+  getRulesForPlatform,
+  FileFormat,
+} from "./platformDefinitions";
+import { parseContent } from "./parserLogic";
 
 // Type for the final aggregated results
 export interface ExtractionResults {
-    allExtracted: Record<string, string[]>;
-    uniqueUsernames: string[];
+  allExtracted: Record<string, string[]>;
+  uniqueUsernames: string[];
 }
 
 export class DataExtractor {
-    private file: File | ArrayBuffer | Blob;
+  private file: File | ArrayBuffer | Blob;
 
-    constructor(file: File | ArrayBuffer | Blob) {
-        this.file = file;
-    }
+  constructor(file: File | ArrayBuffer | Blob) {
+    this.file = file;
+  }
 
-    public async processZipArchive(zip: JSZip, rules: ParseRule[]): Promise<ExtractionResults> {
-        /** Core logic for extracting usernames from a successfully loaded ZIP archive. */
-        const allExtracted: Record<string, string[]> = {};
-        const uniqueUsernames: Set<string> = new Set();
+  public async processZipArchive(
+    zip: JSZip,
+    rules: ParseRule[],
+  ): Promise<ExtractionResults> {
+    /** Core logic for extracting usernames from a successfully loaded ZIP archive. */
+    const allExtracted: Record<string, string[]> = {};
+    const uniqueUsernames: Set<string> = new Set();
 
-        for (let i = 0; i < rules.length; i++) {
-            const rule = rules[i];
-            const ruleId = `Rule_${i + 1}_${rule.zipPath}`;
-            console.log(`Processing ZIP file path ${rule.zipPath} (Format: ${rule.format})`);
-            
-            // 1. Get file object from ZIP
-            const fileInZip = zip.file(rule.zipPath);
-            if (!fileInZip) {
-                console.warn(`WARNING: File not found in ZIP: '${rule.zipPath}'. Skipping rule.`);
-                continue;
-            }
+    for (let i = 0; i < rules.length; i++) {
+      const rule = rules[i];
+      const ruleId = `Rule_${i + 1}_${rule.zipPath}`;
+      console.log(
+        `Processing ZIP file path ${rule.zipPath} (Format: ${rule.format})`,
+      );
 
-            try {
-                // 2. Read content asynchronously
-                const content = await fileInZip.async("string");
-                
-                // 3. Apply appropriate parsing logic
-                const extracted = parseContent(content, rule);
-                
-                // 4. Store results
-                allExtracted[ruleId] = extracted;
-                extracted.forEach(name => uniqueUsernames.add(name));
+      // 1. Get file object from ZIP
+      const fileInZip = zip.file(rule.zipPath);
+      if (!fileInZip) {
+        console.warn(
+          `WARNING: File not found in ZIP: '${rule.zipPath}'. Skipping rule.`,
+        );
+        continue;
+      }
+
+      try {
+        // 2. Read content asynchronously
+        const content = await fileInZip.async("string");
 
-            } catch (e) {
-                console.error(`ERROR reading file ${rule.zipPath} from ZIP:`, e);
-            }
-        }
+        // 3. Apply appropriate parsing logic
+        const extracted = parseContent(content, rule);
 
-        return {
-            allExtracted,
-            uniqueUsernames: Array.from(uniqueUsernames).sort()
-        };
+        // 4. Store results
+        allExtracted[ruleId] = extracted;
+        extracted.forEach((name) => uniqueUsernames.add(name));
+      } catch (e) {
+        console.error(`ERROR reading file ${rule.zipPath} from ZIP:`, e);
+      }
     }
+
+    return {
+      allExtracted,
+      uniqueUsernames: Array.from(uniqueUsernames).sort(),
+    };
+  }
 }
 
 /**
···
  * @param platform The platform name (e.g., 'instagram', 'tiktok').
  * @returns A promise that resolves to an array of unique usernames (string[]).
  */
-export async function parseDataFile(file: File | ArrayBuffer | Blob, platform: string): Promise<string[]> {
-    const rules = getRulesForPlatform(platform);
-    
-    if (rules.length === 0) {
-        console.error(`No parsing rules found for platform: ${platform}`);
-        return [];
+export async function parseDataFile(
+  file: File | ArrayBuffer | Blob,
+  platform: string,
+): Promise<string[]> {
+  const rules = getRulesForPlatform(platform);
+
+  if (rules.length === 0) {
+    console.error(`No parsing rules found for platform: ${platform}`);
+    return [];
+  }
+
+  // 1. --- ATTEMPT ZIP LOAD ---
+  try {
+    console.log("Attempting to load file as ZIP archive...");
+    const zip = await JSZip.loadAsync(file);
+
+    const extractor = new DataExtractor(file);
+    const results = await extractor.processZipArchive(zip, rules);
+
+    console.log(
+      `Successfully extracted ${results.uniqueUsernames.length} usernames from ZIP archive.`,
+    );
+    return results.uniqueUsernames;
+  } catch (e) {
+    // 2. --- ZIP LOAD FAILED, ATTEMPT SINGLE FILE ---
+    console.warn(
+      "ZIP load failed. Attempting to parse file as a single data file...",
+    );
+
+    // We need a File object to get the name and content easily
+    if (!(file instanceof File) && !(file instanceof Blob)) {
+      console.error(
+        "Input failed ZIP check and lacks a name/content structure for single file parsing (must be File or Blob).",
+      );
+      return [];
     }
 
-    // 1. --- ATTEMPT ZIP LOAD ---
-    try {
-        console.log("Attempting to load file as ZIP archive...");
-        const zip = await JSZip.loadAsync(file);
-        
-        const extractor = new DataExtractor(file);
-        const results = await extractor.processZipArchive(zip, rules);
-        
-        console.log(`Successfully extracted ${results.uniqueUsernames.length} usernames from ZIP archive.`);
-        return results.uniqueUsernames;
+    const singleFile = file as File;
 
-    } catch (e) {
-        // 2. --- ZIP LOAD FAILED, ATTEMPT SINGLE FILE ---
-        console.warn("ZIP load failed. Attempting to parse file as a single data file...");
-        
-        // We need a File object to get the name and content easily
-        if (!(file instanceof File) && !(file instanceof Blob)) {
-            console.error("Input failed ZIP check and lacks a name/content structure for single file parsing (must be File or Blob).");
-            return [];
-        }
+    // Find the rule that matches the uploaded file name
+    // We check if the uploaded filename ends with the final part of a rule's zipPath (e.g., "following.html")
+    const matchingRule = rules.find((rule) =>
+      singleFile.name
+        .toLowerCase()
+        .endsWith((rule.zipPath.split("/").pop() || "").toLowerCase()),
+    );
 
-        const singleFile = file as File;
-        
-        // Find the rule that matches the uploaded file name
-        // We check if the uploaded filename ends with the final part of a rule's zipPath (e.g., "following.html")
-        const matchingRule = rules.find(rule => 
-            singleFile.name.toLowerCase().endsWith((rule.zipPath.split('/').pop() || '').toLowerCase())
-        );
+    if (!matchingRule) {
+      console.error(
+        `Could not match single file '${singleFile.name}' to any rule for platform ${platform}. Check rules in platformDefinitions.ts.`,
+      );
+      return [];
+    }
 
-        if (!matchingRule) {
-            console.error(`Could not match single file '${singleFile.name}' to any rule for platform ${platform}. Check rules in platformDefinitions.ts.`);
-            return [];
-        }
+    console.log(
+      `Matched single file '${singleFile.name}' to rule: ${matchingRule.zipPath}`,
+    );
 
-        console.log(`Matched single file '${singleFile.name}' to rule: ${matchingRule.zipPath}`);
+    // 3. Process as single file content
+    try {
+      const content = await singleFile.text();
+      const extracted = parseContent(content, matchingRule);
 
-        // 3. Process as single file content
-        try {
-            const content = await singleFile.text();
-            const extracted = parseContent(content, matchingRule);
+      const uniqueUsernames = Array.from(new Set(extracted)).sort();
+      console.log(
+        `Successfully extracted ${uniqueUsernames.length} unique usernames from single file.`,
+      );
 
-            const uniqueUsernames = Array.from(new Set(extracted)).sort();
-            console.log(`Successfully extracted ${uniqueUsernames.length} unique usernames from single file.`);
-            
-            return uniqueUsernames;
-            
-        } catch (contentError) {
-            console.error("Error reading content of single file:", contentError);
-            return [];
-        }
+      return uniqueUsernames;
+    } catch (contentError) {
+      console.error("Error reading content of single file:", contentError);
+      return [];
     }
-}
+  }
+}

src/lib/parserLogic.ts

···
-import { ParseRule, FileFormat } from './platformDefinitions';
+import { ParseRule, FileFormat } from "./platformDefinitions";
 
 /**
  * Parses content using a regular expression.
···
  * @param regexPattern The regex string defining the capture group for the username.
  * @returns An array of extracted usernames.
  */
-export function parseTextOrHtml(content: string, regexPattern: string): string[] {
-    try {
-        // 'g' for global matching, 's' for multiline (DOTALL equivalent)
-        const pattern = new RegExp(regexPattern, 'gs');
-        
-        // matchAll returns an iterator of matches; we spread it into an array.
-        const matches = [...content.matchAll(pattern)];
-        
-        // We map the results to the first captured group (match[1]), filtering out empty results.
-        return matches.map(match => match[1].trim()).filter(name => !!name); 
-        
-    } catch (e) {
-        console.error(`ERROR: Invalid regex pattern '${regexPattern}':`, e);
-        return [];
-    }
+export function parseTextOrHtml(
+  content: string,
+  regexPattern: string,
+): string[] {
+  try {
+    // 'g' for global matching, 's' for multiline (DOTALL equivalent)
+    const pattern = new RegExp(regexPattern, "gs");
+
+    // matchAll returns an iterator of matches; we spread it into an array.
+    const matches = [...content.matchAll(pattern)];
+
+    // We map the results to the first captured group (match[1]), filtering out empty results.
+    return matches.map((match) => match[1].trim()).filter((name) => !!name);
+  } catch (e) {
+    console.error(`ERROR: Invalid regex pattern '${regexPattern}':`, e);
+    return [];
+  }
 }
 
 /**
···
  * @returns An array of extracted usernames.
  */
 export function parseJson(content: string, pathKeys: string[]): string[] {
-    try {
-        const data = JSON.parse(content);
-        const usernames: string[] = [];
+  try {
+    const data = JSON.parse(content);
+    const usernames: string[] = [];
 
-        if (pathKeys.length < 2) {
-            console.error("JSON rule must have at least two path keys (list key and target key).");
-            return [];
-        }
+    if (pathKeys.length < 2) {
+      console.error(
+        "JSON rule must have at least two path keys (list key and target key).",
+      );
+      return [];
+    }
 
-        // Determine the navigation path
-        let currentData: any = data;
-        const listContainerPath = pathKeys.slice(0, -2);
-        const listKey = pathKeys[pathKeys.length - 2];
-        const targetKey = pathKeys[pathKeys.length - 1];
+    // Determine the navigation path
+    let currentData: any = data;
+    const listContainerPath = pathKeys.slice(0, -2);
+    const listKey = pathKeys[pathKeys.length - 2];
+    const targetKey = pathKeys[pathKeys.length - 1];
 
-        // 1. Traverse down to the object containing the target array
-        for (const key of listContainerPath) {
-            if (typeof currentData === 'object' && currentData !== null && key in currentData) {
-                currentData = currentData[key];
-            } else {
-                console.error(`ERROR: Could not traverse JSON path up to key: ${key}. Path: ${listContainerPath.join(' -> ')}`);
-                return [];
-            }
-        }
+    // 1. Traverse down to the object containing the target array
+    for (const key of listContainerPath) {
+      if (
+        typeof currentData === "object" &&
+        currentData !== null &&
+        key in currentData
+      ) {
+        currentData = currentData[key];
+      } else {
+        console.error(
+          `ERROR: Could not traverse JSON path up to key: ${key}. Path: ${listContainerPath.join(" -> ")}`,
+        );
+        return [];
+      }
+    }
 
-        // 2. Check if the penultimate key holds the array
-        if (typeof currentData === 'object' && currentData !== null && listKey in currentData) {
-            const userList = currentData[listKey];
+    // 2. Check if the penultimate key holds the array
+    if (
+      typeof currentData === "object" &&
+      currentData !== null &&
+      listKey in currentData
+    ) {
+      const userList = currentData[listKey];
 
-            if (Array.isArray(userList)) {
-                // 3. Iterate over the array and extract the final target key
-                for (const item of userList) {
-                    if (typeof item === 'object' && item !== null && targetKey in item) {
-                        // Found the username
-                        usernames.push(String(item[targetKey]));
-                    }
-                }
-            } else {
-                console.error(`ERROR: Expected an array at key '${listKey}' but found a different type.`);
-            }
-        } else {
-            console.error(`ERROR: List key '${listKey}' not found at its expected position.`);
+      if (Array.isArray(userList)) {
+        // 3. Iterate over the array and extract the final target key
+        for (const item of userList) {
+          if (typeof item === "object" && item !== null && targetKey in item) {
+            // Found the username
+            usernames.push(String(item[targetKey]));
+          }
         }
-
-        return usernames;
+      } else {
+        console.error(
+          `ERROR: Expected an array at key '${listKey}' but found a different type.`,
+        );
+      }
+    } else {
+      console.error(
+        `ERROR: List key '${listKey}' not found at its expected position.`,
+      );
+    }
 
-    } catch (e) {
-        if (e instanceof SyntaxError) {
-            console.error(`ERROR: Could not decode JSON content:`, e);
-        } else {
-            console.error(`An unexpected error occurred during JSON parsing:`, e);
-        }
-        return [];
+    return usernames;
+  } catch (e) {
+    if (e instanceof SyntaxError) {
+      console.error(`ERROR: Could not decode JSON content:`, e);
+    } else {
+      console.error(`An unexpected error occurred during JSON parsing:`, e);
     }
+    return [];
+  }
 }
 
 /**
···
  * @returns An array of extracted usernames.
  */
 export function parseContent(content: string, rule: ParseRule): string[] {
-    if (rule.format === 'HTML' || rule.format === 'TEXT') {
-        if (typeof rule.rule === 'string') {
-            return parseTextOrHtml(content, rule.rule);
-        }
-    } else if (rule.format === 'JSON') {
-        if (Array.isArray(rule.rule)) {
-            return parseJson(content, rule.rule);
-        }
+  if (rule.format === "HTML" || rule.format === "TEXT") {
+    if (typeof rule.rule === "string") {
+      return parseTextOrHtml(content, rule.rule);
+    }
+  } else if (rule.format === "JSON") {
+    if (Array.isArray(rule.rule)) {
+      return parseJson(content, rule.rule);
     }
-    console.error(`ERROR: Unsupported format or invalid rule type for rule with path: ${rule.zipPath}`);
-    return [];
-}
+  }
+  console.error(
+    `ERROR: Unsupported format or invalid rule type for rule with path: ${rule.zipPath}`,
+  );
+  return [];
+}

src/lib/platformDefinitions.ts

···
 // Use string literals for type safety on formats
-export type FileFormat = 'HTML' | 'TEXT' | 'JSON';
+export type FileFormat = "HTML" | "TEXT" | "JSON";
 
 // Define the structure for a single parsing rule
 export interface ParseRule {
-    zipPath: string; // File path *inside* the ZIP archive
-    format: FileFormat; // Expected format of the file, e.g. 'HTML', 'TEXT', 'JSON'
-    rule: string | string[]; // specific extraction rule (regex pattern string or JSON key path array)
+  zipPath: string; // File path *inside* the ZIP archive
+  format: FileFormat; // Expected format of the file, e.g. 'HTML', 'TEXT', 'JSON'
+  rule: string | string[]; // specific extraction rule (regex pattern string or JSON key path array)
 }
 
 /*
···
 */
 
 export const PLATFORM_RULES: Record<string, ParseRule[]> = {
-    
-    "instagram": [
-        {
-            zipPath: "connections/followers_and_following/following.html",
-            format: "HTML",
-            // Regex captures the username group 'beautyscicomm' from the URL:
-            // https://www.instagram.com/_u/beautyscicomm
-            // Note: The 'g' and 's' flags are handled in the extractor method.
-            rule: '<a target="_blank" href="https://www.instagram.com/_u/([^"]+)"'
-        },
-        {
-            zipPath: "connections/followers_and_following/following.json",
-            format: "JSON",
-            rule: ["relationships_following", "title"]
-        }
-    ],
+  instagram: [
+    {
+      zipPath: "connections/followers_and_following/following.html",
+      format: "HTML",
+      // Regex captures the username group 'beautyscicomm' from the URL:
+      // https://www.instagram.com/_u/beautyscicomm
+      // Note: The 'g' and 's' flags are handled in the extractor method.
+      rule: '<a target="_blank" href="https://www.instagram.com/_u/([^"]+)"',
+    },
+    {
+      zipPath: "connections/followers_and_following/following.json",
+      format: "JSON",
+      rule: ["relationships_following", "title"],
+    },
+  ],
 
-    "tiktok": [
-        {
-            zipPath: "TikTok/Profile and Settings/Following.txt",
-            format: "TEXT",
-            // Regex captures the text after "Username: " on the same line
-            rule: "Username:\s*([^\r\n]+)"
-        },
-        {
-            zipPath: "user_data_tiktok.json",
-            format: "JSON",
-            // JSON key path to traverse: ['Your Activity'] -> ['Following'] -> ['Following'] -> 'UserName'
-            rule: ["Your Activity", "Following", "Following", "UserName"]
-        }
-    ],
+  tiktok: [
+    {
+      zipPath: "TikTok/Profile and Settings/Following.txt",
+      format: "TEXT",
+      // Regex captures the text after "Username: " on the same line
+      rule: "Username:\s*([^\r\n]+)",
+    },
+    {
+      zipPath: "user_data_tiktok.json",
+      format: "JSON",
+      // JSON key path to traverse: ['Your Activity'] -> ['Following'] -> ['Following'] -> 'UserName'
+      rule: ["Your Activity", "Following", "Following", "UserName"],
+    },
+  ],
 };
 
 export function getRulesForPlatform(platformName: string): ParseRule[] {
-    // Retrieves the list of parsing rules for a given platform.
-    return PLATFORM_RULES[platformName.toLowerCase()] || [];
-}
+  // Retrieves the list of parsing rules for a given platform.
+  return PLATFORM_RULES[platformName.toLowerCase()] || [];
+}

src/main.tsx

···
-import React from 'react'
-import ReactDOM from 'react-dom/client'
-import App from './App'
-import './index.css'
+import React from "react";
+import ReactDOM from "react-dom/client";
+import App from "./App";
+import "./index.css";
 
-ReactDOM.createRoot(document.getElementById('root')!).render(
+ReactDOM.createRoot(document.getElementById("root")!).render(
   <React.StrictMode>
     <App />
   </React.StrictMode>,
-)
+);

src/types/index.ts

···
 }
 
 // App State
-export type AppStep = 'checking' | 'login' | 'home' | 'upload' | 'loading' | 'results';
+export type AppStep =
+  | "checking"
+  | "login"
+  | "home"
+  | "upload"
+  | "loading"
+  | "results";
 
 // API Response Types
 export interface BatchSearchResult {
···
   totalUsers: number;
   matchedUsers: number;
   unmatchedUsers: number;
-}
+}

src/vite-env.d.ts

···
 
 interface ImportMeta {
   readonly env: ImportMetaEnv;
-}
+}