some fixes

Author: arcbtc

src/lib/nostr/client.ts

@@ -27,6 +27,8 @@ type SearchFilter = Filter & { search?: string };
 const bunkerSigners = new Map<string, nip46.BunkerSigner>();
 const connectedBunkerSignerKeys = new Set<string>();
 const bunkerConnectionPromises = new Map<string, Promise<void>>();
+const nip07DetectionTimeoutMs = 3000;
+const nip07DetectionIntervalMs = 100;
 type SubCloser = { close: (reason?: string) => void };
 type PomegranateProfile = { name: string; handler_pubkey: string; email?: string };
 type PomegranateAccount = { pubkey: string; email?: string };
@@ -164,12 +166,24 @@ export function createGuestSession(): Session {
 }
 
 export async function loginWithNip07(): Promise<Session> {
-  if (!window.nostr) throw new Error('No NIP-07 extension was found.');
-  const pubkey = await withTimeout(window.nostr.getPublicKey(), 30_000, 'The NIP-07 extension did not respond.');
+  const signer = await waitForNip07();
+  if (!signer) throw new Error('No NIP-07 extension was found. In Chrome, check the extension is enabled for nostr.com, then reload the page.');
+  const pubkey = await withTimeout(signer.getPublicKey(), 30_000, 'The NIP-07 extension did not respond.');
   if (!/^[0-9a-f]{64}$/i.test(pubkey)) throw new Error('The NIP-07 extension returned an invalid public key.');
   return { pubkey: pubkey.toLowerCase(), mode: 'nip07' };
 }
 
+async function waitForNip07() {
+  if (typeof window === 'undefined') return undefined;
+  if (window.nostr) return window.nostr;
+  const startedAt = Date.now();
+  while (Date.now() - startedAt < nip07DetectionTimeoutMs) {
+    await sleep(nip07DetectionIntervalMs);
+    if (window.nostr) return window.nostr;
+  }
+  return undefined;
+}
+
 export function loginWithPrivateKey(secret: string): Session {
   const normalized = secret.trim();
   const bytes = normalized.startsWith('nsec1') ? decodeNsec(normalized) : hexToBytes(normalized);
@@ -190,6 +204,10 @@ async function withTimeout<T>(promise: Promise<T>, ms: number, message: string)
   }
 }
 
