wireweave 0.1.1 → 0.1.3

package/src/roles.js

@@ -0,0 +1,58 @@
+export class Roles extends EventTarget {
+  constructor({ relayPool, auth }) {
+    super();
+    if (!relayPool || !auth) throw new Error('Roles: deps required');
+    this.pool = relayPool; this.auth = auth;
+    this.store = new Map();
+    this.sub = null;
+  }
+
+  _creatorOf(serverId) { return serverId ? serverId.split(':')[0] : null; }
+
+  isOwner(serverId) { return !!this.auth.pubkey && this._creatorOf(serverId) === this.auth.pubkey; }
+  isAdmin(serverId) { if (this.isOwner(serverId)) return true; const r = this.store.get(serverId); return !!(r?.admins || []).includes(this.auth.pubkey); }
+  isMod(serverId) { if (this.isAdmin(serverId)) return true; const r = this.store.get(serverId); return !!(r?.mods || []).includes(this.auth.pubkey); }
+
+  getRole(serverId, pubkey) {
+    if (pubkey === this._creatorOf(serverId)) return 'owner';
+    const r = this.store.get(serverId) || {};
+    if ((r.admins || []).includes(pubkey)) return 'admin';
+    if ((r.mods || []).includes(pubkey)) return 'moderator';
+    return 'member';
+  }
+
+  async setRole(serverId, targetPubkey, role) {
+    if (!this.isOwner(serverId) && role === 'admin') throw new Error('Only owner can assign admin');
+    if (!this.isAdmin(serverId)) throw new Error('Insufficient permissions');
+    const existing = this.store.get(serverId) || { admins: [], mods: [] };
+    let admins = (existing.admins || []).filter(p => p !== targetPubkey);
+    let mods = (existing.mods || []).filter(p => p !== targetPubkey);
+    if (role === 'admin') admins = [...admins, targetPubkey];
+    else if (role === 'moderator') mods = [...mods, targetPubkey];
+    const next = { admins, mods };
+    this.store.set(serverId, next);
+    const signed = await this.auth.sign({ kind: 30078, created_at: Math.floor(Date.now() / 1000), tags: [['d', 'zellous-roles:' + serverId]], content: JSON.stringify(next) });
+    this.pool.publish(signed);
+    this.dispatchEvent(new CustomEvent('updated', { detail: { serverId, next } }));
+  }
+
+  subscribe(serverId) {
+    if (this.sub) { this.pool.unsubscribe(this.sub); this.sub = null; }
+    if (!serverId) return;
+    const creator = this._creatorOf(serverId);
+    if (!creator) return;
+    this.sub = 'roles-' + serverId;
+    this.pool.subscribe(this.sub,
+      [{ kinds: [30078], authors: [creator], '#d': ['zellous-roles:' + serverId] }],
+      (event) => {
+        if (event.pubkey !== creator) return;
+        try {
+          const data = JSON.parse(event.content);
+          this.store.set(serverId, { admins: data.admins || [], mods: data.mods || [] });
+          this.dispatchEvent(new CustomEvent('updated', { detail: { serverId, next: this.store.get(serverId) } }));
+        } catch {}
+      });
+  }
+}
+
+export const createRoles = (opts) => new Roles(opts);

package/src/servers.js

