fix(profile): correct anon fallback in feeds, comments, notifications (#368)

Three bugs converged to make valid profiles render as Anon Chef
across feeds, comments, AuthorName, and ProfileLink — even though
the same profiles loaded fine elsewhere on Nostr. All three are
fixed in this PR.

1) getUsername now checks display_name before name. Mirrors the
   priority order getDisplayName already uses. Previously
   getUsername (and formatDisplayName, which wraps it) ignored
   display_name entirely and fell straight to anon for profiles
   that set only display_name. This affected most rendering paths
   in the app since formatDisplayName is the default helper used
   by feed, comments, AuthorName, and ProfileLink. Notifications
   were unaffected because they call getDisplayName directly.

2) AuthorName drops its 3s outer Promise.race timeout. The inner
   resolveProfileByPubkey + fetchProfileFromRelays already cap the
   fetch at 5s. The 3s outer race fired before the underlying 5s
   could complete on slow relays — the profile arrived in the cache
   afterward, but AuthorName had already rendered the anon fallback
   and uses onMount, not reactive, so it never re-read. User refresh
   = re-mount = cache hit = correct render. That's the symptom
   pattern reported.

3) fetchProfileFromRelays now uses an explicit relay set unioning
   the connected NDK pool with canonical profile relays (purplepag.es,
   relay.nostr.band, nostr.wine). NDK's user.fetchProfile() doesn't
   let us override the relay set; we drop down to fetchEvent +
   manual JSON parse to get the wider net. Profiles that live only
   on purplepag.es or relays not in our default pool are now
   reachable. Plus we now read displayName (camelCase) in addition
   to display_name (snake_case) since some clients write only the
   camelCase form.

Test plan:
- Profile with display_name only renders correctly in feed, comments,
  AuthorName, ProfileLink (Bug 1).
- Profile that takes 4s to resolve no longer flashes anon and stick
  (Bug 2). Cache eventually warms and second-mount components show
  the right name without a refresh.
- Profile that lives only on purplepag.es renders without needing
  the user to manually add the relay (Bug 3).

Validation:
- pnpm test 77 / 77 passing
- pnpm check 0 errors
- pnpm build clean

Out of scope:
- Reactive re-read when cache populates after the component mounts.
  Would let "anon → real name" upgrade live without re-mount, but
  needs a Svelte store-backed cache. Tracked as a follow-up; the
  cache + faster lookups land in this PR cover most cases already.

Co-authored-by: spe1020 <sethsager@Seths-MacBook-Air.local>
Co-authored-by: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: 3 people

package.json

