feat: add Following tab, profile stats & npub UX (#245)

* feat: add Following tab, profile stats, and npub UX improvements

- Add Following tab on user profiles showing who they follow
  - Uses Primal cache for fast contact list retrieval with NDK fallback
  - Batch-fetches profile metadata with timeouts to prevent hangs
  - Sorted alphabetically with unresolved npubs at the bottom
- Add follower/following counts via Primal's user_profile cache endpoint
  - New PrimalUserStats interface and kind 10000105 event handling
  - Counts displayed between bio and tabs, "Following" links to tab
- Move inline npub pill to "more options" menu on other users' profiles
  - Own profile still shows inline npub for quick access
  - Toast notification on copy for better feedback
- Optimize tab bar for mobile: remove icons from Reads and Following tabs

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* fix: address Copilot audit — race guards, safe timeouts, type-safe resolvers

- Replace reject-based Promise.race timeouts with a fetchEventsWithTimeout
  helper that resolves to an empty Set (no unhandled rejections)
- Add navigation race guards to loadFollowing() and fetchUserStatsFromPrimal
  — capture requestedPubkey and bail if hexpubkey changes mid-request
- Fix PendingRequest resolve casts: wrap each resolve with a narrowing
  function instead of unsafe union cast

Author: spe1020

src/lib/primalCache.ts

@@ -42,14 +42,25 @@ interface PrimalFeedResponse {
   profiles: PrimalProfile[];
 }
 
+export interface PrimalUserStats {
+  followers_count: number;
+  follows_count: number;
+  note_count: number;
+  reply_count: number;
+  total_zap_count: number;
+  total_satszapped: number;
+  time_joined: number;
+}
+
 interface PendingRequest {
-  resolve: (value: PrimalSearchResult | PrimalFeedResponse | string[]) => void;
+  resolve: (value: PrimalSearchResult | PrimalFeedResponse | string[] | PrimalUserStats | null) => void;
   reject: (error: Error) => void;
   timeout: ReturnType<typeof setTimeout>;
   profiles: PrimalProfile[];
   events: PrimalEvent[];
   follows: string[];
-  type: 'search' | 'feed' | 'contacts' | 'global' | 'articles';
+  userStats: PrimalUserStats | null;
+  type: 'search' | 'feed' | 'contacts' | 'global' | 'articles' | 'user_stats';
 }
 
 export interface PrimalArticleOptions {
@@ -186,6 +197,22 @@ export class PrimalCacheService {
           .filter((tag: string[]) => tag[0] === 'p' && tag[1])
           .map((tag: string[]) => tag[1]);
         pending.follows.push(...follows);
+      } else if (event.kind === 10000105) {
+        // User stats (Primal-specific kind)
+        try {
+          const stats = JSON.parse(event.content);
+          pending.userStats = {
+            followers_count: stats.followers_count ?? 0,
+            follows_count: stats.follows_count ?? 0,
+            note_count: stats.note_count ?? 0,
+            reply_count: stats.reply_count ?? 0,
+            total_zap_count: stats.total_zap_count ?? 0,
+            total_satszapped: stats.total_satszapped ?? 0,
+            time_joined: stats.time_joined ?? 0
+          };
+        } catch (error) {
+          console.error('[PrimalCache] Error parsing user stats:', error);
+        }
       }
     } else if (messageType === 'EOSE' && requestId) {
       const pending = this.pendingRequests.get(requestId as string);
@@ -201,6 +228,8 @@ export class PrimalCacheService {
           });
         } else if (pending.type === 'contacts') {
           (pending.resolve as (value: string[]) => void)(pending.follows);
+        } else if (pending.type === 'user_stats') {
+          (pending.resolve as (value: PrimalUserStats | null) => void)(pending.userStats);
         }
 
         this.pendingRequests.delete(requestId as string);
@@ -249,6 +278,7 @@ export class PrimalCacheService {
         profiles: [],
         events: [],
         follows: [],
+        userStats: null,
         type: 'search'
       });
 
@@ -294,12 +324,13 @@ export class PrimalCacheService {
       }, timeoutMs);
 
       this.pendingRequests.set(requestId, {
-        resolve: resolve as (value: PrimalSearchResult | PrimalFeedResponse | string[]) => void,
+        resolve: (value) => resolve(value as string[]),
         reject,
         timeout,
         profiles: [],
         events: [],
         follows: [],
+        userStats: null,
         type: 'contacts'
       });
 
