1 files changed, 49 insertions, 18 deletions

diff --git a/src/features/messages.js b/src/features/messages.js
index e1468ce..836966f 100644
--- a/src/features/messages.js
+++ b/src/features/messages.js
@@ -4923,25 +4923,38 @@ export function messagesFeature(ctx) {
   const notesCache = new Map(); // pk -> { status: 'loading'|'ready', notes: [kind-1 events] }
   // NIP-65: where this author actually writes. Their notes and threads live
   // there first — our default relays are just the common ground.
+  // Asked one at a time — a quoted note's author, a face tapped, a reply's
+  // target — these went out as one REQ per author per relay: a feed with
+  // six quotes on screen sent eighteen. Asks now wait a beat and go out
+  // together, one REQ with every author wanted, through the feed's own
+  // batched fetch, which also remembers who has no list so nobody is asked
+  // twice.
   const relayListCache = new Map(); // pk -> Promise<string[]>
+  const RELAY_ASK_MS = 80;
+  let relayAskQ = new Map(), relayAskTimer = null; // pk -> [resolve]
   function relaysOf(pk) {
     let p = relayListCache.get(pk);
     if (p) return p;
     // the feed's batched fetch has probably already asked for this one
     const known = relayListsNow().get(pk);
     if (known) { p = Promise.resolve(known.r || []); relayListCache.set(pk, p); return p; }
-    p = queryOn([...new Set([...PROFILE_RELAYS, ...NOTE_RELAYS])], { kinds: [10002], authors: [pk] }, 3500)
-      .then((evs) => {
-        const newest = (evs || []).sort((a, b) => b.created_at - a.created_at)[0];
-        if (!newest) return [];
-        return [...new Set(newest.tags
-          .filter((x) => x[0] === 'r' && x[1] && x[2] !== 'read' && /^wss:\/\//.test(x[1]))
-          .map((x) => x[1].replace(/\/$/, '')))].slice(0, 4);
-      })
-      .catch(() => []);
+    p = new Promise((resolve) => {
+      if (!relayAskQ.has(pk)) relayAskQ.set(pk, []);
+      relayAskQ.get(pk).push(resolve);
+      if (!relayAskTimer) relayAskTimer = setTimeout(flushRelayAsks, RELAY_ASK_MS);
+    });
     relayListCache.set(pk, p);
     return p;
   }
+  async function flushRelayAsks() {
+    relayAskTimer = null;
+    const batch = relayAskQ; relayAskQ = new Map();
+    try { await fetchRelayLists([...batch.keys()], [...new Set([...PROFILE_RELAYS, ...NOTE_RELAYS])]); } catch {}
+    for (const [pk, waiters] of batch) {
+      const r = ((relayListsNow().get(pk) || {}).r || []).slice(0, 4);
+      for (const w of waiters) w(r);
+    }
+  }
   // Plus relays that keep history: the big ones prune within days, and an
   // author without a NIP-65 list (Joe Nakamoto, 2026-10-01) otherwise shows
   // only whatever primal still holds — 2 posts of 22.
@@ -5385,12 +5398,12 @@ export function messagesFeature(ctx) {
   // small, widely mirrored, and worth having before anything else is asked.
   // Authors with no list at all are remembered as such, so we don't ask again
   // every time the feed refreshes.
-  async function fetchRelayLists(pks) {
+  async function fetchRelayLists(pks, relays = NOTE_RELAYS) {
     const want = [...new Set(pks)].filter((pk) => !relayListsNow().has(pk));
     if (!want.length) return;
     for (let i = 0; i < want.length; i += 100) {
       const batch = want.slice(i, i + 100);
-      const evs = await queryOn(NOTE_RELAYS, { kinds: [10002], authors: batch }, 4500).catch(() => []);
+      const evs = await queryOn(relays, { kinds: [10002], authors: batch }, 4500).catch(() => []);
       const newest = new Map();
       for (const ev of evs || []) {
         const cur = newest.get(ev.pubkey);
@@ -7770,22 +7783,33 @@ export function messagesFeature(ctx) {
   }
   // While the feed is what's on screen, new posts arrive by themselves — on
   // the same relays the pass above reads, one subscription each.
+  // The live subscriptions stay up across refreshes. Every refresh pass
+  // used to end by closing and reopening all of them — seventeen REQs over
+  // eight relays, twice per opening of Following — for subscriptions whose
+  // relays and authors hadn't changed; only the head they count fresh posts
+  // against moves, and that is read at each event.
+  let feedWatchKey = '', feedWatchHead = { t: Infinity };
   function watchFeed() {
-    stopFeedWatch();
     const c = feedNow();
     const def = feedDef(c.id); // the Conversations view has its own
-    if (!feedHasQuery(def) || !ui.chatOpen || ui.msgView !== 'feed') return;
+    if (!feedHasQuery(def) || !ui.chatOpen || ui.msgView !== 'feed') { stopFeedWatch(); return; }
     const newerThan = c.notes.length ? c.notes[0].created_at : Infinity;
     const since = Math.floor(Date.now() / 1000) - 60;
     const topics = feedTopics(def), tag = topics.length ? { '#t': topics } : {};
     const kinds = feedKinds(def);
-    const on = (ev) => { mergeFeed([ev], { live: true, newerThan }, c).then((ok) => { if (ok) scheduleRepaint(); }).catch(() => {}); };
     const authors = feedAuthors(def);
+    const orT = orTopicsOf(def);
+    const plan = def.curated || !authors.length ? [] : feedRelays(def) ? [{ relays: feedRelays(def), authors }] : outboxPlan(authors);
+    const key = [c.id, !!def.curated, !!def.all, !!def.replies, kinds.join(), topics.join(), orT.join(), (feedRelays(def) || []).join(),
+      ...plan.map(({ relays, authors: a }) => relays.join() + '>' + a.join())].join('\n');
+    if (feedUnsubs.length && key === feedWatchKey) { feedWatchHead.t = newerThan; return; }
+    stopFeedWatch();
+    feedWatchKey = key;
+    const head = feedWatchHead = { t: newerThan };
+    const on = (ev) => { mergeFeed([ev], { live: true, newerThan: head.t }, c).then((ok) => { if (ok) scheduleRepaint(); }).catch(() => {}); };
     if (def.curated) { const iv = setInterval(() => { if (c === feed && ui.chatOpen && ui.msgView === 'feed') refreshFeed({ force: true, live: true }, c).catch(() => {}); }, 120_000); feedUnsubs.push(() => clearInterval(iv)); return; }
     if (!authors.length) { feedUnsubs.push(subscribeOn(feedRelaysOr(def, def.all ? FIREHOSE_RELAYS : TOPIC_RELAYS), { kinds, ...tag, since }, on)); return; }
-    const orT = orTopicsOf(def);
     if (orT.length) feedUnsubs.push(subscribeOn(feedRelaysOr(def, TOPIC_RELAYS), { kinds, '#t': orT, since }, on));
-    const plan = feedRelays(def) ? [{ relays: feedRelays(def), authors }] : outboxPlan(authors);
     for (const { relays, authors: a } of plan)
       for (let i = 0; i < a.length; i += REQ_AUTHORS)
         feedUnsubs.push(subscribeOn(relays, { kinds: topics.length || def.replies ? kinds : [...kinds, REPOST], authors: a.slice(i, i + REQ_AUTHORS), ...tag, since }, on));
@@ -7793,6 +7817,7 @@ export function messagesFeature(ctx) {
   function stopFeedWatch() {
     for (const u of feedUnsubs) { try { u(); } catch {} }
     feedUnsubs = [];
+    feedWatchKey = '';
   }
   // Prepare older pages several screens ahead of the reader. A scroll while
   // preparation is underway shares the same work instead of exposing it early.
@@ -11270,10 +11295,16 @@ export function messagesFeature(ctx) {
     }
   }
   const REPORTS_MS = 30 * 60_000;
+  // The half hour counts from the last sync the device SAVED, so a reload
+  // (every open of the installed app is one) doesn't ask the outbox relays
+  // again — some forty REQs with every follow's reports — and a sync after
+  // one asks only for what came since. (The index is kept.)
   async function syncReports({ force = false } = {}) {
     if (!modOn('reports') || !myPubkeys().length) return;
-    if (!force && Date.now() - reportsAt < REPORTS_MS) return;
+    const last = Math.max(reportsAt, reportsNow().at || 0);
+    if (!force && Date.now() - last < REPORTS_MS) return;
     reportsAt = Date.now();
+    const since = last ? { since: Math.floor(last / 1000) - 3600 } : {};
     const authors = [...new Set([...myPubkeys(), ...followsNow().set])].slice(0, FEED_AUTHORS_MAX);
     const from = new Set(authors);
     try {
@@ -11282,7 +11313,7 @@ export function messagesFeature(ctx) {
       const got = await Promise.all(plan.flatMap(({ relays, authors: a }) => {
         const chunks = [];
         for (let i = 0; i < a.length; i += REQ_AUTHORS) chunks.push(a.slice(i, i + REQ_AUTHORS));
-        return chunks.map((chunk) => queryOn(relays, { kinds: [1984], authors: chunk, limit: 500 }, 5000).catch(() => []));
+        return chunks.map((chunk) => queryOn(relays, { kinds: [1984], authors: chunk, limit: 500, ...since }, 5000).catch(() => []));
       }));
       for (const ev of got.flat()) if (ev && ev.kind === 1984 && from.has(ev.pubkey)) noteReport(ev);
       reportsNow().at = Date.now();