wireweave 0.1.1

package/src/legacy/nostr-pages.js

@@ -0,0 +1,152 @@
+var serverPages = {
+  _store: new Map(),
+  _subs: new Map(),
+
+  _sanitize(html) {
+    const el = document.createElement('div');
+    el.innerHTML = html;
+    el.querySelectorAll('script,iframe,object,embed,form,input,button').forEach(n => n.remove());
+    el.querySelectorAll('*').forEach(n => {
+      [...n.attributes].forEach(a => {
+        if (/^on/i.test(a.name) || (a.name === 'href' && /^javascript:/i.test(a.value)) || (a.name === 'src' && /^javascript:/i.test(a.value))) n.removeAttribute(a.name);
+      });
+    });
+    return el.innerHTML;
+  },
+
+  _pageKey(serverId, slug) { return 'zellous-page:' + serverId + ':' + slug; },
+
+  getPages(serverId) { return Array.from((serverPages._store.get(serverId) || new Map()).values()); },
+
+  subscribe(serverId) {
+    if (serverPages._subs.has(serverId)) return;
+    var creator = serverId ? serverId.split(':')[0] : null;
+    if (!creator) return;
+    var subId = 'pages-' + serverId;
+    serverPages._subs.set(serverId, subId);
+    nostrNet.subscribe(subId,
+      [{ kinds: [30078], authors: [creator] }],
+      function(event) {
+        if (event.pubkey !== creator) return;
+        var dTag = (event.tags.find(function(t) { return t[0] === 'd'; }) || [])[1] || '';
+        var prefix = 'zellous-page:' + serverId + ':';
+        if (!dTag.startsWith(prefix)) return;
+        var slug = dTag.slice(prefix.length);
+        if (!slug) return;
+        try {
+          var data = JSON.parse(event.content);
+          var pages = serverPages._store.get(serverId) || new Map();
+          if (data.deleted) { pages.delete(slug); } else {
+            pages.set(slug, { slug: slug, title: data.title || slug, html: serverPages._sanitize(data.html || ''), updatedAt: event.created_at });
+          }
+          serverPages._store.set(serverId, pages);
+          if (window.uiChannels) uiChannels.render();
+        } catch(e) {}
+      },
+      function() {}
+    );
+  },
+
+  unsubscribe(serverId) {
+    var subId = serverPages._subs.get(serverId);
+    if (subId) { nostrNet.unsubscribe(subId); serverPages._subs.delete(serverId); }
+  },
+
+  async publish(serverId, slug, title, html) {
+    if (!serverRoles.isAdmin(serverId)) throw new Error('Admin only');
+    var safe = serverPages._sanitize(html);
+    var dTag = serverPages._pageKey(serverId, slug);
+    var signed = await auth.sign({ kind: 30078, created_at: Math.floor(Date.now() / 1000), tags: [['d', dTag]], content: JSON.stringify({ title: title, html: safe }) });
+    await nostrNet.publish(signed);
+    var pages = serverPages._store.get(serverId) || new Map();
+    pages.set(slug, { slug: slug, title: title, html: safe, updatedAt: Math.floor(Date.now() / 1000) });
+    serverPages._store.set(serverId, pages);
+    if (window.uiChannels) uiChannels.render();
+  },
+
+  async deletePage(serverId, slug) {
+    if (!serverRoles.isAdmin(serverId)) throw new Error('Admin only');
+    var dTag = serverPages._pageKey(serverId, slug);
+    var signed = await auth.sign({ kind: 30078, created_at: Math.floor(Date.now() / 1000), tags: [['d', dTag]], content: JSON.stringify({ deleted: true }) });
+    await nostrNet.publish(signed);
+    var pages = serverPages._store.get(serverId) || new Map();
+    pages.delete(slug);
+    serverPages._store.set(serverId, pages);
+    if (window.uiChannels) uiChannels.render();
+  },
+
+  showEditModal(serverId, existing) {
+    document.getElementById('pageEditModal')?.remove();
+    var modal = document.createElement('div');
+    modal.id = 'pageEditModal';
+    modal.className = 'modal-overlay';
+    modal.style.display = 'flex';
+    var slug = existing ? existing.slug : 'page-' + Date.now().toString(36);
+    modal.innerHTML = '<div class="modal" style="max-width:680px;width:95%">' +
+      '<div class="modal-header"><span class="modal-title">' + (existing ? 'Edit Page' : 'New Page') + '</span>' +
+      '<button class="modal-close" id="pageModalClose">&times;</button></div>' +
+      '<div class="modal-body" style="display:flex;flex-direction:column;gap:12px">' +
+      '<input id="pageModalTitle" class="modal-input" placeholder="Page title" value="' + escHtml(existing ? existing.title : '') + '">' +
+      '<div id="pageModalEditor" class="page-editor" contenteditable="true" style="min-height:220px;background:var(--bg-raised);border:1px solid var(--border);border-radius:6px;padding:12px;overflow-y:auto;font-size:14px;line-height:1.6"></div>' +
+      '<div class="page-editor-toolbar" style="display:flex;gap:6px;flex-wrap:wrap">' +
+      '<button class="page-tb-btn" data-cmd="bold"><b>B</b></button>' +
+      '<button class="page-tb-btn" data-cmd="italic"><i>I</i></button>' +
+      '<button class="page-tb-btn" data-cmd="underline"><u>U</u></button>' +
+      '<button class="page-tb-btn" data-cmd="insertUnorderedList">&#8226;</button>' +
+      '<button class="page-tb-btn" data-cmd="insertOrderedList">1.</button>' +
+      '</div>' +
+      '</div>' +
+      '<div class="modal-footer">' +
+      (existing ? '<button class="modal-btn danger" id="pageModalDelete">Delete</button>' : '') +
+      '<button class="modal-btn secondary" id="pageModalCancel">Cancel</button>' +
+      '<button class="modal-btn primary" id="pageModalSave">Save</button>' +
+      '</div></div>';
+    document.body.appendChild(modal);
+    var editor = document.getElementById('pageModalEditor');
+    if (existing) editor.innerHTML = existing.html;
+    modal.querySelectorAll('.page-tb-btn').forEach(function(btn) {
+      btn.addEventListener('mousedown', function(e) { e.preventDefault(); document.execCommand(btn.dataset.cmd, false, null); editor.focus(); });
+    });
+    document.getElementById('pageModalClose').addEventListener('click', function() { modal.remove(); });
+    document.getElementById('pageModalCancel').addEventListener('click', function() { modal.remove(); });
+    if (existing) {
+      document.getElementById('pageModalDelete').addEventListener('click', async function() {
+        if (!confirm('Delete this page?')) return;
+        try { await serverPages.deletePage(serverId, slug); modal.remove(); } catch(e) { alert(e.message); }
+      });
+    }
+    document.getElementById('pageModalSave').addEventListener('click', async function() {
+      var title = document.getElementById('pageModalTitle').value.trim();
+      if (!title) { alert('Title required'); return; }
+      try { await serverPages.publish(serverId, slug, title, editor.innerHTML); modal.remove(); } catch(e) { alert(e.message); }
+    });
+    modal.addEventListener('click', function(e) { if (e.target === modal) modal.remove(); });
+  },
+
+  renderPageView(serverId, slug) {
+    var pages = serverPages._store.get(serverId) || new Map();
+    var page = pages.get(slug);
+    var area = document.getElementById('pageView');
+    if (!area) return;
+    var isAdmin = window.serverRoles && serverRoles.isAdmin(serverId);
+    area.innerHTML = '<div class="page-view-header">' +
+      '<span class="page-view-title">' + escHtml(page ? page.title : slug) + '</span>' +
+      (isAdmin ? '<button class="modal-btn secondary page-edit-btn" id="pageEditBtn">Edit</button>' : '') +
+      '</div>' +
+      '<div class="page-view-body">' + (page ? page.html : '<p style="color:var(--text-muted)">No content yet.</p>') + '</div>';
+    if (isAdmin) {
+      document.getElementById('pageEditBtn').addEventListener('click', function() {
+        serverPages.showEditModal(serverId, page || { slug: slug, title: slug, html: '' });
+      });
+    }
+  }
+};
+
+window.__zellous.pages = serverPages;
+window.serverPages = serverPages;
+if (!window.__debug) window.__debug = {};
+Object.defineProperty(window.__debug, 'pages', { get: function() {
+  var out = {};
+  serverPages._store.forEach(function(pages, srv) { out[srv] = Array.from(pages.keys()); });
+  return out;
+}, configurable: true });

