wireweave 0.1.1

package/src/legacy/nostr-channels.js

@@ -0,0 +1,145 @@
+var DEFAULT_CATEGORIES = [
+  { id: 'general', name: 'TEXT CHANNELS', position: 0 },
+  { id: 'voice', name: 'VOICE CHANNELS', position: 1 }
+];
+
+var DEFAULT_CHANNELS = [
+  { id: 'general', name: 'general', type: 'text', categoryId: 'general', position: 0 },
+  { id: 'announcements', name: 'announcements', type: 'announcement', categoryId: 'general', position: 1 },
+  { id: 'general-voice', name: 'General', type: 'voice', categoryId: 'voice', position: 0 }
+];
+
+async function _hexChannelId(channelId, serverId) {
+  var input = (serverId || '') + ':' + channelId;
+  var buf = new TextEncoder().encode(input);
+  var hash = await crypto.subtle.digest('SHA-256', buf);
+  return Array.from(new Uint8Array(hash)).map(function(b) { return b.toString(16).padStart(2, '0'); }).join('');
+}
+
+var channelManager = {
+  isOwner: function() {
+    return state.nostrPubkey && state.currentServerId && state.nostrPubkey === state.currentServerId.split(':')[0];
+  },
+
+  loadChannels: function(serverId, onReady) {
+    var parts = serverId.split(':');
+    var ownerPubkey = parts[0];
+    var dTag = 'zellous-channels:' + serverId;
+    nostrNet.subscribe(
+      'channels-' + serverId,
+      [{ kinds: [30078], authors: [ownerPubkey], '#d': [dTag] }],
+      function(event) {
+        var hasTag = event.tags && event.tags.some(function(t) { return t[0] === 'd' && t[1] === dTag; });
+        if (!hasTag) return;
+        try {
+          var data = JSON.parse(event.content);
+          state.channels = data.channels || [];
+          state.categories = data.categories || [];
+          ui.render.all();
+        } catch (e) { console.warn('[nostr-channels] parse error:', e.message); }
+      },
+      function() {
+        if (!state.channels.length) channelManager._setDefaults();
+        if (onReady) onReady();
+      }
+    );
+  },
+
+  _setDefaults: function() {
+    state.channels = DEFAULT_CHANNELS.map(function(c) { return Object.assign({}, c); });
+    state.categories = DEFAULT_CATEGORIES.map(function(c) { return Object.assign({}, c); });
+    ui.render.all();
+    if (channelManager.isOwner()) channelManager._publishChannelList().catch(function(e) { console.warn('[nostr-channels] publish defaults failed:', e.message); });
+  },
+
+  _publishChannelList: async function() {
+    if (!channelManager.isOwner()) return;
+    var serverId = state.currentServerId;
+    var template = {
+      kind: 30078,
+      created_at: Math.floor(Date.now() / 1000),
+      tags: [['d', 'zellous-channels:' + serverId]],
+      content: JSON.stringify({ channels: state.channels, categories: state.categories })
+    };
+    var signed = await auth.sign(template);
+    await nostrNet.publish(signed);
+  },
+
+  create: async function(name, type, categoryId) {
+    var id = 'ch-' + Date.now();
+    state.channels = state.channels.concat([{
+      id: id, name: name, type: type || 'text',
+      categoryId: categoryId || 'general', position: state.channels.length
+    }]);
+    await channelManager._publishChannelList();
+    ui.render.all();
+  },
+
+  rename: async function(id, name) {
+    state.channels = state.channels.map(function(c) {
+      return c.id === id ? Object.assign({}, c, { name: name }) : c;
+    });
+    await channelManager._publishChannelList();
+    ui.render.all();
+  },
+
+  remove: async function(id) {
+    state.channels = state.channels.filter(function(c) { return c.id !== id; });
+    await channelManager._publishChannelList();
+    ui.render.all();
+  },
+
+  createCategory: async function(name) {
+    var id = 'cat-' + Date.now();
+    state.categories = state.categories.concat([{ id: id, name: name, position: state.categories.length }]);
+    await channelManager._publishChannelList();
+    ui.render.all();
+  },
+
+  renameCategory: async function(id, name) {
+    state.categories = state.categories.map(function(c) {
+      return c.id === id ? Object.assign({}, c, { name: name }) : c;
+    });
+    await channelManager._publishChannelList();
+    ui.render.all();
+  },
+
+  deleteCategory: async function(id) {
+    state.categories = state.categories.filter(function(c) { return c.id !== id; });
+    state.channels = state.channels.map(function(c) {
+      return c.categoryId === id ? Object.assign({}, c, { categoryId: null }) : c;
+    });
+    await channelManager._publishChannelList();
+    ui.render.all();
+  },
+
+  reorderChannels: async function(catId, ids) {
+    ids.forEach(function(chId, idx) {
+      state.channels = state.channels.map(function(c) {
+        return c.id === chId ? Object.assign({}, c, { position: idx, categoryId: catId }) : c;
+      });
+    });
+    await channelManager._publishChannelList();
+    ui.render.all();
+  },
+
+  reorderCategories: async function(ids) {
+    ids.forEach(function(catId, idx) {
+      state.categories = state.categories.map(function(c) {
+        return c.id === catId ? Object.assign({}, c, { position: idx }) : c;
+      });
+    });
+    await channelManager._publishChannelList();
+    ui.render.all();
+  },
+
+  hideContextMenu: function() {
+    var m = document.getElementById('channelContextMenu');
+    if (m) m.remove();
+    var cm = document.getElementById('categoryContextMenu');
+    if (cm) cm.remove();
+  }
+};
+
+window.__zellous.channels = channelManager;
+window.channelManager = channelManager;