@@ -0,0 +1,103 @@
+export class Servers extends EventTarget {
+  constructor({ relayPool, auth, storage, onSwitch = null }) {
+    super();
+    if (!relayPool || !auth || !storage) throw new Error('Servers: deps required');
+    this.pool = relayPool; this.auth = auth; this.storage = storage; this.onSwitch = onSwitch;
+    this.servers = []; this.currentServerId = null;
+  }
+
+  load() {
+    try { this.servers = JSON.parse(this.storage.getItem('zn_servers') || '[]'); } catch { this.servers = []; }
+    if (this.auth.pubkey) {
+      this.pool.subscribe('my-servers', [{ kinds: [34550], authors: [this.auth.pubkey] }], (ev) => this._handleEvent(ev));
+    }
+    try {
+      const joined = JSON.parse(this.storage.getItem('zn_joined_servers') || '[]');
+      joined.forEach(sid => { if (!this.servers.find(s => s.id === sid)) this.servers = [...this.servers, { id: sid, name: sid.slice(0, 8), iconColor: '#5865F2' }]; });
+      const unresolved = joined.filter(sid => { const p = sid.split(':'); return p.length === 2 && p[0] !== this.auth.pubkey; });
+      const byAuthor = {};
+      unresolved.forEach(sid => { const [author, dTag] = sid.split(':'); (byAuthor[author] = byAuthor[author] || []).push(dTag); });
+      Object.keys(byAuthor).forEach(author => {
+        this.pool.subscribe('joined-server-' + author.slice(0, 8),
+          [{ kinds: [34550], authors: [author], '#d': byAuthor[author] }],
+          (ev) => this._handleEvent(ev));
+      });
+    } catch {}
+    this._emit('updated', { servers: this.servers });
+  }
+
+  _handleEvent(event) {
+    const nameTag = event.tags.find(t => t[0] === 'name');
+    const colorTag = event.tags.find(t => t[0] === 'color');
+    const dTag = event.tags.find(t => t[0] === 'd');
+    if (!dTag) return;
+    const serverId = event.pubkey + ':' + dTag[1];
+    const name = nameTag ? nameTag[1] : serverId.slice(0, 8);
+    const iconColor = colorTag ? colorTag[1] : '#5865F2';
+    const existing = this.servers.find(s => s.id === serverId);
+    if (existing) { existing.name = name; existing.iconColor = iconColor; existing.ownerId = event.pubkey; this.servers = [...this.servers]; }
+    else this.servers = [...this.servers, { id: serverId, name, iconColor, ownerId: event.pubkey }];
+    this._persist();
+    this._emit('updated', { servers: this.servers });
+  }
+
+  async create(name, iconColor = '#5865F2') {
+    const dTag = Math.random().toString(36).slice(2, 10);
+    const serverId = this.auth.pubkey + ':' + dTag;
+    const signed = await this.auth.sign({ kind: 34550, created_at: Math.floor(Date.now() / 1000), tags: [['d', dTag], ['name', name], ['color', iconColor]], content: '' });
+    this.pool.publish(signed);
+    this.servers = [...this.servers, { id: serverId, name, iconColor, ownerId: this.auth.pubkey }];
+    this._persist();
+    await this.switchTo(serverId);
+  }
+
+  async join(serverId) {
+    try {
+      const joined = JSON.parse(this.storage.getItem('zn_joined_servers') || '[]');
+      if (!joined.includes(serverId)) { joined.push(serverId); this.storage.setItem('zn_joined_servers', JSON.stringify(joined)); }
+    } catch {}
+    if (!this.servers.find(s => s.id === serverId)) { this.servers = [...this.servers, { id: serverId, name: serverId.slice(0, 8), iconColor: '#5865F2' }]; this._persist(); }
+    await this.switchTo(serverId);
+  }
+
+  async delete(serverId) {
+    this.servers = this.servers.filter(s => s.id !== serverId);
+    this._persist();
+    try {
+      const joined = JSON.parse(this.storage.getItem('zn_joined_servers') || '[]');
+      this.storage.setItem('zn_joined_servers', JSON.stringify(joined.filter(id => id !== serverId)));
+    } catch {}
+    if (this.currentServerId === serverId) await this.switchTo(null);
+    else this._emit('updated', { servers: this.servers });
+  }
+
+  async leave(serverId) { return this.delete(serverId); }
+
+  async switchTo(serverId) {
+    this.currentServerId = serverId;
+    if (serverId) this.storage.setItem('zn_lastServer', serverId); else this.storage.removeItem('zn_lastServer');
+    this._emit('switched', { serverId });
+    await this.onSwitch?.(serverId);
+  }
+
+  init() {
+    this.load();
+    const last = this.storage.getItem('zn_lastServer');
+    if (last && this.servers.find(s => s.id === last)) this.switchTo(last);
+    else if (this.servers.length) this.switchTo(this.servers[0].id);
+  }
+
+  getOrder() { try { return JSON.parse(this.storage.getItem('zn_serverOrder') || '[]'); } catch { return []; } }
+  saveOrder(ids) { this.storage.setItem('zn_serverOrder', JSON.stringify(ids)); this._emit('updated', { servers: this.servers }); }
+  sorted() {
+    const order = this.getOrder();
+    if (!order.length) return this.servers;
+    const idx = {}; order.forEach((id, i) => idx[id] = i);
+    return this.servers.slice().sort((a, b) => (idx[a.id] ?? Infinity) - (idx[b.id] ?? Infinity));
+  }
+
+  _persist() { this.storage.setItem('zn_servers', JSON.stringify(this.servers)); }
+  _emit(t, d) { this.dispatchEvent(new CustomEvent(t, { detail: d })); }
+}
+
+export const createServers = (opts) => new Servers(opts);

package/src/settings.js