package/src/legacy/nostr-roles.js

@@ -0,0 +1,74 @@
+var serverRoles = {
+  _store: new Map(),
+  _sub: null,
+
+  _creatorOf(serverId) {
+    return serverId ? serverId.split(':')[0] : null;
+  },
+
+  isOwner(serverId) {
+    return !!state.nostrPubkey && serverRoles._creatorOf(serverId) === state.nostrPubkey;
+  },
+
+  isAdmin(serverId) {
+    if (serverRoles.isOwner(serverId)) return true;
+    var roles = serverRoles._store.get(serverId) || {};
+    return !!(roles.admins || []).includes(state.nostrPubkey);
+  },
+
+  isMod(serverId) {
+    if (serverRoles.isAdmin(serverId)) return true;
+    var roles = serverRoles._store.get(serverId) || {};
+    return !!(roles.mods || []).includes(state.nostrPubkey);
+  },
+
+  getRole(serverId, pubkey) {
+    var creator = serverRoles._creatorOf(serverId);
+    if (pubkey === creator) return 'owner';
+    var roles = serverRoles._store.get(serverId) || {};
+    if ((roles.admins || []).includes(pubkey)) return 'admin';
+    if ((roles.mods || []).includes(pubkey)) return 'moderator';
+    return 'member';
+  },
+
+  async setRole(serverId, targetPubkey, role) {
+    if (!serverRoles.isOwner(serverId) && role === 'admin') throw new Error('Only owner can assign admin');
+    if (!serverRoles.isAdmin(serverId)) throw new Error('Insufficient permissions');
+    var existing = serverRoles._store.get(serverId) || { admins: [], mods: [] };
+    var admins = (existing.admins || []).filter(function(p) { return p !== targetPubkey; });
+    var mods = (existing.mods || []).filter(function(p) { return p !== targetPubkey; });
+    if (role === 'admin') admins = admins.concat([targetPubkey]);
+    else if (role === 'moderator') mods = mods.concat([targetPubkey]);
+    var next = { admins: admins, mods: mods };
+    serverRoles._store.set(serverId, next);
+    var dTag = 'zellous-roles:' + serverId;
+    var signed = await auth.sign({ kind: 30078, created_at: Math.floor(Date.now() / 1000), tags: [['d', dTag]], content: JSON.stringify(next) });
+    await nostrNet.publish(signed);
+  },
+
+  subscribe(serverId) {
+    if (serverRoles._sub) { nostrNet.unsubscribe(serverRoles._sub); serverRoles._sub = null; }
+    if (!serverId) return;
+    var creator = serverRoles._creatorOf(serverId);
+    if (!creator) return;
+    var dTag = 'zellous-roles:' + serverId;
+    serverRoles._sub = 'roles-' + serverId;
+    nostrNet.subscribe(serverRoles._sub,
+      [{ kinds: [30078], authors: [creator], '#d': [dTag] }],
+      function(event) {
+        if (event.pubkey !== creator) return;
+        try {
+          var data = JSON.parse(event.content);
+          serverRoles._store.set(serverId, { admins: data.admins || [], mods: data.mods || [] });
+          if (window.uiMembers) uiMembers.render();
+        } catch(e) {}
+      },
+      function() {}
+    );
+  }
+};
+
+window.__zellous.roles = serverRoles;
+window.serverRoles = serverRoles;
+if (!window.__debug) window.__debug = {};
+Object.defineProperty(window.__debug, 'roles', { get: function() { return { store: Object.fromEntries(serverRoles._store), sub: serverRoles._sub }; }, configurable: true });