package/src/legacy/nostr-chat.js

@@ -0,0 +1,185 @@
+const profiles = new Map();
+const fetching = new Set();
+
+const chat = {
+  activeChannelId: null,
+
+  get messages() { return state.chatMessages || []; },
+  set messages(v) { state.chatMessages = v; },
+
+  async send(content) {
+    if (!auth.isLoggedIn() || !state.currentChannelId) return;
+    const trimmed = content.trim();
+    if (!trimmed) return;
+    const chanHex = await _hexChannelId(state.currentChannelId, state.currentServerId);
+    const relayHint = (state.nostrRelays || [])[0] || '';
+    const template = {
+      kind: 42,
+      created_at: Math.floor(Date.now() / 1000),
+      tags: [['e', chanHex, relayHint, 'root']],
+      content: trimmed,
+    };
+    const signedEvent = await auth.sign(template);
+    nostrNet.publish(signedEvent);
+    chat._addMessage(chat._eventToMsg(signedEvent));
+  },
+
+  sendImage(file) {
+    if (!file) {
+      var input = document.createElement('input');
+      input.type = 'file'; input.accept = 'image/*,video/*';
+      input.onchange = function() { if (input.files[0]) nostrMedia.sendMedia(input.files[0]).catch(function(e){ message.add('Upload failed: ' + e.message); }); };
+      input.click(); return;
+    }
+    nostrMedia.sendMedia(file).catch(function(e){ message.add('Upload failed: ' + e.message); });
+  },
+
+  async loadHistory(channelId) {
+    if (chat.activeChannelId) {
+      nostrNet.unsubscribe('chat-' + chat.activeChannelId);
+      nostrNet.unsubscribe('chat-live-' + chat.activeChannelId);
+    }
+    chat.activeChannelId = channelId;
+    state.chatMessages = [];
+    const chanHex = await _hexChannelId(channelId, state.currentServerId);
+    const collected = [];
+    nostrNet.subscribe(
+      'chat-' + channelId,
+      [{ kinds: [42], '#e': [chanHex], limit: 50 }],
+      function(event) { collected.push(chat._eventToMsg(event)); },
+      function() {
+        collected.sort(function(a, b) { return a.timestamp - b.timestamp; });
+        state.chatMessages = collected;
+        chat._updateMembers(collected);
+        ui.render.all();
+      }
+    );
+    nostrNet.subscribe(
+      'chat-live-' + channelId,
+      [{ kinds: [42], '#e': [chanHex], since: Math.floor(Date.now() / 1000) }],
+      function(event) { chat._addMessage(chat._eventToMsg(event)); },
+      function() {}
+    );
+  },
+
+  async sendAnnouncement(text) {
+    if (!auth.isLoggedIn() || !state.currentChannelId) return;
+    if (!window.serverRoles || !serverRoles.isAdmin(state.currentServerId)) return;
+    const trimmed = text.trim();
+    if (!trimmed) return;
+    const chanHex = await _hexChannelId(state.currentChannelId, state.currentServerId);
+    const relayHint = (state.nostrRelays || [])[0] || '';
+    const template = {
+      kind: 42,
+      created_at: Math.floor(Date.now() / 1000),
+      tags: [['e', chanHex, relayHint, 'root'], ['t', 'announcement']],
+      content: trimmed,
+    };
+    const signedEvent = await auth.sign(template);
+    nostrNet.publish(signedEvent);
+    chat._addMessage(chat._eventToMsg(signedEvent));
+  },
+
+  _eventToMsg(event) {
+    const tTags = (event.tags || []).filter(t => t[0] === 't').map(t => t[1]);
+    chat._fetchProfile(event.pubkey);
+    return {
+      id: event.id,
+      type: 'text',
+      userId: event.pubkey,
+      content: event.content,
+      timestamp: event.created_at * 1000,
+      tags: tTags,
+    };
+  },
+
+  _addMessage(msg) {
+    if (state.chatMessages && state.chatMessages.find(function(m) { return m.id === msg.id; })) return;
+    const current = state.chatMessages ? state.chatMessages.slice() : [];
+    current.push(msg);
+    state.chatMessages = current;
+    chat._updateMembers(current);
+    ui.render.all();
+  },
+
+  _updateMembers(msgs) {
+    const seen = new Map();
+    (msgs || []).forEach(function(m) {
+      if (m.userId && !seen.has(m.userId)) seen.set(m.userId, chat.resolveProfile(m.userId));
+    });
+    state.roomMembers = Array.from(seen.entries()).map(function([id, username]) {
+      return { id, username, online: true };
+    });
+  },
+
+  async deleteMessage(id) {
+    const template = {
+      kind: 5,
+      created_at: Math.floor(Date.now() / 1000),
+      tags: [['e', id]],
+      content: 'deleted',
+    };
+    const signedEvent = await auth.sign(template);
+    nostrNet.publish(signedEvent);
+    state.chatMessages = (state.chatMessages || []).filter(function(m) { return m.id !== id; });
+    ui.render.all();
+  },
+
+  editMessage() {
+    if (typeof ui !== 'undefined' && ui.showToast) ui.showToast('Nostr messages cannot be edited');
+    else console.warn('Nostr messages cannot be edited');
+  },
+
+  resolveProfile(pubkey) {
+    if (profiles.has(pubkey)) {
+      const p = profiles.get(pubkey);
+      return p.name || auth.npubShort(pubkey);
+    }
+    chat._fetchProfile(pubkey);
+    return auth.npubShort(pubkey);
+  },
+
+  _fetchProfile(pubkey) {
+    if (fetching.has(pubkey)) return;
+    fetching.add(pubkey);
+    nostrNet.subscribe(
+      'profile-' + pubkey,
+      [{ kinds: [0], authors: [pubkey], limit: 1 }],
+      function(event) {
+        try {
+          const p = JSON.parse(event.content);
+          profiles.set(pubkey, p);
+          if (pubkey === state.nostrPubkey) state.nostrProfile = p;
+        } catch (e) {}
+      },
+      function() {
+        nostrNet.unsubscribe('profile-' + pubkey);
+        fetching.delete(pubkey);
+        chat._updateMembers(state.chatMessages);
+        ui.render.all();
+      }
+    );
+  },
+
+  linkify(html) {
+    return html.replace(/https?:\/\/[^\s<>"]+/g, function(url) {
+      if (!window.nostrMedia) return '<a href="' + url + '" target="_blank" rel="noopener">' + url + '</a>';
+      var kind = nostrMedia.isMedia(url);
+      if (kind === 'image') return '<a href="' + url + '" target="_blank" rel="noopener"><img src="' + url + '" style="max-width:100%;max-height:300px;border-radius:8px;margin-top:4px;display:block" loading="lazy"></a>';
+      if (kind === 'video') return '<video src="' + url + '" controls style="max-width:100%;max-height:300px;border-radius:8px;margin-top:4px;display:block"></video>';
+      return '<a href="' + url + '" target="_blank" rel="noopener">' + url + '</a>';
+    });
+  },
+
+  handleTextMessage(msg) { chat._addMessage(msg); },
+  handleImageMessage() {},
+  handleFileShared() {},
+
+  updateProfile(pubkey, profile) {
+    profiles.set(pubkey, profile);
+    ui.render.all();
+  },
+};
+
+window.__zellous.chat = chat;
+window.chat = chat;

