wireweave 0.3.41 → 0.3.42

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wireweave",
-  "version": "0.3.41",
+  "version": "0.3.42",
   "description": "nostr + webrtc voice + data SDK. networking layer for 247420 projects.",
   "type": "module",
   "main": "./src/index.js",

package/src/index.js

@@ -1,4 +1,4 @@
-export { RelayPool, createRelayPool } from './relay-pool.js';
+export { RelayPool, createRelayPool, RelayHealth } from './relay-pool.js';
 export { NostrAuth, createAuth } from './auth.js';
 export { createFSM } from './fsm.js';
 export { VoiceSession, createVoiceSession } from './voice.js';

package/src/relay-pool.js

@@ -1,3 +1,6 @@
+import { safeSetItem } from './safe-storage.js';
+import * as debug from './debug.js';
+
 // Ordered fastest-first by measured connect latency; dead relays removed so
 // signaling reaches a live relay immediately instead of racing dead hosts.
 // (relay.nostr.band / nostr.wine / relay.current.fyi / relay.0xchat.com were
@@ -12,12 +15,94 @@ const DEFAULT_RELAYS = [
   'wss://relay.damus.io'
 ];
 
+// Backup pool candidates auto-rotation can promote in when a connected relay's
+// health score falls below a healthy alternative's — never DEFAULT_RELAYS
+// members already in play, so rotation always trades toward strictly-better.
+const FALLBACK_RELAYS = [
+  'wss://relay.nostr.band',
+  'wss://nostr.wine',
+  'wss://relay.current.fyi',
+  'wss://relay.0xchat.com'
+];
+
 const SEEN_MAX = 10000;
 const PENDING_MAX = 500;
 const PENDING_TTL_MS = 120000;
 const CONNECT_TIMEOUT_MS = 10000;
 const jitter = (ms) => Math.round(ms * (0.75 + Math.random() * 0.5));
 