package/src/legacy/nostr-servers.js

@@ -0,0 +1,223 @@
+var serverManager = {
+  loadServers: function() {
+    try {
+      var raw = localStorage.getItem('zn_servers');
+      state.servers = raw ? JSON.parse(raw) : [];
+    } catch (e) { state.servers = []; }
+
+    if (state.nostrPubkey) {
+      nostrNet.subscribe(
+        'my-servers',
+        [{ kinds: [34550], authors: [state.nostrPubkey] }],
+        function(event) { serverManager._handleServerEvent(event); },
+        function() {}
+      );
+    }
+
+    try {
+      var joined = localStorage.getItem('zn_joined_servers');
+      var joinedIds = joined ? JSON.parse(joined) : [];
+      joinedIds.forEach(function(sid) {
+        if (!state.servers.find(function(s) { return s.id === sid; })) {
+          state.servers = state.servers.concat([{ id: sid, name: sid.slice(0, 8), iconColor: '#5865F2' }]);
+        }
+      });
+      // Subscribe to relay to fetch real names for joined (non-owned) servers
+      var unresolved = joinedIds.filter(function(sid) {
+        // Format: pubkey:dTag — only subscribe if not already owned by us
+        var parts = sid.split(':');
+        return parts.length === 2 && parts[0] !== state.nostrPubkey;
+      });
+      if (unresolved.length) {
+        // Group by author to minimise subscriptions
+        var byAuthor = {};
+        unresolved.forEach(function(sid) {
+          var parts = sid.split(':');
+          var author = parts[0], dTag = parts[1];
+          if (!byAuthor[author]) byAuthor[author] = [];
+          byAuthor[author].push(dTag);
+        });
+        Object.keys(byAuthor).forEach(function(author) {
+          var dTags = byAuthor[author];
+          nostrNet.subscribe(
+            'joined-server-' + author.slice(0, 8),
+            [{ kinds: [34550], authors: [author], '#d': dTags }],
+            function(event) { serverManager._handleServerEvent(event); },
+            function() {}
+          );
+        });
+      }
+    } catch (e) {}
+  },
+
+  _handleServerEvent: function(event) {
+    var nameTag = event.tags.find(function(t) { return t[0] === 'name'; });
+    var colorTag = event.tags.find(function(t) { return t[0] === 'color'; });
+    var dTag = event.tags.find(function(t) { return t[0] === 'd'; });
+    if (!dTag) return;
+    var serverId = event.pubkey + ':' + dTag[1];
+    var name = nameTag ? nameTag[1] : serverId.slice(0, 8);
+    var iconColor = colorTag ? colorTag[1] : '#5865F2';
+    var existing = state.servers.find(function(s) { return s.id === serverId; });
+    if (existing) {
+      existing.name = name; existing.iconColor = iconColor; existing.ownerId = event.pubkey;
+      state.servers = state.servers.slice();
+    } else {
+      state.servers = state.servers.concat([{ id: serverId, name: name, iconColor: iconColor, ownerId: event.pubkey }]);
+    }
+    serverManager._persistServers();
+    ui.render.all();
+  },
+
+  create: async function(name, iconColor) {
+    var dTag = Math.random().toString(36).slice(2, 10);
+    var serverId = state.nostrPubkey + ':' + dTag;
+    var template = { kind: 34550, created_at: Math.floor(Date.now() / 1000), tags: [['d', dTag], ['name', name], ['color', iconColor || '#5865F2']], content: '' };
+    var signed = await auth.sign(template);
+    await nostrNet.publish(signed);
+    var server = { id: serverId, name: name, iconColor: iconColor || '#5865F2', ownerId: state.nostrPubkey };
+    state.servers = state.servers.concat([server]);
+    serverManager._persistServers();
+    serverManager.switchTo(serverId);
+  },
+
+  join: async function(serverId) {
+    try {
+      var joined = JSON.parse(localStorage.getItem('zn_joined_servers') || '[]');
+      if (!joined.includes(serverId)) { joined.push(serverId); localStorage.setItem('zn_joined_servers', JSON.stringify(joined)); }
+    } catch (e) {}
+    if (!state.servers.find(function(s) { return s.id === serverId; })) {
+      state.servers = state.servers.concat([{ id: serverId, name: serverId.slice(0, 8), iconColor: '#5865F2' }]);
+      serverManager._persistServers();
+    }
+    serverManager.switchTo(serverId);
+  },
+
+  delete: async function(serverId) {
+    state.servers = (state.servers || []).filter(function(s) { return s.id !== serverId; });
+    serverManager._persistServers();
+    try {
+      var joined = JSON.parse(localStorage.getItem('zn_joined_servers') || '[]');
+      localStorage.setItem('zn_joined_servers', JSON.stringify(joined.filter(function(id) { return id !== serverId; })));
+    } catch (e) {}
+    if (state.currentServerId === serverId) serverManager.switchTo(null);
+    else ui.render.all();
+  },
+
+  leave: function(serverId) { serverManager.delete(serverId); },
+  switchTo: async function(serverId) {
+    state.currentServerId = serverId;
+    state.chatMessages = []; state.channels = []; state.categories = [];
+    if (window.serverRoles) serverRoles.subscribe(serverId);
+    if (window.serverSettings) serverSettings.subscribe(serverId);
+    if (window.serverPages) serverPages.subscribe(serverId);
+    if (serverId) localStorage.setItem('zn_lastServer', serverId);
+    else localStorage.removeItem('zn_lastServer');
+    if (window.channelManager && serverId) {
+      await new Promise(function(resolve) {
+        var done = false;
+        var finish = function() { if (done) return; done = true; if (!(state.channels || []).length) channelManager._setDefaults(); resolve(); };
+        channelManager.loadChannels(serverId, finish);
+        setTimeout(finish, 3000);
+      });
+    }
+    var firstText = (state.channels || []).find(function(c) { return c.type === 'text'; });
+    if (firstText && state.currentChannelId !== firstText.id) {
+      state.currentChannelId = firstText.id; state.currentChannel = firstText;
+      if (window.chat) chat.loadHistory(firstText.id);
+    }
+    ui.render.all();
+  },
+  _persistServers: function() { localStorage.setItem('zn_servers', JSON.stringify(state.servers)); },
+  init: function() {
+    serverManager.loadServers();
+    var lastServer = localStorage.getItem('zn_lastServer');
+    if (lastServer && state.servers.find(function(s) { return s.id === lastServer; })) serverManager.switchTo(lastServer);
+    else if (state.servers.length) serverManager.switchTo(state.servers[0].id);
+  },
+
+  _getOrder: function() { try { return JSON.parse(localStorage.getItem('zn_serverOrder') || '[]'); } catch(e) { return []; } },
+  _saveOrder: function(ids) { localStorage.setItem('zn_serverOrder', JSON.stringify(ids)); },
+
+  _sortedServers: function() {
+    var srvs = state.servers || [];
+    var order = serverManager._getOrder();
+    if (!order.length) return srvs;
+    var indexed = {};
+    order.forEach(function(id, i) { indexed[id] = i; });
+    return srvs.slice().sort(function(a, b) {
+      var ai = indexed[a.id] !== undefined ? indexed[a.id] : Infinity;
+      var bi = indexed[b.id] !== undefined ? indexed[b.id] : Infinity;
+      return ai - bi;
+    });
+  },
+
+  renderList: function() {
+    var container = document.getElementById('serverIcons');
+    if (!container) return;
+    var srvs = serverManager._sortedServers();
+    var current = state.currentServerId;
+    var currentServer = current && srvs.find(function(s) { return s.id === current; });
+    var headerEl = document.getElementById('serverHeaderName');
+    if (headerEl) headerEl.textContent = currentServer ? currentServer.name : 'Zellous';
+    var colors = ['#5865f2', '#57f287', '#feb347', '#fe7168', '#9b59b6', '#1abc9c', '#e67e22', '#e74c3c'];
+    var html = '';
+    srvs.forEach(function(s) {
+      var active = s.id === current ? ' active' : '';
+      var color = s.iconColor || colors[s.name.length % colors.length];
+      var initial = (s.name || '?')[0].toUpperCase();
+      html += '<div class="server-icon' + active + '" draggable="true" data-server="' + s.id + '" title="' + s.name + '" style="background:' + (active ? '' : color) + '">' +
+        '<div class="server-pill"></div>' + initial + '</div>';
+    });
+    html += '<div class="server-separator" id="serverSeparator"></div>' +
+      '<div class="server-icon add-server" id="addServerBtn" title="Add a Server"><div class="server-pill"></div>+</div>';
+    container.innerHTML = html;
+    var homeIcon = document.getElementById('homeServer');
+    if (homeIcon) {
+      homeIcon.classList.toggle('active', !current);
+      homeIcon.addEventListener('click', function() { serverManager.switchTo(null); });
+    }
+    container.querySelectorAll('[data-server]').forEach(function(el) {
+      el.addEventListener('click', function() { serverManager.switchTo(el.dataset.server); });
+      el.addEventListener('contextmenu', function(e) { e.preventDefault(); serverManager.showContextMenu(el.dataset.server, e.clientX, e.clientY); });
+    });
+    var addBtn = document.getElementById('addServerBtn');
+    if (addBtn) addBtn.addEventListener('click', function() { serverManager.showCreateModal(); });
+    serverManager._initDragDrop(container);
+  },
+
+  _initDragDrop: function(container) {
+    var dragId = null;
+    container.addEventListener('dragstart', function(e) {
+      var el = e.target.closest('[data-server]');
+      if (!el) return;
+      dragId = el.dataset.server; e.dataTransfer.effectAllowed = 'move';
+      setTimeout(function() { el.classList.add('dragging'); }, 0);
+    });
+    container.addEventListener('dragend', function() {
+      container.querySelectorAll('.dragging').forEach(function(el) { el.classList.remove('dragging'); });
+      container.querySelectorAll('.drag-over').forEach(function(el) { el.classList.remove('drag-over'); });
+      dragId = null;
+    });
+    container.addEventListener('dragover', function(e) {
+      e.preventDefault(); e.dataTransfer.dropEffect = 'move';
+      var target = e.target.closest('[data-server]');
+      container.querySelectorAll('.drag-over').forEach(function(el) { el.classList.remove('drag-over'); });
+      if (target && target.dataset.server !== dragId) target.classList.add('drag-over');
+    });
+    container.addEventListener('drop', function(e) {
+      e.preventDefault();
+      var target = e.target.closest('[data-server]');
+      if (!target || !dragId || target.dataset.server === dragId) return;
+      var srvs = serverManager._sortedServers();
+      var ids = srvs.map(function(s) { return s.id; });
+      var fromIdx = ids.indexOf(dragId), toIdx = ids.indexOf(target.dataset.server);
+      if (fromIdx === -1 || toIdx === -1) return;
+      ids.splice(fromIdx, 1); ids.splice(toIdx, 0, dragId);
+      serverManager._saveOrder(ids); serverManager.renderList();
+    });
+  }
+};
+
+window.__zellous.servers = serverManager;
+window.serverManager = serverManager;