package/src/legacy/nostr-fsm.js

@@ -0,0 +1,5 @@
+var voiceMachine = XState.createMachine({initial:'idle',states:{idle:{on:{connect:'connecting'}},connecting:{on:{connected:'connected',fail:'idle'}},connected:{on:{disconnect:'disconnecting'}},disconnecting:{on:{done:'idle'}}}});
+var peerMachine = XState.createMachine({initial:'new',states:{new:{on:{offer:'offering',recv_offer:'answering'}},offering:{on:{recv_answer:'connected',fail:'new',restart:'offering'}},answering:{on:{sent_answer:'connected',recv_answer:'connected',fail:'new'}},connected:{on:{disconnect:'reconnecting',close:'closed'}},reconnecting:{on:{offer:'offering',recv_answer:'connected',close:'closed'}},closed:{}}});
+var cameraMachine = XState.createMachine({initial:'idle',states:{idle:{on:{enable:'requesting'}},requesting:{on:{enabled:'active',denied:'idle'}},active:{on:{disable:'idle',error:'idle'}},error:{on:{enable:'requesting'}}}});
+window.__zellous.fsm = { voiceMachine: voiceMachine, peerMachine: peerMachine, cameraMachine: cameraMachine };
+window.nostrFsm = window.__zellous.fsm;