@@ -1,7 +1,7 @@
 {
   "name": "zap.cooking",
   "license": "MIT",
-  "version": "4.2.340",
+  "version": "4.2.341",
   "private": true,
   "scripts": {
     "dev": "vite dev",

src/components/AuthorName.svelte

@@ -54,11 +54,14 @@
         return;
       }
 
-      // Simple profile fetch with timeout
-      const profile = await Promise.race([
-        resolveProfileByPubkey(pubkey, ndkInstance),
-        new Promise<null>((r) => setTimeout(() => r(null), 3000))
-      ]);
+      // No outer timeout — `resolveProfileByPubkey` (and the
+      // `fetchProfileFromRelays` it calls) already cap the fetch at
+      // 5s and return null on timeout. The previous 3s outer race
+      // here fired *before* the underlying 5s could complete, so
+      // slow-but-eventual profile fetches landed in the cache while
+      // this component had already rendered the anon fallback —
+      // requiring a refresh to pick up the now-cached profile.
+      const profile = await resolveProfileByPubkey(pubkey, ndkInstance);
 
       if (profile) {
         // formatDisplayName already returns a stable anon-chef name when

src/lib/profileResolver.ts

@@ -79,6 +79,21 @@ export function decodeNostrProfile(nostrString: string): string | null {
 // Profile fetch timeout
 const PROFILE_FETCH_TIMEOUT = 5000; // 5 seconds
 
+/**
+ * Relays we'll always consult for kind:0 lookups, in addition to NDK's
+ * default pool. Purplepag.es is the de-facto Nostr profile relay —
+ * many users publish kind:0 there (or it's the only relay their
+ * NIP-65 client targeted). Without including it, profiles that don't
+ * happen to live on garden / nos.lol / damus / primal silently 404
+ * and render as the anon-chef fallback. nostr.band + nostr.wine are
+ * common secondary mirrors.
+ */
+const PROFILE_RELAY_URLS = [
+  'wss://purplepag.es',
+  'wss://relay.nostr.band',
+  'wss://nostr.wine'
+];
+
 // Fetch profile data from relays
 async function fetchProfileFromRelays(pubkey: string, ndkInstance: NDK): Promise<ProfileData | null> {
   try {
@@ -90,34 +105,74 @@ async function fetchProfileFromRelays(pubkey: string, ndkInstance: NDK): Promise
       return null;
     }
 
-    // Use NDK's built-in fetchProfile method
-    // It handles relay selection via outbox model when enabled
-    const user = ndkInstance.getUser({ hexpubkey: pubkey });
-    
-    // Don't clear cached profile - let NDK use its cache
-    // This prevents unnecessary network requests
-    
-    // Add timeout to prevent hanging
-    const fetchPromise = user.fetchProfile();
-    const timeoutPromise = new Promise<null>((resolve) => 
+    // Build an explicit relay set: NDK's connected pool relays
+    // (whatever the page already has open — garden, nos.lol, damus,
+    // primal in default mode) plus the canonical profile relays.
+    // NDK's `user.fetchProfile()` doesn't let us widen the relay set,
+    // so we drop down to fetchEvent + parse the kind:0 manually.
+    const { NDKRelaySet } = await import('@nostr-dev-kit/ndk');
+    const relayUrls = new Set<string>();
+    if (ndkInstance.pool?.relays) {
+      for (const [url] of ndkInstance.pool.relays) relayUrls.add(url);
+    }
+    for (const url of PROFILE_RELAY_URLS) relayUrls.add(url);
+
+    const relays = [];
+    for (const url of relayUrls) {
+      // autoConnect=true, createIfMissing=true — purplepag.es etc.
+      // may not be in the pool yet; this opens a connection in the
+      // background. fetchEvent will queue against not-yet-ready
+      // relays and resolve when any of them returns.
+      const relay = ndkInstance.pool?.getRelay(url, true, true);
+      if (relay) relays.push(relay);
+    }
+    const relaySet = relays.length > 0 ? new NDKRelaySet(new Set(relays), ndkInstance) : undefined;
+
+    const fetchPromise = ndkInstance.fetchEvent(
+      { kinds: [0], authors: [pubkey] },
+      undefined,
+      relaySet
+    );
+    const timeoutPromise = new Promise<null>((resolve) =>
       setTimeout(() => resolve(null), PROFILE_FETCH_TIMEOUT)
     );
-    
-    await Promise.race([fetchPromise, timeoutPromise]);
-    
-    const profile = user.profile;
-    if (!profile) {
+
+    const event = await Promise.race([fetchPromise, timeoutPromise]);
+    if (!event) {
+      return null;
+    }
+
+    let parsed: Record<string, unknown> = {};
+    try {
+      parsed = JSON.parse(event.content || '{}');
+    } catch {
+      // Malformed kind:0 content — return null rather than a
+      // half-populated profile that would obscure the user's identity.
       return null;
     }
 
-    const profileData = {
+    // Nostr profile field naming has historically varied: NIP-01 says
+    // `name`, but many clients also (or only) populate `display_name`,
+    // and a few use camelCase `displayName`. Read all three so we
+    // surface the user's identity regardless of which client wrote
+    // their kind:0.
+    const name =
+      typeof parsed.name === 'string' ? parsed.name : undefined;
+    const displayName =
+      typeof parsed.display_name === 'string'
+        ? (parsed.display_name as string)
+        : typeof parsed.displayName === 'string'
+        ? (parsed.displayName as string)
+        : undefined;
+
+    const profileData: ProfileData = {
       pubkey,
-      name: profile.name,
-      display_name: profile.displayName,
-      picture: profile.image,
-      about: profile.bio,
-      nip05: profile.nip05,
-      lud16: profile.lud16,
+      name,
+      display_name: displayName,
+      picture: typeof parsed.picture === 'string' ? parsed.picture : undefined,
+      about: typeof parsed.about === 'string' ? parsed.about : undefined,
+      nip05: typeof parsed.nip05 === 'string' ? parsed.nip05 : undefined,
+      lud16: typeof parsed.lud16 === 'string' ? parsed.lud16 : undefined,
       lastFetched: Date.now()
     };
 
@@ -229,12 +284,22 @@ export function getDisplayName(profile: ProfileData | null): string {
 }
 
 // Get username for a profile (without @ prefix). Same fallback policy
-// as getDisplayName.
+// as getDisplayName: display_name → name → anon. Previously this only
+// checked `name`, which silently fell back to the anon helper for
+// profiles that set only `display_name` (a common shape on Nostr —
+// "display_name" is the human-readable identity, "name" is the optional
+// short handle). formatDisplayName, AuthorName, ProfileLink, and the
+// feed all flow through here, so the fix lights up display_name-only
+// profiles everywhere at once.
 export function getUsername(profile: ProfileData | null): string {
   if (!profile) {
     return getAnonChefName(null);
   }
 
+  if (profile.display_name) {
+    return profile.display_name;
+  }
+
   if (profile.name) {
     return profile.name;
   }