+// EWMA smoothing for latency/EOSE-speed samples — recent samples dominate but
+// a single slow sample doesn't crater a relay's score outright.
+const EWMA_ALPHA = 0.3;
+const ewma = (prev, sample) => prev === null ? sample : prev + EWMA_ALPHA * (sample - prev);
+
+const HEALTH_STORAGE_KEY = 'ww_relay_health';
+const HEALTH_SAVE_DEBOUNCE_MS = 2000;
+
+// health.rank: 0..100, higher is better. Weighted blend of connect latency,
+// EOSE response speed, and uptime ratio (successful sustained connections vs
+// total attempts). Missing samples (relay never connected / no EOSE seen yet)
+// score neutral (50) for that component rather than zero, so a fresh relay
+// isn't unfairly punished before it has a chance to report real numbers.
+const scoreLatency = (ms) => ms === null ? 50 : Math.max(0, 100 - Math.min(ms, 3000) / 30);
+const scoreEose = (ms) => ms === null ? 50 : Math.max(0, 100 - Math.min(ms, 5000) / 50);
+const scoreUptime = (attempts, successes) => attempts === 0 ? 50 : Math.round((successes / attempts) * 100);
+
+const computeRank = (health) => Math.round(
+  0.35 * scoreLatency(health.connectLatencyMs) +
+  0.35 * scoreEose(health.eoseLatencyMs) +
+  0.30 * scoreUptime(health.attempts, health.successes)
+);
+
+class RelayHealth {
+  constructor(url) {
+    this.url = url;
+    this.connectLatencyMs = null;
+    this.eoseLatencyMs = null;
+    this.attempts = 0;
+    this.successes = 0;
+    this.rank = 50;
+  }
+
+  recordConnectAttempt() { this.attempts++; }
+
+  recordConnectLatency(ms) {
+    this.connectLatencyMs = ewma(this.connectLatencyMs, ms);
+    this.rank = computeRank(this);
+  }
+
+  recordSustainedConnection() {
+    this.successes++;
+    this.rank = computeRank(this);
+  }
+
+  recordEoseLatency(ms) {
+    this.eoseLatencyMs = ewma(this.eoseLatencyMs, ms);
+    this.rank = computeRank(this);
+  }
+
+  toJSON() {
+    return {
+      url: this.url,
+      connectLatencyMs: this.connectLatencyMs,
+      eoseLatencyMs: this.eoseLatencyMs,
+      attempts: this.attempts,
+      successes: this.successes,
+      rank: this.rank
+    };
+  }
+
+  static fromJSON(obj) {
+    const h = new RelayHealth(obj.url);
+    h.connectLatencyMs = obj.connectLatencyMs ?? null;
+    h.eoseLatencyMs = obj.eoseLatencyMs ?? null;
+    h.attempts = obj.attempts ?? 0;
+    h.successes = obj.successes ?? 0;
+    h.rank = obj.rank ?? computeRank(h);
+    return h;
+  }
+}
+
 const lruTouch = (map, key) => {
   if (map.has(key)) { map.delete(key); map.set(key, 1); return false; }
   map.set(key, 1);
@@ -34,7 +119,7 @@ const fnv1a = (s) => {
 const safeSubId = (subId) => subId.length <= 64 ? subId : subId.slice(0, 55) + '-' + fnv1a(subId);
 
 export class RelayPool extends EventTarget {
-  constructor({ relays = DEFAULT_RELAYS, verifyEvent = null, WebSocketImpl = null } = {}) {
+  constructor({ relays = DEFAULT_RELAYS, verifyEvent = null, WebSocketImpl = null, storage = null, fallbackRelays = FALLBACK_RELAYS, autoRotate = true } = {}) {
     super();
     this.urls = [...relays];
     this.relays = new Map();
@@ -48,6 +133,116 @@ export class RelayPool extends EventTarget {
     this.verifyEvent = verifyEvent;
     this.WS = WebSocketImpl || (typeof WebSocket !== 'undefined' ? WebSocket : null);
     if (!this.WS) throw new Error('No WebSocket implementation available');
+
+    this.storage = storage;
+    this.autoRotate = autoRotate;
+    this.fallbackRelays = [...fallbackRelays];
+    this.health = new Map();
+    for (const url of this.urls) this.health.set(url, new RelayHealth(url));
+    this._loadHealth();
+    this._saveHealthTimer = null;
+
+    // Debug-panel integration: window.__wireweave.relayPool (or relayPool2,
+    // relayPool3... for additional instances) exposes healthReport() live.
+    this._debugKey = 'relayPool';
+    let n = 2;
+    while (debug.get(this._debugKey)) this._debugKey = 'relayPool' + n++;
+    debug.register(this._debugKey, this);
+  }
+
+  // --- Health scoring / persistence -------------------------------------
+
+  _getHealth(url) {
+    let h = this.health.get(url);
+    if (!h) { h = new RelayHealth(url); this.health.set(url, h); }
+    return h;
+  }
+
+  _loadHealth() {
+    if (!this.storage) return;
+    try {
+      const raw = this.storage.getItem(HEALTH_STORAGE_KEY);
+      if (!raw) return;
+      const parsed = JSON.parse(raw);
+      if (!Array.isArray(parsed)) return;
+      for (const entry of parsed) {
+        if (!entry?.url) continue;
+        this.health.set(entry.url, RelayHealth.fromJSON(entry));
+      }
+    } catch { /* corrupt/absent persisted health is non-fatal — scores rebuild live */ }
+  }
+
+  _scheduleSaveHealth() {
+    if (!this.storage) return;
+    if (this._saveHealthTimer) return;
+    this._saveHealthTimer = setTimeout(() => {
+      this._saveHealthTimer = null;
+      this._saveHealthNow();
+    }, HEALTH_SAVE_DEBOUNCE_MS);
+  }
+
+  _saveHealthNow() {
+    if (!this.storage) return;
+    const out = [];
+    for (const [, h] of this.health) out.push(h.toJSON());
+    safeSetItem(this.storage, this, HEALTH_STORAGE_KEY, JSON.stringify(out));
+  }
+
+  // Sorted best-first snapshot for a debug panel / inspection.
+  healthReport() {
+    const out = [];
+    for (const [, h] of this.health) out.push(h.toJSON());
+    out.sort((a, b) => b.rank - a.rank);
+    return out;
+  }
+
+  // Swap the worst currently-active relay for the best-ranked unused
+  // candidate (fallback pool, or a previously-tried relay we disconnected
+  // from) when the gap is large enough to be worth the churn of a new
+  // connection. Never rotates below MIN_ACTIVE_RELAYS active URLs.
+  _maybeRotate() {
+    if (!this.autoRotate || this._closed) return;
+    const MIN_ACTIVE_RELAYS = 2;
+    const ROTATE_GAP = 20;
+    if (this.urls.length <= MIN_ACTIVE_RELAYS) return;
+
+    const active = this.urls
+      .map((url) => this._getHealth(url))
+      .filter((h) => h.attempts >= 2); // need a couple of samples before judging
+    if (active.length === 0) return;
+    const worst = active.reduce((a, b) => (a.rank <= b.rank ? a : b));
+
+    const candidates = this.fallbackRelays.filter((u) => !this.urls.includes(u));
+    if (candidates.length === 0) return;
+    const candidateHealth = candidates.map((u) => this._getHealth(u));
+    const best = candidateHealth.reduce((a, b) => (a.rank >= b.rank ? a : b));
+    // Only rotate toward a candidate with real observed history beating the
+    // worst active relay by a wide margin — an untested candidate (rank 50
+    // neutral default) never displaces a relay with a real track record.
+    if (best.attempts === 0) return;
+    if (best.rank - worst.rank < ROTATE_GAP) return;
+
+    this._rotate(worst.url, best.url);
+  }
+
+  _rotate(outUrl, inUrl) {
+    const idx = this.urls.indexOf(outUrl);
+    if (idx === -1) return;
+    this.urls[idx] = inUrl;
+    this.fallbackRelays = this.fallbackRelays.filter((u) => u !== inUrl);
+    this.fallbackRelays.push(outUrl);
+
+    const old = this.relays.get(outUrl);
+    if (old) {
+      if (old._connectTimer) clearTimeout(old._connectTimer);
+      if (old.ws) { old.ws.onclose = null; old.ws.onerror = null; old.ws.onopen = null; old.ws.onmessage = null; try { old.ws.close(); } catch {} }
+      this.relays.delete(outUrl);
+    }
+    const t = this._reconnectTimers.get(outUrl);
+    if (t) { clearTimeout(t); this._reconnectTimers.delete(outUrl); }
+
+    this._emit('relay-rotated', { out: outUrl, in: inUrl, outRank: this._getHealth(outUrl).rank, inRank: this._getHealth(inUrl).rank });
+    if (!this._closed) this._open(inUrl);
   }
 
   connect() {
@@ -71,6 +266,9 @@ export class RelayPool extends EventTarget {
       }
     }
     this.relays.clear();
+    if (this._saveHealthTimer) { clearTimeout(this._saveHealthTimer); this._saveHealthTimer = null; }
+    this._saveHealthNow();
+    debug.deregister(this._debugKey);
   }
 
   _open(url) {
@@ -78,10 +276,14 @@ export class RelayPool extends EventTarget {
     this._reconnectTimers.delete(url);
     const existing = this.relays.get(url);
     if (existing?.ws && (existing.ws.readyState === 0 || existing.ws.readyState === 1)) return;
-    const relay = existing || { ws: null, status: 'connecting', subIds: new Set(), latencyMs: null, failCount: 0, reconnectDelay: 1000, _reqSentAt: null, _openedAt: null };
+    const relay = existing || { ws: null, status: 'connecting', subIds: new Set(), latencyMs: null, failCount: 0, reconnectDelay: 1000, _reqSentAt: null, _openedAt: null, _eoseReqSentAt: new Map() };
+    if (!relay._eoseReqSentAt) relay._eoseReqSentAt = new Map();
     relay.status = 'connecting';
     relay.latencyMs = null;
     this.relays.set(url, relay);
+    const health = this._getHealth(url);
+    health.recordConnectAttempt();
+    const connectStartedAt = Date.now();
     let ws;
     try { ws = new this.WS(url); }
     catch (e) { relay.status = 'error'; this._emit('relay-status', { url, status: 'error' }); return; }
@@ -95,11 +297,14 @@ export class RelayPool extends EventTarget {
       clearTimeout(connectTimer);
       relay.status = 'connected';
       relay._openedAt = Date.now();
+      health.recordConnectLatency(relay._openedAt - connectStartedAt);
+      this._scheduleSaveHealth();
       this._emit('relay-status', { url, status: 'connected' });
       for (const [subId, sub] of this.subs) {
         ws.send(JSON.stringify(['REQ', subId, ...sub.filters]));
         relay.subIds.add(subId);
         if (!relay._reqSentAt) relay._reqSentAt = Date.now();
+        relay._eoseReqSentAt.set(subId, Date.now());
       }
       this._drainPending(url, ws);
     };
@@ -116,8 +321,16 @@ export class RelayPool extends EventTarget {
       relay.status = 'closed';
       this._emit('relay-status', { url, status: 'closed' });
       const sustained = relay._openedAt && Date.now() - relay._openedAt > 5000;
-      if (sustained) { relay.failCount = 0; relay.reconnectDelay = 1000; }
-      else { relay.failCount++; relay.reconnectDelay = Math.min(relay.reconnectDelay * 2, 30000); }
+      if (sustained) {
+        relay.failCount = 0;
+        relay.reconnectDelay = 1000;
+        health.recordSustainedConnection();
+        this._scheduleSaveHealth();
+        this._maybeRotate();
+      } else {
+        relay.failCount++;
+        relay.reconnectDelay = Math.min(relay.reconnectDelay * 2, 30000);
+      }
       relay._openedAt = null;
       if (this._closed) return;
       const t = setTimeout(() => this._open(url), jitter(relay.reconnectDelay));
@@ -142,6 +355,13 @@ export class RelayPool extends EventTarget {
       sub?.onEvent?.(event);
       this._emit('event', { subId, event });
     } else if (type === 'EOSE') {
+      const relay = this.relays.get(url);
+      const sentAt = relay?._eoseReqSentAt?.get(subId);
+      if (sentAt) {
+        relay._eoseReqSentAt.delete(subId);
+        this._getHealth(url).recordEoseLatency(Date.now() - sentAt);
+        this._scheduleSaveHealth();
+      }
       this.subs.get(subId)?.onEose?.();
       this._emit('eose', { subId });
     } else if (type === 'NOTICE') {
@@ -163,6 +383,8 @@ export class RelayPool extends EventTarget {
         relay.ws.send(JSON.stringify(['REQ', subId, ...filters]));
         relay.subIds.add(subId);
         if (!relay._reqSentAt) relay._reqSentAt = Date.now();
+        if (!relay._eoseReqSentAt) relay._eoseReqSentAt = new Map();
+        relay._eoseReqSentAt.set(subId, Date.now());
       }
     }
     return subId;
@@ -290,3 +512,4 @@ export class RelayPool extends EventTarget {
 }
 
 export const createRelayPool = (opts) => new RelayPool(opts);
+export { RelayHealth };