+function sleep(ms: number) {
+  return new Promise<void>((resolve) => setTimeout(resolve, ms));
+}
+
 async function mapWithConcurrency<T, R>(items: T[], concurrency: number, mapper: (item: T) => Promise<R>) {
   const results: R[] = [];
   let index = 0;

src/lib/stores/app.ts

@@ -2,6 +2,7 @@ import { browser } from '$app/environment';
 import { goto } from '$app/navigation';
 import { writable } from 'svelte/store';
 import {
+  cacheEvents,
   cacheDirectMessages,
   cacheNotifications,
   clearEventCache,
@@ -1160,6 +1161,7 @@ export async function postNote(content: string, parent?: NostrEvent, extraTags:
   const event = await publishNote(currentSession, content, currentRelays, tags);
   seenLiveStatEvents.add(event.id);
   events.update((existing) => mergeEvents([event], existing));
+  void cacheEvents([event]);
   if (parent) mergeLocalReplyStats(event);
   replyTarget.set(null);
   quoteTarget.set(null);
@@ -1242,6 +1244,7 @@ export async function repostNote(target: NostrEvent) {
   try {
     const event = await publishRepost(currentSession, target, currentRelays);
     events.update((existing) => mergeEvents([event], existing));
+    void cacheEvents([event]);
   } catch (err) {
     repostedEvents.update((existing) => {
       const next = new Set(existing);
@@ -1625,7 +1628,7 @@ async function activateSession(
   notifications.set([]);
   loadingFeed.set(true);
   if (!hasExplicitFeedModeSelection && previousFeedMode === 'global') feedMode.set('global');
-  void finishSignedInBootstrap(next);
+  await finishSignedInBootstrap(next);
 }
 
 function restoreSession(next: Session) {
@@ -1901,10 +1904,10 @@ async function hydrateDefaultFeedContext() {
 
 async function finishSignedInBootstrap(next: Session) {
   try {
-    await hydrateSignedInFeedContext(next);
+    await hydrateSignedInFeedContext(next).catch(() => undefined);
     if (!isCurrentSession(next)) return;
     selectPreferredSignedInFeed(true);
-    await refreshFeed(currentMode);
+    await refreshSignedInFeedWithFallback();
     void warmSignedInSession(next, { refreshFeed: false });
     restartInboxSubscriptions();
     if (pendingGoogleOnboardingPubkey === next.pubkey && shouldOfferGoogleOnboarding(next, 'google')) onboardingDialogOpen.set(true);
@@ -1913,6 +1916,17 @@ async function finishSignedInBootstrap(next: Session) {
   }
 }
 
+async function refreshSignedInFeedWithFallback() {
+  await refreshFeed(currentMode).catch(() => undefined);
+  if (getStoreSnapshot(events).length || currentMode === 'global') return;
+  activeHashtag.set('');
+  cachedOlderEvents = [];
+  olderFeedEmptyAttempts = 0;
+  hasMoreFeed.set(true);
+  feedMode.set('global');
+  await refreshFeed('global').catch(() => undefined);
+}
+
 async function warmSignedInSession(currentSession: Session, options: { refreshFeed?: boolean } = {}) {
   if (!isCurrentSession(currentSession)) return;
   await Promise.all([

src/routes/+page.svelte

@@ -1,5 +1,6 @@
 <script lang="ts">
   import { onMount, tick } from 'svelte';
+  import { browser } from '$app/environment';
   import { page } from '$app/stores';
   import { beforeNavigate, goto } from '$app/navigation';
   import { ArrowUp, Plus } from '@lucide/svelte';
@@ -46,15 +47,20 @@
   let hideNewerBubbleTimeout: ReturnType<typeof setTimeout> | undefined;
   let restoredFeedPosition = false;
   let clickedFeedNoteSaved = false;
+  let autoFillRunning = false;
+  let autoFillQueued = false;
+  let autoFillTimer: ReturnType<typeof setTimeout> | undefined;
   const pullThreshold = 78;
   const newerBubbleCooldownMs = 5000;
   const feedScrollStateMaxAgeMs = 30 * 60 * 1000;
+  const autoFillMaxLoads = 5;
   $: hasReadRelays = $relays.some((relay) => relay.enabled && relay.read);
   $: feedEvents = hashtagFilteredEvents(displayEventsForFeedMode($feedMode, topLevelFeedEvents($events), $follows, $customFeedSettings), $activeHashtag);
   $: if (observer && loadMoreSentinel && feedEvents.length) {
     observer.unobserve(loadMoreSentinel);
     observer.observe(loadMoreSentinel);
   }
+  $: if (browser) scheduleFeedAutoFill();
   $: pullProgress = Math.min(1, pullDistance / pullThreshold);
   $: showNewerBubble = canLoadNewerForFeed() && $pendingNewerEvents.length && !pullingNewer && !hideNewerBubble && !pullStartedAtTop && pullDistance <= 0;
   $: emptyMessage = !hasReadRelays
@@ -114,6 +120,7 @@
       observer?.disconnect();
       clearTimeout(hideNewerBubbleTimeout);
       clearTimeout(wheelPullTimeout);
+      clearTimeout(autoFillTimer);
       removeEventListener('scroll', onScroll);
       removeEventListener('touchstart', startPullForNewer);
       removeEventListener('touchmove', updatePullForNewer);
@@ -217,6 +224,39 @@
     }
   }
 
+  function scheduleFeedAutoFill() {
+    if (!feedEvents.length || $loadingFeed || $loadingMoreFeed || !$hasMoreFeed || autoFillQueued || autoFillRunning) return;
+    autoFillQueued = true;
+    clearTimeout(autoFillTimer);
+    autoFillTimer = setTimeout(() => {
+      autoFillQueued = false;
+      void autoFillFeedViewport();
+    }, 80);
+  }
+
+  async function autoFillFeedViewport() {
+    if (autoFillRunning) return;
+    autoFillRunning = true;
+    try {
+      for (let attempt = 0; attempt < autoFillMaxLoads; attempt += 1) {
+        await tick();
+        if (!shouldAutoLoadOlderFeed()) return;
+        const beforeCount = feedEvents.length;
+        await requestOlderFeed();
+        await tick();
+        if (feedEvents.length <= beforeCount || !shouldAutoLoadOlderFeed()) return;
+      }
+    } finally {
+      autoFillRunning = false;
+    }
+  }
+
+  function shouldAutoLoadOlderFeed() {
+    if (!feedEvents.length || $loadingFeed || $loadingMoreFeed || !$hasMoreFeed || requestingOlder) return false;
+    const page = document.documentElement;
+    return page.scrollHeight <= window.innerHeight + 180 || isNearPageBottom();
+  }
+
   function saveCurrentFeedScrollPosition() {
     const anchor = firstVisibleFeedNote();
     saveFeedScrollPositionForAnchor(anchor);

src/routes/profile/[pubkey]/+page.svelte

@@ -100,6 +100,7 @@
     profileEvents = profileEvents.filter((event) => !$deletedEventIds.has(event.id));
     profileSummaryEvents = profileSummaryEvents.filter((event) => !$deletedEventIds.has(event.id));
   }
+  $: if (browser && pubkey) mergeProfileEventsFromGlobalStore(pubkey, $events);
   $: if (browser && routeKey && userItems.length && routeKey !== restoredProfileRouteKey) void restoreProfileScrollPosition(routeKey);
 
   beforeNavigate(() => {
@@ -357,6 +358,20 @@
     void refreshProfileStats();
   }
 
+  function mergeProfileEventsFromGlobalStore(targetPubkey: string, storeEvents: NostrEvent[]) {
+    if (!targetPubkey || !storeEvents.length) return;
+    const existingIds = new Set([...profileEvents, ...profileSummaryEvents].map((event) => event.id));
+    const freshProfileEvents = storeEvents.filter(
+      (event) =>
+        event.pubkey === targetPubkey &&
+        !existingIds.has(event.id) &&
+        eventInProfileWindow(event, profileRecentWindowLowerBound(), profileRecentWindowUpperBound()) &&
+        (event.kind === 1 || event.kind === 6 || event.kind === 30023)
+    );
+    if (!freshProfileEvents.length) return;
+    addProfileEvents(freshProfileEvents);
+  }
+
   function refreshProfileStats() {
     const statIds = [...new Set(profileNoteItems.map((item) => item.event.id))];
     if (statIds.length) void refreshEventStats(statIds, true);

src/routes/thread/[id]/+page.svelte

@@ -25,6 +25,8 @@
   const threadScrollStateMaxAgeMs = 30 * 60 * 1000;
   const threadReplyWindowSeconds = 60 * 60 * 24 * 30;
   const threadReplyWindowScanLimit = 6;
+  const threadReplyRetryDelaysMs = [2500, 5000, 10000, 20000, 30000];
+  const threadReplyRetryMaxAttempts = threadReplyRetryDelaysMs.length;
 
   let loading = true;
   let loadingOlderReplies = false;
@@ -43,6 +45,9 @@
   let liveThreadSub: { close: (reason?: string) => void } | undefined;
   let liveThreadKey = '';
   let liveThreadToken = 0;
+  let threadReplyRetryKey = '';
+  let threadReplyRetryAttempts = 0;
+  let threadReplyRetryTimer: ReturnType<typeof setTimeout> | undefined;
   const seenLiveThreadEventIds = new Set<string>();
 
   $: routeId = decodeURIComponent($page.params.id ?? '');
@@ -65,7 +70,9 @@
   $: if (browser && routeKey && focusedReplyId && threadReplyItems.some((item) => item.event.id === focusedReplyId) && `${routeKey}:${focusedReplyId}` !== focusedThreadRouteKey) {
     void scrollFocusedReplyIntoView(routeKey, focusedReplyId);
   }
+  $: if (browser && root?.id) mergeThreadEventsFromGlobalStore(root.id, $events);
   $: if (browser) syncThreadLiveSubscription(root?.id ?? '', [root?.id ?? '', ...replies.map((reply) => reply.id)]);
+  $: if (browser) syncMissingReplyRetry(root?.id ?? '', $eventStats[root?.id ?? '']?.replies ?? 0, replies.length);
 
   beforeNavigate(() => {
     saveCurrentThreadState();
@@ -89,6 +96,7 @@
     saveCurrentThreadScrollPosition();
     bottomObserver?.disconnect();
     stopThreadLiveSubscription('leaving thread page');
+    clearThreadReplyRetry();
   });
 
   $: if (browser && id && id !== hydratedId) void hydrateThread();
@@ -332,6 +340,29 @@
     }
   }
 
+  function mergeThreadEventsFromGlobalStore(rootId: string, storeEvents: NostrEvent[]) {
+    if (!rootId || !storeEvents.length) return;
+    const existingItems = threadEventsForCache();
+    const existingIds = new Set(existingItems.map((event) => event.id));
+    const rootFromStore = storeEvents.find((event) => event.id === rootId);
+    const freshRoot = rootFromStore && !rootEvent ? rootFromStore : undefined;
+    const candidateThread = mergeThreadEvents([...(freshRoot ? [freshRoot] : []), ...storeEvents], existingItems);
+    const freshReplies = threadReplyEvents(candidateThread, rootId).filter((event) => !existingIds.has(event.id));
+
+    if (!freshRoot && !freshReplies.length) return;
+    if (freshRoot) rootEvent = freshRoot;
+    if (freshReplies.length) {
+      localThreadEvents = mergeThreadEvents(freshReplies, localThreadEvents);
+      trimThreadReplyWindow('bottom');
+    }
+
+    const freshItems = [...(freshRoot ? [freshRoot] : []), ...freshReplies];
+    hydrateThreadProfiles(freshItems);
+    refreshThreadStats(freshItems);
+    void pruneDeletedEvents(freshItems);
+    saveCurrentThreadState();
+  }
+
   function cachedThreadSeed(rootId: string, focusId: string) {
     const directSeed = readThreadSeed(rootId);
     const focusSeed = focusId && focusId !== rootId ? readThreadSeed(focusId) : null;
@@ -367,6 +398,7 @@
     loadingOlderReplies = false;
     hasOlderReplies = true;
     olderThreadReplyCursor = 0;
+    resetThreadReplyRetry();
     stopThreadLiveSubscription('thread changed');
     if (restoreHydratedThread(nextId)) {
       loading = false;
@@ -497,6 +529,71 @@
     liveThreadKey = '';
   }
 
+  function syncMissingReplyRetry(rootId: string, expectedReplies: number, loadedReplies: number) {
+    if (!rootId) {
+      clearThreadReplyRetry();
+      return;
+    }
+    if (threadReplyRetryKey !== rootId) {
+      clearThreadReplyRetry();
+      threadReplyRetryKey = rootId;
+      threadReplyRetryAttempts = 0;
+    }
+    if (loading || loadingOlderReplies || threadReplyRetryTimer) return;
+    if (loadedReplies >= expectedReplies || expectedReplies <= 0) {
+      clearThreadReplyRetry();
+      threadReplyRetryKey = rootId;
+      threadReplyRetryAttempts = 0;
+      return;
+    }
+    if (threadReplyRetryAttempts >= threadReplyRetryMaxAttempts) return;
+
+    const delay = threadReplyRetryDelaysMs[Math.min(threadReplyRetryAttempts, threadReplyRetryDelaysMs.length - 1)];
+    threadReplyRetryTimer = setTimeout(() => {
+      threadReplyRetryTimer = undefined;
+      void retryMissingThreadReplies(rootId);
+    }, delay);
+  }
+
+  async function retryMissingThreadReplies(rootId: string) {
+    if (id !== rootId || loading || loadingOlderReplies) return;
+    threadReplyRetryAttempts += 1;
+    loading = true;
+    const loadedBefore = threadReplyEvents(threadEventsForCache(), rootId).length;
+    try {
+      const replyBatch = await fetchThreadReplyWindow({ limit: initialThreadReplyLimit });
+      if (id !== rootId) return;
+      if (!replyBatch.events.length) return;
+
+      localThreadEvents = mergeThreadEvents(replyBatch.events, localThreadEvents);
+      trimThreadReplyWindow('bottom');
+      hydrateThreadProfiles(replyBatch.events);
+      refreshThreadStats(replyBatch.events);
+      void pruneDeletedEvents(replyBatch.events);
+
+      const loadedAfter = threadReplyEvents(threadEventsForCache(), rootId).length;
+      if (loadedAfter > loadedBefore) {
+        threadReplyRetryAttempts = 0;
+        olderThreadReplyCursor = nextThreadForwardCursor(replyBatch.events, olderThreadReplyCursor || rootEvent?.created_at || 0);
+        hasOlderReplies = hasOlderReplies || replyBatch.directCount >= initialThreadReplyLimit;
+      }
+      saveCurrentThreadState();
+    } finally {
+      if (id === rootId) loading = false;
+    }
+  }
+
+  function resetThreadReplyRetry() {
+    clearThreadReplyRetry();
+    threadReplyRetryKey = '';
+    threadReplyRetryAttempts = 0;
+  }
+
+  function clearThreadReplyRetry() {
+    if (threadReplyRetryTimer) clearTimeout(threadReplyRetryTimer);
+    threadReplyRetryTimer = undefined;
+  }
+
   function handleLiveThreadEvent(rootId: string, statIds: string[], event: NostrEvent, token: number) {
     if (token !== liveThreadToken || id !== rootId || seenLiveThreadEventIds.has(event.id)) return;
     seenLiveThreadEventIds.add(event.id);