1 files changed, 54 insertions, 1 deletions
diff --git a/src/nostr.js b/src/nostr.js
index c77fc27..f0b47d1 100644
--- a/src/nostr.js
+++ b/src/nostr.js
@@ -186,7 +186,12 @@ pool.ensureRelay = async (url, params) => {
     relay._coinosRL = true;
     const notice = relay.onnotice;
     relay.onnotice = (msg) => {
-      if (RATE_LIMITED.test(String(msg))) markRelayRateLimited(relay.url, String(msg));
+      // Primal's "too many concurrent REQs" is advice, not a refusal: every
+      // REQ past its twenty is answered all the same (measured: 60 at once,
+      // 60 EOSEs, 12 notices). Cooling it off for 30 s at every boot — when
+      // the relay lists, profiles and the feed all ask at once — only lost
+      // us its answers. A CLOSED with that reason still counts (below).
+      if (RATE_LIMITED.test(String(msg)) && !/concurrent/i.test(String(msg))) markRelayRateLimited(relay.url, String(msg));
       try { notice?.call(relay, msg); } catch {}
     };
     const subscribe = relay.subscribe.bind(relay);
@@ -284,6 +289,54 @@ export function resetRelay(url) {
   try { r.close(); } catch {}
   pool.relays.delete(n);
 }
+// Back from a freeze (a phone's backgrounded tab: timers stopped, the
+// network's idea of every socket long gone), the pool's sockets still read
+// OPEN, and anything sent on them vanishes. Left to itself the library
+// notices one in up to 29 s (its ping) + 20 s (the ping's timeout), then
+// waits 10 s more before redialing — a minute of a feed that won't catch up
+// ("no new notes since 11:35?", Adam, 2026-11-01). So on resume every open
+// socket is asked one tiny REQ; one that answers within the deadline is
+// fine, one that doesn't is closed and redialed now, its subscriptions
+// refired by the library with `since` set to the last event each saw. A
+// relay already waiting out a reconnect backoff is dialed now too.
+const WAKE_PING_MS = 2500;
+const DUMMY_ID = 'a'.repeat(64);
+function pingRelay(r, ms) {
+  return new Promise((resolve) => {
+    let done = false;
+    const fin = (ok) => { if (done) return; done = true; clearTimeout(t); resolve(ok); };
+    const t = setTimeout(() => fin(false), ms);
+    try {
+      const sub = r.subscribe([{ ids: [DUMMY_ID], limit: 0 }], {
+        label: '<wake-ping>',
+        oneose: () => { fin(true); try { sub.close(); } catch {} },
+        onclose: () => fin(true), // a relay refusing the REQ is a relay that answers
+        eoseTimeout: ms + 1000, // ours fires first: the library's would count as an EOSE
+      });
+    } catch { fin(false); }
+  });
+}
+function redialRelay(r, why) {
+  console.warn('nostr: ' + r.url + ' ' + why + ' — redialing');
+  // the dead socket's close would reach the library long after (a closing
+  // handshake nobody answers), and undo the new connection: detached first
+  const ws = r.ws;
+  try { if (ws) { ws.onopen = ws.onclose = ws.onerror = ws.onmessage = null; ws.close(); } } catch {}
+  try { r.handleHardClose(why); } catch {} // the library's own path: subscriptions kept, a reconnect queued
+  if (r.reconnectTimeoutHandle) { clearTimeout(r.reconnectTimeoutHandle); r.reconnectTimeoutHandle = undefined; }
+  r.connect().catch(() => {}); // now, not after the backoff
+}
+export async function wakeRelays(ms = WAKE_PING_MS) {
+  const checks = [];
+  for (const r of pool.relays.values()) {
+    if (r.connected && r.ws && r.ws.readyState === 1) checks.push(pingRelay(r, ms).then((ok) => { if (!ok) redialRelay(r, 'silent after resume'); }));
+    else if (!r.connectionPromise && r.reconnectTimeoutHandle) {
+      clearTimeout(r.reconnectTimeoutHandle); r.reconnectTimeoutHandle = undefined;
+      r.connect().catch(() => {});
+    }
+  }
+  await Promise.all(checks);
+}
 // the relays a subscription on this list actually dials (sick ones skipped)
 export const liveRelayList = (list) => liveRelays(list);
 // ...and the ones a one-shot read goes to (rate-limited ones skipped too)