package/src/legacy/nostr-settings.js

@@ -0,0 +1,97 @@
+var serverSettings = {
+  _store: new Map(),
+  _sub: null,
+  _VALID_BITRATES: [8000, 16000, 24000, 48000, 96000],
+
+  _clampBitrate(v) {
+    return serverSettings._VALID_BITRATES.reduce(function(prev, cur) {
+      return Math.abs(cur - v) < Math.abs(prev - v) ? cur : prev;
+    });
+  },
+
+  getBitrate(serverId) {
+    var s = serverSettings._store.get(serverId);
+    return (s && s.opusBitrate) || 24000;
+  },
+
+  async setBitrate(serverId, bitrate) {
+    if (!serverRoles.isOwner(serverId) && !serverRoles.isAdmin(serverId)) throw new Error('Insufficient permissions');
+    var clamped = serverSettings._clampBitrate(Number(bitrate));
+    var existing = serverSettings._store.get(serverId) || {};
+    var next = Object.assign({}, existing, { opusBitrate: clamped });
+    serverSettings._store.set(serverId, next);
+    var dTag = 'zellous-settings:' + serverId;
+    var signed = await auth.sign({ kind: 30078, created_at: Math.floor(Date.now() / 1000), tags: [['d', dTag]], content: JSON.stringify(next) });
+    await nostrNet.publish(signed);
+    if (state.audioEncoder) {
+      try { state.audioEncoder.configure({ codec: 'opus', sampleRate: config.sampleRate, numberOfChannels: 1, bitrate: clamped }); } catch(e) {}
+    }
+    return clamped;
+  },
+
+  getEmbedAllowlist(serverId) {
+    var s = serverSettings._store.get(serverId);
+    return (s && s.embedAllowlist) ? (typeof s.embedAllowlist === 'string' ? s.embedAllowlist.split(',').map(function(d) { return d.trim(); }).filter(Boolean) : s.embedAllowlist) : [];
+  },
+
+  async setEmbedAllowlist(serverId, domainsStr) {
+    if (!serverRoles.isOwner(serverId) && !serverRoles.isAdmin(serverId)) throw new Error('Insufficient permissions');
+    var domains = domainsStr.split(',').map(function(d) { return d.trim(); }).filter(Boolean);
+    var existing = serverSettings._store.get(serverId) || {};
+    var next = Object.assign({}, existing, { embedAllowlist: domains });
+    serverSettings._store.set(serverId, next);
+    var dTag = 'zellous-settings:' + serverId;
+    var signed = await auth.sign({ kind: 30078, created_at: Math.floor(Date.now() / 1000), tags: [['d', dTag]], content: JSON.stringify(next) });
+    await nostrNet.publish(signed);
+    return domains;
+  },
+
+  isOriginAllowed(serverId, origin) {
+    if (!origin) return false;
+    var allowlist = serverSettings.getEmbedAllowlist(serverId);
+    if (allowlist.length === 0) return true;
+    var url = {};
+    try { url = new URL(origin); } catch(e) { return false; }
+    var hostname = url.hostname;
+    return allowlist.some(function(pattern) {
+      if (pattern === '*') return true;
+      if (pattern.startsWith('*.')) {
+        var suffix = pattern.slice(2);
+        return hostname === suffix || hostname.endsWith('.' + suffix);
+      }
+      return hostname === pattern || hostname === pattern.replace('https://', '').replace('http://', '');
+    });
+  },
+
+  subscribe(serverId) {
+    if (serverSettings._sub) { nostrNet.unsubscribe(serverSettings._sub); serverSettings._sub = null; }
+    if (!serverId) return;
+    var creator = serverId.split(':')[0];
+    if (!creator) return;
+    var dTag = 'zellous-settings:' + serverId;
+    serverSettings._sub = 'settings-' + serverId;
+    nostrNet.subscribe(serverSettings._sub,
+      [{ kinds: [30078], authors: [creator], '#d': [dTag] }],
+      function(event) {
+        if (event.pubkey !== creator) return;
+        try {
+          var data = JSON.parse(event.content);
+          serverSettings._store.set(serverId, data);
+        } catch(e) {}
+      },
+      function() {}
+    );
+  },
+
+  applyToEncoder() {
+    var bitrate = serverSettings.getBitrate(state.currentServerId);
+    if (state.audioEncoder) {
+      try { state.audioEncoder.configure({ codec: 'opus', sampleRate: config.sampleRate, numberOfChannels: 1, bitrate: bitrate }); } catch(e) {}
+    }
+  }
+};
+
+window.__zellous.settings = serverSettings;
+window.serverSettings = serverSettings;
+if (!window.__debug) window.__debug = {};
+Object.defineProperty(window.__debug, 'settings', { get: function() { return { store: Object.fromEntries(serverSettings._store), sub: serverSettings._sub }; }, configurable: true });