@@ -0,0 +1,72 @@
+const VALID_BITRATES = [8000, 16000, 24000, 48000, 96000];
+const clampBitrate = (v) => VALID_BITRATES.reduce((prev, cur) => Math.abs(cur - v) < Math.abs(prev - v) ? cur : prev);
+
+export class Settings extends EventTarget {
+  constructor({ relayPool, auth, roles }) {
+    super();
+    if (!relayPool || !auth || !roles) throw new Error('Settings: deps required');
+    this.pool = relayPool; this.auth = auth; this.roles = roles;
+    this.store = new Map();
+    this.sub = null;
+  }
+
+  getBitrate(serverId) { return this.store.get(serverId)?.opusBitrate || 24000; }
+
+  async setBitrate(serverId, bitrate) {
+    if (!this.roles.isOwner(serverId) && !this.roles.isAdmin(serverId)) throw new Error('Insufficient permissions');
+    const clamped = clampBitrate(Number(bitrate));
+    const existing = this.store.get(serverId) || {};
+    const next = { ...existing, opusBitrate: clamped };
+    this.store.set(serverId, next);
+    const signed = await this.auth.sign({ kind: 30078, created_at: Math.floor(Date.now() / 1000), tags: [['d', 'zellous-settings:' + serverId]], content: JSON.stringify(next) });
+    this.pool.publish(signed);
+    this.dispatchEvent(new CustomEvent('updated', { detail: { serverId, next } }));
+    return clamped;
+  }
+
+  getEmbedAllowlist(serverId) {
+    const s = this.store.get(serverId);
+    if (!s?.embedAllowlist) return [];
+    return typeof s.embedAllowlist === 'string' ? s.embedAllowlist.split(',').map(d => d.trim()).filter(Boolean) : s.embedAllowlist;
+  }
+
+  async setEmbedAllowlist(serverId, domainsStr) {
+    if (!this.roles.isOwner(serverId) && !this.roles.isAdmin(serverId)) throw new Error('Insufficient permissions');
+    const domains = domainsStr.split(',').map(d => d.trim()).filter(Boolean);
+    const existing = this.store.get(serverId) || {};
+    const next = { ...existing, embedAllowlist: domains };
+    this.store.set(serverId, next);
+    const signed = await this.auth.sign({ kind: 30078, created_at: Math.floor(Date.now() / 1000), tags: [['d', 'zellous-settings:' + serverId]], content: JSON.stringify(next) });
+    this.pool.publish(signed);
+    this.dispatchEvent(new CustomEvent('updated', { detail: { serverId, next } }));
+    return domains;
+  }
+
+  isOriginAllowed(serverId, origin) {
+    if (!origin) return false;
+    const allowlist = this.getEmbedAllowlist(serverId);
+    if (!allowlist.length) return true;
+    let url; try { url = new URL(origin); } catch { return false; }
+    return allowlist.some(p => {
+      if (p === '*') return true;
+      if (p.startsWith('*.')) { const s = p.slice(2); return url.hostname === s || url.hostname.endsWith('.' + s); }
+      return url.hostname === p || url.hostname === p.replace(/^https?:\/\//, '');
+    });
+  }
+
+  subscribe(serverId) {
+    if (this.sub) { this.pool.unsubscribe(this.sub); this.sub = null; }
+    if (!serverId) return;
+    const creator = serverId.split(':')[0];
+    if (!creator) return;
+    this.sub = 'settings-' + serverId;
+    this.pool.subscribe(this.sub,
+      [{ kinds: [30078], authors: [creator], '#d': ['zellous-settings:' + serverId] }],
+      (event) => {
+        if (event.pubkey !== creator) return;
+        try { this.store.set(serverId, JSON.parse(event.content)); this.dispatchEvent(new CustomEvent('updated', { detail: { serverId, next: this.store.get(serverId) } })); } catch {}
+      });
+  }
+}
+
+export const createSettings = (opts) => new Settings(opts);

package/src/voice.js

@@ -0,0 +1,348 @@
+const ICE_SERVERS = [
+  { urls: 'stun:stun.l.google.com:19302' },
+  { urls: 'stun:stun1.l.google.com:19302' },
+  { urls: 'stun:stun.cloudflare.com:3478' },
+  { urls: 'stun:stun.nextcloud.com:443' },
+  { urls: 'turn:openrelay.metered.ca:80', username: 'openrelayproject', credential: 'openrelayproject' },
+  { urls: 'turn:openrelay.metered.ca:443', username: 'openrelayproject', credential: 'openrelayproject' },
+  { urls: 'turn:openrelay.metered.ca:443?transport=tcp', username: 'openrelayproject', credential: 'openrelayproject' },
+  { urls: 'turns:openrelay.metered.ca:443', username: 'openrelayproject', credential: 'openrelayproject' }
+];
+
+const PRESENCE_EXPIRY = 300000;
+const HEARTBEAT = 30000;
+const STALL_CHECK = 5000;
+const DISCONNECT_GRACE = 8000;
+
+const deriveRoomId = async (serverId, channel) => {
+  const h = await crypto.subtle.digest('SHA-256', new TextEncoder().encode((serverId || 'default') + ':voice:' + channel));
+  return 'zellous' + Array.from(new Uint8Array(h)).map(b => b.toString(16).padStart(2, '0')).join('').slice(0, 16);
+};
+
+export class VoiceSession extends EventTarget {
+  constructor({ fsm, xstate, relayPool, auth, mediaDevices, bans = null, serverId = '', onAudioTrack = null, onVideoTrack = null }) {
+    super();
+    if (!fsm || !xstate || !relayPool || !auth || !mediaDevices) throw new Error('VoiceSession: missing deps');
+    this.fsm = fsm; this.xstate = xstate; this.pool = relayPool; this.auth = auth; this.md = mediaDevices; this.bans = bans;
+    this.serverId = serverId;
+    this.onAudioTrack = onAudioTrack; this.onVideoTrack = onVideoTrack;
+    this.actor = null;
+    this.channelName = ''; this.roomId = '';
+    this.peers = new Map(); this.participants = new Map();
+    this.localStream = null; this.cameraStream = null;
+    this.heartbeat = null; this.joinTs = 0;
+    this.muted = false; this.deafened = false;
+    this.sfu = { mode: 'mesh', hub: null, hubLostAt: null, rttMatrix: new Map(), electionTimer: null, statsInterval: null, actor: null };
+    this.retrySchedule = {};
+  }
+
+  _initActor() {
+    this.actor = this.xstate.createActor(this.fsm.voiceMachine);
+    this.actor.subscribe((snap) => this.dispatchEvent(new CustomEvent('state', { detail: { value: snap.value } })));
+    this.actor.start();
+  }
+
+  async connect(channelName, { displayName = 'Guest' } = {}) {
+    if (!this.actor) this._initActor();
+    if (!this.actor.getSnapshot().can({ type: 'connect' })) await this.disconnect();
+    this.actor.send({ type: 'connect' });
+    this.channelName = channelName;
+    this.joinTs = Math.floor(Date.now() / 1000);
+    this.displayName = displayName;
+    try {
+      this.roomId = await deriveRoomId(this.serverId, channelName);
+      this.localStream = await this.md.getUserMedia({ audio: { echoCancellation: true, noiseSuppression: true, autoGainControl: true } });
+      this.participants.clear();
+      this.participants.set('local', { identity: displayName, isSpeaking: false, isMuted: false, isLocal: true, hasVideo: false, connectionQuality: 'good' });
+      this.actor.send({ type: 'connected' });
+      this._subscribeSignals();
+      this._subscribePresence();
+      await this._publishPresence('join');
+      this._startHeartbeat();
+      this._sfuStart();
+      this._emit('connected', { roomId: this.roomId, channelName });
+    } catch (e) {
+      this.actor.send({ type: 'fail' });
+      this._emit('error', { message: 'connect failed: ' + e.message });
+      throw e;
+    }
+  }
+
+  async disconnect() {
+    if (!this.actor || this.actor.getSnapshot().matches('idle')) return;
+    if (!this.actor.getSnapshot().can({ type: 'disconnect' })) return;
+    this.actor.send({ type: 'disconnect' });
+    await this._publishPresence('leave');
+    this._stopHeartbeat();
+    this._sfuStop();
+    for (const pk of Array.from(this.peers.keys())) this._closePeer(pk);
+    this.peers.clear();
+    if (this.cameraStream) { this.cameraStream.getTracks().forEach(t => t.stop()); this.cameraStream = null; }
+    if (this.localStream) { this.localStream.getTracks().forEach(t => t.stop()); this.localStream = null; }
+    if (this.roomId) { this.pool.unsubscribe('voice-presence-' + this.roomId); this.pool.unsubscribe('voice-signals-' + this.roomId); }
+    this.participants.clear();
+    this.roomId = ''; this.channelName = '';
+    this.muted = false; this.deafened = false;
+    this.actor.send({ type: 'done' });
+    this._emit('disconnected', {});
+  }
+
+  toggleMic() {
+    this.muted = !this.muted;
+    if (this.localStream) this.localStream.getAudioTracks().forEach(t => t.enabled = !this.muted);
+    const local = this.participants.get('local'); if (local) local.isMuted = this.muted;
+    this._emit('mic', { muted: this.muted });
+    this._emit('participants', { list: this.getParticipants() });
+  }
+
+  toggleDeafen() {
+    this.deafened = !this.deafened;
+    for (const [, peer] of this.peers) if (peer.audioEl) peer.audioEl.muted = this.deafened;
+    this._emit('deafen', { deafened: this.deafened });
+  }
+
+  getParticipants() { return Array.from(this.participants.values()); }
+
+  async _publishPresence(action) {
+    if (!this.auth.isLoggedIn() || !this.roomId) return;
+    const rttScores = action === 'heartbeat' ? this._rttScores() : {};
+    const signed = await this.auth.sign({
+      kind: 30078, created_at: Math.floor(Date.now() / 1000),
+      tags: [['d', 'zellous-voice:' + this.roomId], ['action', action], ['channel', this.channelName], ['server', this.serverId]],
+      content: JSON.stringify({ action, name: this.displayName, channel: this.channelName, ts: Date.now(), rttScores })
+    });
+    this.pool.publish(signed);
+  }
+
+  _startHeartbeat() { this._stopHeartbeat(); this.heartbeat = setInterval(() => { if (this.actor?.getSnapshot().matches('connected')) this._publishPresence('heartbeat'); }, HEARTBEAT); }
+  _stopHeartbeat() { if (this.heartbeat) { clearInterval(this.heartbeat); this.heartbeat = null; } }
+
+  _subscribePresence() {
+    this.pool.subscribe('voice-presence-' + this.roomId,
+      [{ kinds: [30078], '#d': ['zellous-voice:' + this.roomId] }],
+      (event) => this._onPresence(event));
+  }
+
+  _onPresence(event) {
+    if (event.pubkey === this.auth.pubkey) return;
+    let data; try { data = JSON.parse(event.content); } catch { return; }
+    if (Date.now() - (data.ts || 0) > PRESENCE_EXPIRY) return;
+    const shortId = 'nostr-' + event.pubkey.slice(0, 12);
+    if (data.rttScores) this.sfu.rttMatrix.set(event.pubkey, data.rttScores);
+    if (data.action === 'leave') { this.participants.delete(shortId); this._closePeer(event.pubkey); }
+    else if (!this.participants.has(shortId)) {
+      this.participants.set(shortId, { identity: data.name || event.pubkey.slice(0, 8), isSpeaking: false, isMuted: false, isLocal: false, hasVideo: false, connectionQuality: 'connecting' });
+      this._maybeConnect(event.pubkey);
+    } else if (!this.peers.has(event.pubkey)) this._maybeConnect(event.pubkey);
+    this._emit('participants', { list: this.getParticipants() });
+  }
+
+  _subscribeSignals() {
+    this.pool.subscribe('voice-signals-' + this.roomId,
+      [{ kinds: [30078], '#p': [this.auth.pubkey], '#r': [this.roomId] }],
+      (event) => this._handleSignal(event));
+  }
+
+  _maybeConnect(peerPubkey) {
+    if (!peerPubkey || peerPubkey === this.auth.pubkey || this.peers.has(peerPubkey)) return;
+    if (this.bans && this.serverId && (this.bans.isBanned?.(this.serverId, peerPubkey) || this.bans.isTimedOut?.(this.serverId, peerPubkey))) return;
+    this._cancelReconnect(peerPubkey);
+    const fsmActor = this.xstate.createActor(this.fsm.peerMachine);
+    fsmActor.subscribe((snap) => { const p = this.peers.get(peerPubkey); if (p) p.state = snap.value; });
+    fsmActor.start();
+    const peer = { pc: null, audioEl: null, pendingCandidates: [], bufferedCandidates: [], iceTimer: null, disconnectTimer: null, failCount: 0, state: 'new', fsm: fsmActor, _stallInterval: null, remoteDescSet: false, trackEndedRestart: false };
+    this.peers.set(peerPubkey, peer);
+    const pc = new RTCPeerConnection({ iceServers: ICE_SERVERS, bundlePolicy: 'max-bundle' });
+    peer.pc = pc;
+    const isOfferer = this.auth.pubkey > peerPubkey;
+    if (isOfferer) {
+      if (this.localStream) this.localStream.getTracks().forEach(t => pc.addTransceiver(t, { direction: 'sendrecv', streams: [this.localStream] }));
+      else pc.addTransceiver('audio', { direction: 'recvonly' });
+    }
+    this._wirePeer(peer, peerPubkey, fsmActor, isOfferer);
+  }
+
+  _wirePeer(peer, peerPubkey, fsmActor, isOfferer) {
+    const pc = peer.pc;
+    pc.ontrack = (ev) => {
+      if (ev.track.kind === 'video') { this.onVideoTrack?.({ peerPubkey, track: ev.track, stream: ev.streams[0] }); return; }
+      this.onAudioTrack?.({ peerPubkey, track: ev.track, stream: ev.streams[0], peer });
+      try { ev.receiver.playoutDelayHint = 0.02; } catch {}
+      ev.track.onended = () => { if (peer.fsm.getSnapshot().matches('connected')) this._doIceRestart(peer, peerPubkey, fsmActor); };
+      if (!peer._stallInterval) peer._stallInterval = setInterval(() => this._checkStall(peer, peerPubkey, fsmActor), STALL_CHECK);
+    };
+    pc.onicecandidate = (ev) => {
+      if (!ev.candidate) return;
+      peer.pendingCandidates.push(ev.candidate.toJSON());
+      if (peer.iceTimer) clearTimeout(peer.iceTimer);
+      peer.iceTimer = setTimeout(() => { if (peer.pendingCandidates.length) { this._publishSignal(peerPubkey, 'ice', peer.pendingCandidates.splice(0)); peer.iceTimer = null; } }, 500);
+    };
+    pc.onicegatheringstatechange = () => { if (pc.iceGatheringState === 'complete') { if (peer.iceTimer) { clearTimeout(peer.iceTimer); peer.iceTimer = null; } if (peer.pendingCandidates.length) this._publishSignal(peerPubkey, 'ice', peer.pendingCandidates.splice(0)); } };
+    pc.onconnectionstatechange = () => {
+      if (pc.connectionState === 'connected') {
+        peer.failCount = 0; this._cancelReconnect(peerPubkey);
+        if (fsmActor.getSnapshot().can({ type: 'recv_answer' })) fsmActor.send({ type: 'recv_answer' });
+        if (peer.disconnectTimer) { clearTimeout(peer.disconnectTimer); peer.disconnectTimer = null; }
+        this._applyAudioHints(pc);
+      }
+      if (pc.connectionState === 'disconnected') { fsmActor.send({ type: 'disconnect' }); peer.disconnectTimer = setTimeout(() => this._doIceRestart(peer, peerPubkey, fsmActor), DISCONNECT_GRACE); }
+      if (pc.connectionState === 'failed') this._doIceRestart(peer, peerPubkey, fsmActor);
+      if (pc.connectionState === 'closed') { this._closePeer(peerPubkey); if (this.sfu.hub === peerPubkey) { this._sfuDissolve(); setTimeout(() => this._sfuMaybeElect(), 500); } }
+    };
+    if (isOfferer) {
+      fsmActor.send({ type: 'offer' });
+      pc.createOffer().then(o => pc.setLocalDescription(o).then(() => this._publishSignal(peerPubkey, 'offer', o))).catch(() => {});
+    }
+  }
+
+  _applyAudioHints(pc) {
+    try {
+      pc.getSenders().forEach(s => { if (!s.track || s.track.kind !== 'audio') return; const p = s.getParameters(); if (!p.encodings?.length) return; p.encodings[0].networkPriority = 'high'; p.encodings[0].maxBitrate = 48000; s.setParameters(p).catch(() => {}); });
+      pc.getReceivers().forEach(r => { if (r.track?.kind !== 'audio') return; try { r.playoutDelayHint = 0.02; } catch {} });
+    } catch {}
+  }
+
+  _checkStall(peer, peerPubkey, fsmActor) {
+    if (!peer.audioEl?.srcObject || !peer.fsm.getSnapshot().matches('connected') || peer.trackEndedRestart) return;
+    const allEnded = peer.audioEl.srcObject.getTracks().every(t => t.readyState === 'ended');
+    if (!allEnded) return;
+    peer.trackEndedRestart = true;
+    this._doIceRestart(peer, peerPubkey, fsmActor);
+  }
+
+  _doIceRestart(peer, peerPubkey, fsmActor) {
+    const pc = peer.pc;
+    if (peer.disconnectTimer) { clearTimeout(peer.disconnectTimer); peer.disconnectTimer = null; }
+    peer.failCount++;
+    if (peer.failCount <= 1 && this.auth.pubkey > peerPubkey) {
+      fsmActor.send({ type: 'restart' }); pc.restartIce();
+      pc.createOffer({ iceRestart: true }).then(o => pc.setLocalDescription(o).then(() => this._publishSignal(peerPubkey, 'offer', o))).catch(() => this._closePeer(peerPubkey));
+    } else { this._closePeer(peerPubkey); this._scheduleReconnect(peerPubkey, peer.failCount); }
+  }
+
+  _handleSignal(event) {
+    const from = event.pubkey; if (from === this.auth.pubkey) return;
+    let data; try { data = JSON.parse(event.content); } catch { return; }
+    if (!data?.type) return;
+    if (!this.peers.has(from)) this._maybeConnect(from);
+    const peer = this.peers.get(from); if (!peer) return;
+    const pc = peer.pc; const fsmActor = peer.fsm;
+    const addCands = (cands) => cands.forEach(c => pc.addIceCandidate(new RTCIceCandidate(c)).catch(() => {}));
+    const drainBuf = () => { addCands(peer.bufferedCandidates); peer.bufferedCandidates = []; };
+    const doAnswer = async () => {
+      if (fsmActor.getSnapshot().can({ type: 'recv_offer' })) fsmActor.send({ type: 'recv_offer' });
+      await pc.setRemoteDescription(new RTCSessionDescription(data.data));
+      peer.remoteDescSet = true; drainBuf();
+      const hasAudioTx = pc.getTransceivers().some(t => t.receiver.track?.kind === 'audio');
+      if (!hasAudioTx) pc.addTransceiver('audio', { direction: this.localStream ? 'sendrecv' : 'recvonly' });
+      if (this.localStream) { const hasSender = pc.getSenders().some(s => s.track?.kind === 'audio'); if (!hasSender) this.localStream.getTracks().forEach(t => pc.addTrack(t, this.localStream)); }
+      const a = await pc.createAnswer(); await pc.setLocalDescription(a); fsmActor.send({ type: 'sent_answer' }); this._publishSignal(from, 'answer', a);
+    };
+    if (data.type === 'offer') {
+      const polite = this.auth.pubkey < from; const collision = pc.signalingState !== 'stable';
+      if (collision && !polite) return;
+      if (collision && polite) { pc.setLocalDescription({ type: 'rollback' }).then(doAnswer).catch(() => {}); return; }
+      doAnswer().catch(() => {});
+    } else if (data.type === 'answer' && pc.signalingState === 'have-local-offer') {
+      pc.setRemoteDescription(new RTCSessionDescription(data.data)).then(() => { peer.remoteDescSet = true; drainBuf(); }).catch(() => {});
+    } else if (data.type === 'ice') {
+      const cands = Array.isArray(data.data) ? data.data : [data.data];
+      if (peer.remoteDescSet) addCands(cands); else peer.bufferedCandidates.push(...cands);
+    }
+  }
+
+  async _publishSignal(toPubkey, type, data) {
+    if (!this.auth.pubkey || !this.roomId) return;
+    const d = 'zellous-rtc:' + this.roomId + ':' + this.auth.pubkey + ':' + toPubkey + ':' + type + ':' + (type === 'ice' ? Date.now() : 'sdp');
+    const signed = await this.auth.sign({ kind: 30078, created_at: Math.floor(Date.now() / 1000), tags: [['d', d], ['p', toPubkey], ['r', this.roomId]], content: JSON.stringify({ type, data }) });
+    this.pool.publish(signed);
+  }
+
+  _closePeer(peerPubkey) {
+    const peer = this.peers.get(peerPubkey); if (!peer) return;
+    if (peer.iceTimer) clearTimeout(peer.iceTimer);
+    if (peer.disconnectTimer) clearTimeout(peer.disconnectTimer);
+    if (peer._stallInterval) clearInterval(peer._stallInterval);
+    try { peer.pc?.close(); } catch {}
+    if (peer.audioEl) { peer.audioEl.srcObject = null; peer.audioEl.remove(); }
+    this.peers.delete(peerPubkey);
+    this._emit('peer-closed', { peerPubkey });
+  }
+
+  _cancelReconnect(pk) { const e = this.retrySchedule[pk]; if (e) { clearTimeout(e.timer); delete this.retrySchedule[pk]; } }
+  _scheduleReconnect(pk, attempt) {
+    const a = attempt || 0; if (a >= 6) return;
+    this._cancelReconnect(pk);
+    const timer = setTimeout(() => { delete this.retrySchedule[pk]; if (!this.peers.has(pk) && this.roomId) this._maybeConnect(pk); }, Math.min(2 ** a * 2000, 30000));
+    this.retrySchedule[pk] = { attempt: a, timer };
+  }
+
+  _sfuStart() { this.sfu.actor = this.xstate.createActor(this.fsm.sfuMachine); this.sfu.actor.start(); this._sfuStopStats(); this.sfu.statsInterval = setInterval(() => this._sfuPoll(), 5000); }
+  _sfuStop() { this._sfuStopStats(); this.sfu.actor?.send({ type: 'dissolve' }); this.sfu.hub = null; this.sfu.rttMatrix.clear(); }
+  _sfuStopStats() { if (this.sfu.statsInterval) { clearInterval(this.sfu.statsInterval); this.sfu.statsInterval = null; } if (this.sfu.electionTimer) { clearTimeout(this.sfu.electionTimer); this.sfu.electionTimer = null; } }
+  async _sfuPoll() {
+    const scores = {}; const tasks = [];
+    for (const [pk, peer] of this.peers) {
+      if (!peer.pc || peer.pc.connectionState !== 'connected') continue;
+      tasks.push(peer.pc.getStats().then(stats => stats.forEach(r => { if (r.type === 'candidate-pair' && r.state === 'succeeded' && r.currentRoundTripTime != null) scores[pk] = Math.round(r.currentRoundTripTime * 1000); })).catch(() => {}));
+    }
+    await Promise.all(tasks);
+    this.sfu.rttMatrix.set(this.auth.pubkey, scores);
+    this._sfuMaybeElect();
+  }
+  _sfuMaybeElect() {
+    if (this.peers.size < 3) { if (this.sfu.actor?.getSnapshot().value !== 'mesh') this._sfuDissolve(); return; }
+    if (this.sfu.electionTimer) return;
+    this.sfu.electionTimer = setTimeout(() => { this.sfu.electionTimer = null; this._sfuElect(); }, 2000);
+  }
+  _sfuElect() {
+    const all = [this.auth.pubkey]; for (const pk of this.peers.keys()) all.push(pk);
+    let best = null, bestAvg = Infinity;
+    for (const pk of all) {
+      const s = this.sfu.rttMatrix.get(pk); if (!s) continue;
+      const vals = Object.values(s).filter(v => typeof v === 'number'); if (!vals.length) continue;
+      const avg = vals.reduce((a, b) => a + b, 0) / vals.length;
+      if (avg < bestAvg || (avg === bestAvg && pk > best)) { bestAvg = avg; best = pk; }
+    }
+    if (!best || best === this.sfu.hub) return;
+    this.sfu.hub = best; this.sfu.actor?.send({ type: 'elected' });
+    if (best === this.auth.pubkey) this._sfuBecomeHub(); else this._sfuRouteToHub(best);
+  }
+  _sfuBecomeHub() {
+    for (const [srcPk, srcPeer] of this.peers) {
+      if (!srcPeer.pc?.getReceivers) continue;
+      srcPeer.pc.getReceivers().forEach(recv => {
+        if (recv.track?.kind !== 'audio') return;
+        for (const [dstPk, dstPeer] of this.peers) {
+          if (dstPk === srcPk) continue;
+          const sender = dstPeer.pc?.getSenders().find(s => s.track?.kind === 'audio');
+          sender?.replaceTrack(recv.track).catch(() => {});
+        }
+      });
+    }
+  }
+  _sfuRouteToHub(hubPk) {
+    for (const pk of Array.from(this.peers.keys())) { if (pk === hubPk) continue; this._closePeer(pk); }
+    if (!this.peers.has(hubPk)) this._maybeConnect(hubPk);
+  }
+  _sfuDissolve() { this.sfu.actor?.send({ type: 'dissolve' }); this.sfu.hubLostAt = Date.now(); this.sfu.hub = null; }
+
+  _rttScores() { return this.sfu.rttMatrix.get(this.auth.pubkey) || {}; }
+
+  debug() {
+    const peers = [];
+    for (const [pk, peer] of this.peers) peers.push({ pubkey: pk.slice(0, 12), fsmState: peer.fsm?.getSnapshot().value, iceState: peer.pc?.iceConnectionState, connState: peer.pc?.connectionState, candidates: peer.pendingCandidates.length, buffered: peer.bufferedCandidates.length });
+    const rttMatrix = {}; for (const [k, v] of this.sfu.rttMatrix) rttMatrix[k.slice(0, 12)] = v;
+    return { fsm: this.actor?.getSnapshot().value, peers, participants: this.getParticipants(), sfu: { mode: this.sfu.actor?.getSnapshot().value || 'mesh', hub: this.sfu.hub?.slice(0, 12) || null, rttMatrix }, retrySchedule: this.retrySchedule };
+  }
+
+  heal() {
+    if (!this.roomId) return;
+    const bad = { disconnected: 1, failed: 1, closed: 1 };
+    for (const [pk, peer] of this.peers) if (bad[peer.pc?.connectionState]) { this._closePeer(pk); this._scheduleReconnect(pk, 0); }
+  }
+
+  _emit(t, d) { this.dispatchEvent(new CustomEvent(t, { detail: d })); }
+}
+
+export const createVoiceSession = (opts) => new VoiceSession(opts);

package/src/wireweave.js

@@ -0,0 +1,89 @@
+import { createRelayPool } from './relay-pool.js';
+import { createAuth } from './auth.js';
+import { createFSM } from './fsm.js';
+import { createVoiceSession } from './voice.js';
+import { createChat } from './chat.js';
+import { createChannels } from './channels.js';
+import { createServers } from './servers.js';
+import { createMessageBus } from './message.js';
+import { createBans } from './bans.js';
+import { createRoles } from './roles.js';
+import { createSettings } from './settings.js';
+import { createMedia } from './media.js';
+import { createPages } from './pages.js';
+import { register } from './debug.js';
+
+export const createWireweave = ({
+  nostrTools,
+  xstate,
+  storage = (typeof localStorage !== 'undefined' ? localStorage : null),
+  extension = (typeof window !== 'undefined' ? window.nostr : null),
+  relays = ['wss://relay.damus.io', 'wss://relay.primal.net', 'wss://nos.lol', 'wss://relay.snort.social'],
+  mediaDevices = (typeof navigator !== 'undefined' ? navigator.mediaDevices : null),
+  WebSocketImpl = (typeof WebSocket !== 'undefined' ? WebSocket : null)
+} = {}) => {
+  if (!nostrTools) throw new Error('wireweave: nostrTools required');
+  if (!xstate) throw new Error('wireweave: xstate required');
+
+  const fsm = createFSM(xstate);
+  const pool = createRelayPool({ relays, verifyEvent: nostrTools.verifyEvent, WebSocketImpl });
+  const auth = createAuth({ nostrTools, storage, extension });
+  const message = createMessageBus();
+  const bans = createBans({ relayPool: pool });
+  const roles = createRoles({ relayPool: pool, auth });
+  const settings = createSettings({ relayPool: pool, auth, roles });
+  const pages = createPages({ relayPool: pool, auth, roles });
+  const media = createMedia({ relayPool: pool, auth });
+  const channels = createChannels({ relayPool: pool, auth });
+
+  let currentChannelId = null;
+  const chat = createChat({
+    relayPool: pool, auth,
+    getChannelContext: () => ({ channelId: currentChannelId, serverId: servers.currentServerId || '' }),
+    isAdmin: (sid) => roles.isAdmin(sid)
+  });
+
+  const servers = createServers({
+    relayPool: pool, auth, storage,
+    onSwitch: async (serverId) => {
+      roles.subscribe(serverId);
+      settings.subscribe(serverId);
+      bans.subscribe(serverId);
+      pages.subscribe(serverId);
+      if (serverId) {
+        await new Promise((resolve) => {
+          let done = false;
+          const finish = () => { if (done) return; done = true; resolve(); };
+          channels.load(serverId, finish);
+          setTimeout(finish, 3000);
+        });
+      }
+      const firstText = channels.channels.find(c => c.type === 'text');
+      if (firstText) {
+        currentChannelId = firstText.id;
+        chat.loadHistory(firstText.id);
+      }
+    }
+  });
+
+  let voice = null;
+  const ensureVoice = ({ serverId, displayName, onAudioTrack, onVideoTrack }) => {
+    if (!voice) voice = createVoiceSession({ fsm, xstate, relayPool: pool, auth, mediaDevices, bans, serverId, onAudioTrack, onVideoTrack });
+    else voice.serverId = serverId;
+    return voice;
+  };
+
+  const setCurrentChannel = (id) => { currentChannelId = id; if (id) chat.loadHistory(id); };
+
+  const api = {
+    pool, auth, fsm, message, bans, roles, settings, pages, media, channels, servers, chat,
+    get voice() { return voice; },
+    ensureVoice,
+    setCurrentChannel,
+    get currentChannelId() { return currentChannelId; },
+    get currentServerId() { return servers.currentServerId; }
+  };
+
+  register('wireweave', api);
+  return api;
+};