package/src/legacy/nostr-media.js

@@ -0,0 +1,97 @@
+var nostrMedia = {
+  _BLOSSOM_SERVERS: [
+    'https://blossom.nostr.build',
+    'https://files.sovbit.host',
+    'https://nostrcheck.me',
+  ],
+
+  async _hashFile(file) {
+    const buf = await file.arrayBuffer();
+    const hash = await crypto.subtle.digest('SHA-256', buf);
+    return Array.from(new Uint8Array(hash)).map(b => b.toString(16).padStart(2, '0')).join('');
+  },
+
+  async _generateBlossomAuth(file, uploadUrl) {
+    if (!state.nostrPubkey) throw new Error('Not authenticated');
+    const hash = await nostrMedia._hashFile(file);
+    const auth_event = {
+      kind: 24242,
+      created_at: Math.floor(Date.now() / 1000),
+      tags: [
+        ['t', 'upload'],
+        ['x', hash],
+        ['expiration', String(Math.floor(Date.now() / 1000) + 600)],
+      ],
+      content: 'Upload ' + file.name,
+    };
+    const signed = await window.auth.sign(auth_event);
+    return { header: 'Nostr ' + btoa(JSON.stringify(signed)), hash };
+  },
+
+  async _uploadBlossom(file, serverUrl) {
+    const uploadUrl = serverUrl + '/upload';
+    const { header, hash } = await nostrMedia._generateBlossomAuth(file, uploadUrl);
+    const res = await fetch(uploadUrl, {
+      method: 'PUT',
+      body: file,
+      headers: {
+        'Authorization': header,
+        'Content-Type': file.type || 'application/octet-stream',
+      }
+    });
+    if (!res.ok) throw new Error('Status ' + res.status);
+    const data = await res.json();
+    const url = data.url || (data.content && JSON.parse(data.content).url);
+    if (!url) throw new Error('No URL in response');
+    return url;
+  },
+
+  async upload(file) {
+    var errors = [];
+    for (var i = 0; i < nostrMedia._BLOSSOM_SERVERS.length; i++) {
+      try {
+        var url = await nostrMedia._uploadBlossom(file, nostrMedia._BLOSSOM_SERVERS[i]);
+        return { url: url, type: file.type, name: file.name, size: file.size };
+      } catch(e) { errors.push(nostrMedia._BLOSSOM_SERVERS[i] + ': ' + e.message); }
+    }
+    throw new Error('Upload failed: ' + errors.join('; '));
+  },
+
+  isMedia(url) {
+    if (!url || typeof url !== 'string') return null;
+    var imgRx = /\.(png|jpe?g|gif|webp|svg|avif)(\?|$)/i;
+    var vidRx = /\.(mp4|webm|mov|ogg)(\?|$)/i;
+    if (imgRx.test(url)) return 'image';
+    if (vidRx.test(url)) return 'video';
+    return null;
+  },
+
+  extractUrls(text) {
+    if (!text) return [];
+    var urlRx = /https?:\/\/[^\s<>"]+/g;
+    return (text.match(urlRx) || []);
+  },
+
+  async sendMedia(file) {
+    if (file.size > 20 * 1024 * 1024) throw new Error('File too large (max 20 MB)');
+    var result = await nostrMedia.upload(file);
+    var chanHex = await _hexChannelId(state.currentChannelId, state.currentServerId);
+    var relayHint = (state.nostrRelays || [])[0] || '';
+    var imetaTag = ['imeta', 'url ' + result.url, 'm ' + result.type];
+    if (result.size) imetaTag.push('size ' + result.size);
+    var template = {
+      kind: 42,
+      created_at: Math.floor(Date.now() / 1000),
+      tags: [['e', chanHex, relayHint, 'root'], imetaTag],
+      content: result.url
+    };
+    var signed = await auth.sign(template);
+    nostrNet.publish(signed);
+    chat._addMessage(chat._eventToMsg(signed));
+  }
+};
+
+window.__zellous.media = nostrMedia;
+window.nostrMedia = nostrMedia;
+if (!window.__debug) window.__debug = {};
+Object.defineProperty(window.__debug, 'media', { get: function() { return { servers: nostrMedia._NIP96_SERVERS }; }, configurable: true });

package/src/legacy/nostr-message.js

@@ -0,0 +1,12 @@
+var message = window.message || {
+  handlers: {},
+  handle: function(m) { var h = message.handlers[m.type]; if (h) h(m); },
+  add: function(text, audioData, userId, username) {
+    var id = Date.now() + Math.random();
+    var msgs = (state.messages || []).concat([{ id: id, text: text, time: Date.now(), userId: userId, username: username }]);
+    state.messages = msgs.length > 50 ? msgs.slice(-50) : msgs;
+    if (window.ui) ui.render.messages();
+  }
+};
+window.__zellous.message = message;
+window.message = message;

package/src/legacy/nostr-network.js

@@ -0,0 +1,182 @@
+var nostrNet = {
+  relays: new Map(),
+  subs: new Map(),
+  pendingEvents: [],
+  seenIds: new Set(),
+
+  _makeRelayActor: function() {
+    var machine = XState.createMachine({initial:'connecting',states:{connecting:{on:{connected:'connected',fail:'error'}},connected:{on:{fail:'error',disconnect:'disconnected'}},disconnected:{on:{reconnect:'connecting'}},error:{on:{reconnect:'connecting'}}}});
+    var actor = XState.createActor(machine);
+    actor.start();
+    return actor;
+  },
+
+    connect: function() {
+    var relays = (state.nostrRelays || []);
+    for (var i = 0; i < relays.length; i++) nostrNet._openRelay(relays[i]);
+  },
+
+  disconnect: function() {
+    nostrNet.relays.forEach(function(relay) {
+      if (relay.ws) { relay.ws.onclose = null; relay.ws.onerror = null; relay.ws.close(); }
+    });
+    nostrNet.relays.clear();
+  },
+
+  _openRelay: function(url) {
+    var existing = nostrNet.relays.get(url);
+    if (existing && existing.ws && (existing.ws.readyState === 0 || existing.ws.readyState === 1)) return;
+    var relay = existing || { ws: null, status: 'connecting', actor: null, reconnectDelay: 1000, failCount: 0, subIds: new Set(), latencyMs: null, _reqSentAt: null };
+    relay.status = 'connecting';
+    relay.latencyMs = null;
+    if(!relay.actor) relay.actor = nostrNet._makeRelayActor();
+    else relay.actor.send({type:'reconnect'});
+    nostrNet.relays.set(url, relay);
+    var ws;
+    try { ws = new WebSocket(url); } catch (e) {
+      relay.status = 'error'; relay.actor.send({type:'fail'}); nostrNet._updateRelayStatus(url, 'error');
+      if (window.ui) ui.render.all(); return;
+    }
+    relay.ws = ws;
+    ws.onopen = function() {
+      relay.status = 'connected'; relay.actor.send({type:'connected'}); relay._openedAt = Date.now();
+      nostrNet._updateRelayStatus(url, 'connected');
+      var wasConnected = state.isConnected; state.isConnected = true;
+      if (!wasConnected && window.ui) ui.render.all();
+      nostrNet.subs.forEach(function(sub, subId) {
+        var req = ['REQ', subId].concat(sub.filters);
+        ws.send(JSON.stringify(req)); relay.subIds.add(subId);
+        if (!relay._reqSentAt) relay._reqSentAt = Date.now();
+      });
+      nostrNet._drainPending();
+    };
+    ws.onmessage = function(e) {
+      if (relay._reqSentAt && relay.latencyMs === null) {
+        relay.latencyMs = Date.now() - relay._reqSentAt; relay._reqSentAt = null;
+        nostrNet._updateRelayStatus(url, 'connected');
+      }
+      try { nostrNet._handleMessage(url, e.data); } catch (_) {}
+    };
+    ws.onerror = function() {
+      relay.status = 'error'; nostrNet._updateRelayStatus(url, 'error');
+      if (window.ui) ui.render.all();
+    };
+    ws.onclose = function() {
+      relay.status = 'closed'; relay.actor.send({type:'fail'}); nostrNet._updateRelayStatus(url, 'error');
+      var anyOpen = false;
+      nostrNet.relays.forEach(function(r) { if (r.ws && r.ws.readyState === 1) anyOpen = true; });
+      if (!anyOpen) state.isConnected = false;
+      if (window.ui) ui.render.all();
+      var sustained = relay._openedAt && (Date.now() - relay._openedAt) > 5000;
+      if (sustained) { relay.failCount = 0; relay.reconnectDelay = 1000; }
+      else { relay.failCount = (relay.failCount || 0) + 1; relay.reconnectDelay = Math.min(relay.reconnectDelay * 2, 30000); }
+      relay._openedAt = null;
+      nostrNet._reconnect(url, relay.reconnectDelay);
+    };
+  },
+
+  _reconnect: function(url, delay) {
+    setTimeout(function() {
+      var relay = nostrNet.relays.get(url); if (!relay) return;
+      relay.status = 'connecting'; nostrNet._openRelay(url);
+    }, delay || 1000);
+  },
+
+  _handleMessage: function(url, rawData) {
+    var msg = JSON.parse(rawData);
+    if (!Array.isArray(msg) || msg.length < 2) return;
+    var type = msg[0], subId = msg[1], sub;
+    if (type === 'EVENT') {
+      var event = msg[2]; if (!event || !event.id) return;
+      if (event.created_at > Math.floor(Date.now() / 1000) + 300) return;
+      if (nostrNet.seenIds.has(event.id)) return;
+      var valid = true;
+      if (window.NostrTools && NostrTools.verifyEvent) {
+        try { valid = NostrTools.verifyEvent(event); } catch (_) { valid = false; }
+      }
+      if (!valid) return;
+      nostrNet.seenIds.add(event.id); nostrNet._trimSeenIds();
+      sub = nostrNet.subs.get(subId);
+      if (sub && sub.onEvent) sub.onEvent(event);
+    } else if (type === 'EOSE') {
+      sub = nostrNet.subs.get(subId); if (sub && sub.onEose) sub.onEose();
+    } else if (type === 'NOTICE') {
+      console.warn('[nostr relay notice]', msg[1]);
+    } else if (type === 'OK' && !msg[2]) {
+      console.error('[nostr relay rejected event]', msg[1], msg[3] || '');
+    }
+  },
+
+  _normSubId: function(subId) { return subId.length > 64 ? subId.slice(0, 64) : subId; },
+
+  subscribe: function(subId, filters, onEvent, onEose) {
+    subId = nostrNet._normSubId(subId);
+    nostrNet.subs.set(subId, { filters: filters, onEvent: onEvent, onEose: onEose, relays: new Set() });
+    nostrNet.relays.forEach(function(relay, url) {
+      if (relay.ws && relay.ws.readyState === 1) {
+        var req = ['REQ', subId].concat(filters); relay.ws.send(JSON.stringify(req));
+        relay.subIds.add(subId); nostrNet.subs.get(subId).relays.add(url);
+        if (!relay._reqSentAt) relay._reqSentAt = Date.now();
+      }
+    });
+    return subId;
+  },
+
+  unsubscribe: function(subId) {
+    subId = nostrNet._normSubId(subId);
+    nostrNet.relays.forEach(function(relay) {
+      if (relay.ws && relay.ws.readyState === 1 && relay.subIds.has(subId)) {
+        relay.ws.send(JSON.stringify(['CLOSE', subId])); relay.subIds.delete(subId);
+      }
+    });
+    nostrNet.subs.delete(subId);
+  },
+
+  publish: function(event) {
+    var sent = false;
+    nostrNet.relays.forEach(function(relay) {
+      if (relay.ws && relay.ws.readyState === 1) { relay.ws.send(JSON.stringify(['EVENT', event])); sent = true; }
+    });
+    if (!sent) nostrNet.pendingEvents.push(event);
+  },
+
+  _drainPending: function() {
+    var pending = nostrNet.pendingEvents.splice(0);
+    for (var i = 0; i < pending.length; i++) nostrNet.publish(pending[i]);
+  },
+
+  isConnected: function() {
+    var open = false;
+    nostrNet.relays.forEach(function(r) { if (r.ws && r.ws.readyState === 1) open = true; });
+    return open;
+  },
+
+  _updateRelayStatus: function(url, status) {
+    var m = new Map(state.nostrRelayStatus || []); m.set(url, status); state.nostrRelayStatus = m;
+  },
+
+  _trimSeenIds: function() {
+    if (nostrNet.seenIds.size > 10000) {
+      var arr = Array.from(nostrNet.seenIds); nostrNet.seenIds = new Set(arr.slice(arr.length - 5000));
+    }
+  }
+};
+window.__zellous.net = nostrNet;
+window.network = nostrNet;
+window.nostrNet = nostrNet;
+
+function _healRelays() {
+  nostrNet.relays.forEach(function(relay, url) {
+    if (!relay.ws || relay.ws.readyState === 2 || relay.ws.readyState === 3) nostrNet._openRelay(url);
+  });
+}
+window.addEventListener('online', function() {
+  nostrNet.relays.forEach(function(relay) { relay.reconnectDelay = 1000; });
+  _healRelays();
+});
+document.addEventListener('visibilitychange', function() {
+  if (document.visibilityState === 'visible') _healRelays();
+});
+window.__debugNet = { get relays() {
+  var out = []; nostrNet.relays.forEach(function(r, url) { out.push({url: url, status: r.status, actorState: r.actor ? r.actor.getSnapshot().value : null, latencyMs: r.latencyMs}); }); return out;
+}};