add user ranking for search results

netlify/functions/batch-search-actors.ts

···
           else if (normalizedDisplayName.includes(normalizedUsername)) score = 40;
           else if (normalizedUsername.includes(normalizedHandle)) score = 30;
 
-          return { ...actor, matchScore: score };
+          return { 
+            ...actor, 
+            matchScore: score,
+            postCount: actor.postCount || 0,
+            followerCount: actor.followerCount || 0
+          };
         })
         .filter((actor: any) => actor.matchScore > 0)
         .sort((a: any, b: any) => b.matchScore - a.matchScore)

netlify/functions/db-helpers.ts

···
   atprotoHandle: string,
   atprotoDisplayName: string | undefined,
   atprotoAvatar: string | undefined,
-  matchScore: number
+  matchScore: number,
+  postCount: number,
+  followerCount: number
 ): Promise<number> {
   const sql = getDbClient();
   const result = await sql`
     INSERT INTO atproto_matches (
       source_account_id, atproto_did, atproto_handle, 
-      atproto_display_name, atproto_avatar, match_score
+      atproto_display_name, atproto_avatar, match_score,
+      post_count, follower_count
     )
     VALUES (
       ${sourceAccountId}, ${atprotoDid}, ${atprotoHandle},
-      ${atprotoDisplayName || null}, ${atprotoAvatar || null}, ${matchScore}
+      ${atprotoDisplayName || null}, ${atprotoAvatar || null}, ${matchScore},
+      ${postCount || 0}, ${followerCount || 0}
     )
     ON CONFLICT (source_account_id, atproto_did) DO UPDATE SET
       atproto_handle = ${atprotoHandle},
       atproto_display_name = ${atprotoDisplayName || null},
       atproto_avatar = ${atprotoAvatar || null},
       match_score = ${matchScore},
+      post_count = ${postCount},
+      follower_count = ${followerCount},
       last_verified = NOW()
     RETURNING id
   `;
···
     atprotoDisplayName?: string;
     atprotoAvatar?: string;
     matchScore: number;
+    postCount?: number;
+    followerCount?: number;
   }>
 ): Promise<Map<string, number>> {
   const sql = getDbClient();
···
   const atprotoDisplayName = matches.map(m => m.atprotoDisplayName || null)
   const atprotoAvatar = matches.map(m => m.atprotoAvatar  || null)
   const matchScore = matches.map(m => m.matchScore)
+  const postCount = matches.map(m => m.postCount || 0)
+  const followerCount = matches.map(m => m.followerCount || 0)
 
   const result = await sql`
     INSERT INTO atproto_matches (
       source_account_id, atproto_did, atproto_handle, 
-      atproto_display_name, atproto_avatar, match_score
+      atproto_display_name, atproto_avatar, match_score,
+      post_count, follower_count
     )
     SELECT * FROM UNNEST(
       ${sourceAccountId}::integer[],
···
       ${atprotoHandle}::text[],
       ${atprotoDisplayName}::text[],
       ${atprotoAvatar}::text[],
-      ${matchScore}::integer[]
+      ${matchScore}::integer[],
+      ${postCount}::integer[],
+      ${followerCount}::integer[]
     ) AS t(
       source_account_id, atproto_did, atproto_handle,
-      atproto_display_name, atproto_avatar, match_score
+      atproto_display_name, atproto_avatar, match_score,
+      post_count, follower_count
     )
     ON CONFLICT (source_account_id, atproto_did) DO UPDATE SET
       atproto_handle = EXCLUDED.atproto_handle,
       atproto_display_name = EXCLUDED.atproto_display_name,
       atproto_avatar = EXCLUDED.atproto_avatar,
       match_score = EXCLUDED.match_score,
+      post_count = EXCLUDED.post_count,
+      follower_count = EXCLUDED.follower_count,
       last_verified = NOW()
     RETURNING id, source_account_id, atproto_did
   `;

netlify/functions/db.ts

···
       atproto_handle TEXT NOT NULL,
       atproto_display_name TEXT,
       atproto_avatar TEXT,
+      post_count INTEGER,
+      follower_count INTEGER,
       match_score INTEGER NOT NULL,
       found_at TIMESTAMP DEFAULT NOW(),
       last_verified TIMESTAMP,
···
   await sql`CREATE INDEX IF NOT EXISTS idx_notification_queue_pending ON notification_queue(sent, created_at) WHERE sent = false`;
 
   // NEW: Enhanced indexes for common query patterns
+
+  // For sorting
+  await sql`CREATE INDEX IF NOT EXISTS idx_atproto_matches_stats ON atproto_matches(source_account_id, found_at DESC, post_count DESC, follower_count DESC)`;
   
   // For session lookups (most frequent query)
 await sql`CREATE INDEX IF NOT EXISTS idx_user_sessions_did ON user_sessions(did)`;

netlify/functions/get-upload-details.ts

···
         am.atproto_display_name,
         am.atproto_avatar,
         am.match_score,
+        am.post_count,
+        am.follower_count,
+        am.found_at,
         ums.followed,
-        ums.dismissed
+        ums.dismissed,
+        -- Calculate if this is a new match (found after upload creation)
+        CASE WHEN am.found_at > uu.created_at THEN 1 ELSE 0 END as is_new_match
       FROM user_source_follows usf
       JOIN source_accounts sa ON usf.source_account_id = sa.id
-      LEFT JOIN atproto_matches am ON sa.id = am.source_account_id
+      JOIN user_uploads uu ON usf.upload_id = uu.upload_id
+      LEFT JOIN atproto_matches am ON sa.id = am.source_account_id AND am.is_active = true
       LEFT JOIN user_match_status ums ON am.id = ums.atproto_match_id AND ums.did = ${userSession.did}
       WHERE usf.upload_id = ${uploadId}
-      ORDER BY sa.source_username
+      ORDER BY 
+        -- 1. Users with matches first
+        CASE WHEN am.atproto_did IS NOT NULL THEN 0 ELSE 1 END,
+        -- 2. New matches (found after initial upload)
+        is_new_match DESC,
+        -- 3. Highest post count
+        am.post_count DESC NULLS LAST,
+        -- 4. Highest follower count
+        am.follower_count DESC NULLS LAST,
+        -- 5. Username as tiebreaker
+        sa.source_username
       LIMIT ${pageSize}
       OFFSET ${offset}
     `;
 
     // Group results by source username
-    const groupedResults: any = {};
+    const groupedResults = new Map<string, any>();
     
     (results as any[]).forEach((row: any) => {
       const username = row.source_username;
       
-      if (!groupedResults[username]) {
-        groupedResults[username] = {
-          tiktokUser: {
+      // Get or create the entry for this username
+      let userResult = groupedResults.get(username);
+      
+      if (!userResult) {
+        userResult = {
+          sourceUser: {
             username: username,
             date: row.source_date || '',
           },
           atprotoMatches: [],
         };
+        groupedResults.set(username, userResult); // Add to map, this preserves the order
       }
       
+      // Add the match (if it exists) to the array
       if (row.atproto_did) {
-        groupedResults[username].atprotoMatches.push({
+        userResult.atprotoMatches.push({
           did: row.atproto_did,
           handle: row.atproto_handle,
           displayName: row.atproto_display_name,
           avatar: row.atproto_avatar,
           matchScore: row.match_score,
+          postCount: row.post_count,
+          followerCount: row.follower_count,
+          foundAt: row.found_at,
           followed: row.followed || false,
           dismissed: row.dismissed || false,
         });
       }
     });
 
-    const searchResults = Object.values(groupedResults);
+    const searchResults = Array.from(groupedResults.values());
 
     return {
       statusCode: 200,

netlify/functions/save-results.ts

···
 import { getDbClient } from './db';
 
 interface SearchResult {
-  tiktokUser: {
+  sourceUser: {
     username: string;
     date: string;
   };
···
     displayName?: string;
     avatar?: string;
     matchScore: number;
+    postCount: number;
+    followerCount: number;
   }>;
   isSearching?: boolean;
   error?: string;
···
     );
 
     // BULK OPERATION 1: Create all source accounts at once
-    const allUsernames = results.map(r => r.tiktokUser.username);
+    const allUsernames = results.map(r => r.sourceUser.username);
     const sourceAccountIdMap = await bulkCreateSourceAccounts(sourcePlatform, allUsernames);
     
     // BULK OPERATION 2: Link all users to source accounts
     const links = results.map(result => {
-      const normalized = result.tiktokUser.username.toLowerCase().replace(/[._-]/g, '');
+      const normalized = result.sourceUser.username.toLowerCase().replace(/[._-]/g, '');
       const sourceAccountId = sourceAccountIdMap.get(normalized);
       return {
         sourceAccountId: sourceAccountId!,
-        sourceDate: result.tiktokUser.date
+        sourceDate: result.sourceUser.date
       };
     }).filter(link => link.sourceAccountId !== undefined);
     
···
       atprotoDisplayName?: string;
       atprotoAvatar?: string;
       matchScore: number;
+      postCount: number;
+      followerCount: number;
     }> = [];
     
     const matchedSourceAccountIds: number[] = [];
     
     for (const result of results) {
-      const normalized = result.tiktokUser.username.toLowerCase().replace(/[._-]/g, '');
+      const normalized = result.sourceUser.username.toLowerCase().replace(/[._-]/g, '');
       const sourceAccountId = sourceAccountIdMap.get(normalized);
       
       if (sourceAccountId && result.atprotoMatches && result.atprotoMatches.length > 0) {
···
             atprotoHandle: match.handle,
             atprotoDisplayName: match.displayName,
             atprotoAvatar: match.avatar,
-            matchScore: match.matchScore
+            matchScore: match.matchScore,
+            postCount: match.postCount || 0,
+            followerCount: match.followerCount || 0,
           });
         }
       }

src/App.tsx

···
     (initialResults, platform) => {
       setCurrentPlatform(platform);
 
-      const resultsWithPlatform = initialResults.map(res => ({
-        ...res,
-        sourcePlatform: platform,
-      }));
-      
-      setSearchResults(resultsWithPlatform);
+      setSearchResults(initialResults);
       setCurrentStep('loading');
 
       const uploadId = crypto.randomUUID();
 
       searchAllUsers(
-        resultsWithPlatform,
+        initialResults,
         setStatusMessage,
         () => {
           setCurrentStep('results');

src/components/SearchResultCard.tsx

···
 import { Video, MessageCircle, Check, UserPlus, ChevronDown } from "lucide-react";
 import { PLATFORMS } from "../constants/platforms";
-import type { SearchResult, AtprotoMatch, TikTokUser } from '../types';
+import type { SearchResult, AtprotoMatch, SourceUser } from '../types';
 
 
 interface SearchResultCardProps {
···
         <div className="flex items-center justify-between">
           <div className="flex-1 min-w-0">
             <div className="font-bold text-gray-900 dark:text-gray-100 truncate">
-              @{result.tiktokUser.username}
+              @{result.sourceUser.username}
             </div>
             <div className="text-xs text-gray-500 dark:text-gray-400">
               {platform.name}
···
                     </div>
                     {match.description && (
                       <div className="text-sm text-gray-500 dark:text-gray-400 mt-1 line-clamp-2">{match.description}</div>
+                    )}
+                    {(match.postCount || match.followerCount) && (
+                      <div className="flex items-center space-x-3 mt-2 text-xs text-gray-500 dark:text-gray-400">
+                        {match.postCount && match.postCount > 0 && (
+                          <span>{match.postCount.toLocaleString()} posts</span>
+                        )}
+                        {match.followerCount && match.followerCount > 0 && (
+                          <span>{match.followerCount.toLocaleString()} followers</span>
+                        )}
+                      </div>
                     )}
                     <div className="flex items-center space-x-3 mt-2">
                       <span className="text-xs bg-green-100 dark:bg-green-900 text-green-800 dark:text-green-300 px-2 py-1 rounded-full font-medium">

src/hooks/useFileUpload.ts

···
 
     // Initialize search results
     const initialResults: SearchResult[] = users.map(user => ({
-      tiktokUser: user, // TODO: Rename to sourceUser in types
+      sourceUser: user,
       atprotoMatches: [],
       isSearching: false,
       selectedMatches: new Set<string>(),

src/hooks/useSearch.ts

···
 import { SEARCH_CONFIG } from '../constants/platforms';
 import type { SearchResult, SearchProgress, AtprotoSession } from '../types';
 
+function sortSearchResults(results: SearchResult[]): SearchResult[] {
+  return [...results].sort((a, b) => {
+    // 1. Users with matches first
+    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 batch = resultsToSearch.slice(i, i + BATCH_SIZE);
-      const usernames = batch.map(r => r.tiktokUser.username);
+      const usernames = batch.map(r => r.sourceUser.username);
       
       // Mark current batch as searching
       setSearchResults(prev => prev.map((result, index) => 
···
             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;
+        }));
+
+        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);
             }

src/lib/apiClient.ts

···
       const resultsToSave = results
         .filter(r => !r.isSearching)
         .map(r => ({
-          tiktokUser: r.tiktokUser,
+          sourceUser: r.sourceUser,
           atprotoMatches: r.atprotoMatches || []
         }));
       

src/pages/Results.tsx

···
   description?: string;
 }
 
-interface TikTokUser {
+interface SourceUser {
   username: string;
   date: string;
 }
 
 interface SearchResult {
-  tiktokUser: TikTokUser;
+  sourceUser: SourceUser;
   atprotoMatches: any[];
   isSearching: boolean;
   error?: string;
···
 
       {/* Feed Results */}
       <div className="max-w-3xl mx-auto px-4 py-4 space-y-4">
-        {searchResults.map((result, idx) => (
-          <SearchResultCard
-            key={idx}
-            result={result}
-            resultIndex={idx}
-            isExpanded={expandedResults.has(idx)}
-            onToggleExpand={() => onToggleExpand(idx)}
-            onToggleMatchSelection={(did) => onToggleMatchSelection(idx, did)}
-            sourcePlatform={sourcePlatform}
-          />
-        ))}
+        {[...searchResults].sort((a, b) => {
+          // Sort logic here, match sortSearchResults function
+          const aHasMatches = a.atprotoMatches.length > 0 ? 0 : 1;
+          const bHasMatches = b.atprotoMatches.length > 0 ? 0 : 1;
+          if (aHasMatches !== bHasMatches) return aHasMatches - bHasMatches;
+          
+          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;
+            
+            const aTopFollowers = a.atprotoMatches[0]?.followerCount || 0;
+            const bTopFollowers = b.atprotoMatches[0]?.followerCount || 0;
+            if (aTopFollowers !== bTopFollowers) return bTopFollowers - aTopFollowers;
+          }
+          
+          return a.sourceUser.username.localeCompare(b.sourceUser.username);
+        }).map((result, idx) => {
+          // Find the original index in unsorted array
+          const originalIndex = searchResults.findIndex(r => r.sourceUser.username === result.sourceUser.username);
+          return (
+            <SearchResultCard
+              key={originalIndex}
+              result={result}
+              resultIndex={originalIndex}  // Use original index for state updates
+              isExpanded={expandedResults.has(originalIndex)}
+              onToggleExpand={() => onToggleExpand(originalIndex)}
+              onToggleMatchSelection={(did) => onToggleMatchSelection(originalIndex, did)}
+              sourcePlatform={sourcePlatform}
+            />
+          );
+        })}
       </div>
 
       {/* Fixed Bottom Action Bar */}

src/types/index.ts

···
 }
 
 // TikTok Data Types
-export interface TikTokUser {
+export interface SourceUser {
   username: string;
   date: string;
 }
···
   matchScore: number;
   description?: string;
   followed?: boolean;
+  postCount?: number;
+  followerCount?: number;
+  foundAt?: string;
 }
 
 export interface SearchResult {
-  tiktokUser: TikTokUser;
+  sourceUser: SourceUser;
   atprotoMatches: AtprotoMatch[];
   isSearching: boolean;
   error?: string;