@@ -364,12 +395,13 @@ export class PrimalCacheService {
       }, timeoutMs);
 
       this.pendingRequests.set(requestId, {
-        resolve: resolve as (value: PrimalSearchResult | PrimalFeedResponse | string[]) => void,
+        resolve: (value) => resolve(value as PrimalFeedResponse),
         reject,
         timeout,
         profiles: [],
         events: [],
         follows: [],
+        userStats: null,
         type: 'feed'
       });
 
@@ -427,12 +459,13 @@ export class PrimalCacheService {
       }, timeoutMs);
 
       this.pendingRequests.set(requestId, {
-        resolve: resolve as (value: PrimalSearchResult | PrimalFeedResponse | string[]) => void,
+        resolve: (value) => resolve(value as PrimalFeedResponse),
         reject,
         timeout,
         profiles: [],
         events: [],
         follows: [],
+        userStats: null,
         type: 'global'
       });
 
@@ -496,12 +529,13 @@ export class PrimalCacheService {
       }, timeoutMs);
 
       this.pendingRequests.set(requestId, {
-        resolve: resolve as (value: PrimalSearchResult | PrimalFeedResponse | string[]) => void,
+        resolve: (value) => resolve(value as PrimalFeedResponse),
         reject,
         timeout,
         profiles: [],
         events: [],
         follows: [],
+        userStats: null,
         type: 'articles'
       });
 
@@ -556,12 +590,13 @@ export class PrimalCacheService {
       }, timeoutMs);
 
       this.pendingRequests.set(requestId, {
-        resolve: resolve as (value: PrimalSearchResult | PrimalFeedResponse | string[]) => void,
+        resolve: (value) => resolve(value as PrimalFeedResponse),
         reject,
         timeout,
         profiles: [],
         events: [],
         follows: [],
+        userStats: null,
         type: 'articles'
       });
 
@@ -606,6 +641,7 @@ export class PrimalCacheService {
         profiles: [],
         events: [],
         follows: [],
+        userStats: null,
         type: 'search'
       });
 
@@ -619,6 +655,57 @@ export class PrimalCacheService {
     });
   }
 
+  /**
+   * Fetch user profile stats (follower count, following count, etc.) from Primal cache
+   * Uses the user_profile cache endpoint which returns kind 10000105 events
+   */
+  public async fetchUserStats(pubkey: string, timeoutMs: number = 5000): Promise<PrimalUserStats | null> {
+    if (!pubkey) return null;
+
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+      await this.connect();
+    }
+
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+      throw new Error('WebSocket not connected');
+    }
+
+    const requestId = this.generateRequestId();
+    const request = [
+      'REQ',
+      requestId,
+      {
+        cache: ['user_profile', { pubkey }]
+      }
+    ];
+
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        this.pendingRequests.delete(requestId);
+        reject(new Error('User stats request timed out'));
+      }, timeoutMs);
+
+      this.pendingRequests.set(requestId, {
+        resolve: (value) => resolve(value as PrimalUserStats | null),
+        reject,
+        timeout,
+        profiles: [],
+        events: [],
+        follows: [],
+        userStats: null,
+        type: 'user_stats'
+      });
+
+      try {
+        this.ws!.send(JSON.stringify(request));
+      } catch (error) {
+        clearTimeout(timeout);
+        this.pendingRequests.delete(requestId);
+        reject(error as Error);
+      }
+    });
+  }
+
   public isConnected(): boolean {
     return this.ws?.readyState === WebSocket.OPEN;
   }
@@ -641,6 +728,22 @@ export const getPrimalCache = (): PrimalCacheService | null => {
   return primalCache;
 };
 
+/**
+ * Fetch user profile stats (followers, following, etc.) from Primal cache
+ * Convenience wrapper that handles connection and errors
+ */
+export async function fetchUserStatsFromPrimal(pubkey: string): Promise<PrimalUserStats | null> {
+  const cache = getPrimalCache();
+  if (!cache) return null;
+
+  try {
+    return await cache.fetchUserStats(pubkey);
+  } catch (error) {
+    console.debug('[PrimalCache] Failed to fetch user stats:', error);
+    return null;
+  }
+}
+
 // ═══════════════════════════════════════════════════════════════
 // CONVENIENCE FUNCTIONS FOR FEED INTEGRATION
 // ═══════════════════════════════════════════════════════════════