package/src/legacy/nostr-state-patch.js

@@ -0,0 +1,19 @@
+(() => {
+  const sig = window.__signal;
+  const raw = window.stateSignals;
+
+  raw.nostrPubkey = sig('');
+  raw.nostrPrivkey = sig(null);
+  raw.nostrRelays = sig([
+    'wss://relay.damus.io',
+    'wss://relay.primal.net',
+    'wss://relay.snort.social',
+    'wss://nos.lol',
+    'wss://relay.olas.app',
+    'wss://nostr.mom'
+  ]);
+  raw.nostrRelayStatus = sig(new Map());
+  raw.nostrProfile = sig(null);
+  raw.nostrSubscriptions = sig(new Map());
+  raw.currentChannelId = sig(null);
+})();

package/src/legacy/nostr-voice-camera.js

@@ -0,0 +1,63 @@
+var nostrVoiceCamera = {
+  _fsm: null,
+
+  _initFSM: function() {
+    var actor = XState.createActor(nostrFsm.cameraMachine);
+    actor.subscribe(function(snap) {
+      var state_val = snap.value;
+      document.getElementById('voiceCamBtn')?.classList.toggle('active', state_val === 'active');
+    });
+    actor.start();
+    nostrVoiceCamera._fsm = actor;
+  },
+
+  toggle() {
+    if (!nostrVoiceCamera._fsm) nostrVoiceCamera._initFSM();
+    var snap = nostrVoiceCamera._fsm.getSnapshot();
+    if (snap.matches('active')) {
+      nostrVoiceCamera.stop();
+    } else if (snap.matches('idle')) {
+      nostrVoiceCamera.start();
+    }
+  },
+
+  async start() {
+    if (!nostrVoiceCamera._fsm) nostrVoiceCamera._initFSM();
+    var snap = nostrVoiceCamera._fsm.getSnapshot();
+    if (!snap.can({type:'enable'})) return;
+    nostrVoiceCamera._fsm.send({type:'enable'});
+    state.cameraEnabled = true;
+    if (nostrVoice._cameraStream) {
+      var track = nostrVoice._cameraStream.getVideoTracks()[0];
+      nostrVoice._peers.forEach(function(peer) {
+        var sender = peer.pc.getSenders().find(function(s) { return s.track && s.track.kind === 'video'; });
+        if (sender) { sender.replaceTrack(track).catch(function(){}); }
+        else { peer.pc.addTrack(track, nostrVoice._cameraStream); }
+      });
+      var local = nostrVoice._participants.get('local');
+      if (local) local.hasVideo = true;
+      nostrVoiceCamera._fsm.send({type:'enabled'});
+      nostrVoice.updateParticipants();
+    } else {
+      nostrVoiceCamera._fsm.send({type:'denied'});
+      state.cameraEnabled = false;
+    }
+  },
+
+  stop() {
+    if (!nostrVoiceCamera._fsm) nostrVoiceCamera._initFSM();
+    if (!nostrVoiceCamera._fsm.getSnapshot().can({type:'disable'})) return;
+    nostrVoiceCamera._fsm.send({type:'disable'});
+    state.cameraEnabled = false;
+    nostrVoice._peers.forEach(function(peer) {
+      var sender = peer.pc.getSenders().find(function(s) { return s.track && s.track.kind === 'video'; });
+      if (sender) { sender.replaceTrack(null).catch(function(){}); }
+    });
+    var local = nostrVoice._participants.get('local');
+    if (local) local.hasVideo = false;
+    nostrVoice.updateParticipants();
+  }
+};
+
+window.__zellous.voiceCamera = nostrVoiceCamera;
+window.nostrVoiceCamera = nostrVoiceCamera;