wireweave 0.1.1 → 0.1.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wireweave",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "nostr + webrtc voice SDK. networking layer for 247420 projects.",
   "type": "module",
   "main": "./src/index.js",
@@ -9,6 +9,9 @@
     ".": "./src/index.js",
     "./relay-pool": "./src/relay-pool.js",
     "./auth": "./src/auth.js",
+    "./fsm": "./src/fsm.js",
+    "./voice": "./src/voice.js",
+    "./chat": "./src/chat.js",
     "./debug": "./src/debug.js",
     "./legacy": "./src/legacy/index.js",
     "./legacy/*": "./src/legacy/*"

package/src/chat.js

@@ -0,0 +1,95 @@
+const hexChannelId = async (channelId, serverId) => {
+  const h = await crypto.subtle.digest('SHA-256', new TextEncoder().encode((serverId || 'default') + ':' + channelId));
+  return Array.from(new Uint8Array(h)).map(b => b.toString(16).padStart(2, '0')).join('');
+};
+
+export class Chat extends EventTarget {
+  constructor({ relayPool, auth, getChannelContext = () => ({ channelId: null, serverId: '' }), isAdmin = () => false }) {
+    super();
+    if (!relayPool || !auth) throw new Error('Chat: relayPool + auth required');
+    this.pool = relayPool; this.auth = auth;
+    this.getChannelContext = getChannelContext; this.isAdmin = isAdmin;
+    this.activeChannelId = null;
+    this.messages = [];
+    this.profiles = new Map(); this.fetching = new Set();
+  }
+
+  async send(content, { announcement = false } = {}) {
+    const { channelId, serverId } = this.getChannelContext();
+    if (!this.auth.isLoggedIn() || !channelId) return;
+    if (announcement && !this.isAdmin(serverId)) return;
+    const trimmed = content.trim(); if (!trimmed) return;
+    const chanHex = await hexChannelId(channelId, serverId);
+    const tags = [['e', chanHex, '', 'root']];
+    if (announcement) tags.push(['t', 'announcement']);
+    const signed = await this.auth.sign({ kind: 42, created_at: Math.floor(Date.now() / 1000), tags, content: trimmed });
+    this.pool.publish(signed);
+    this._addMessage(this._eventToMsg(signed));
+  }
+
+  async loadHistory(channelId) {
+    const { serverId } = this.getChannelContext();
+    if (this.activeChannelId) {
+      this.pool.unsubscribe('chat-' + this.activeChannelId);
+      this.pool.unsubscribe('chat-live-' + this.activeChannelId);
+    }
+    this.activeChannelId = channelId;
+    this.messages = [];
+    this._emit('messages', { list: [] });
+    const chanHex = await hexChannelId(channelId, serverId);
+    const collected = [];
+    this.pool.subscribe('chat-' + channelId,
+      [{ kinds: [42], '#e': [chanHex], limit: 50 }],
+      (ev) => collected.push(this._eventToMsg(ev)),
+      () => {
+        collected.sort((a, b) => a.timestamp - b.timestamp);
+        this.messages = collected;
+        this._emit('messages', { list: collected });
+      });
+    this.pool.subscribe('chat-live-' + channelId,
+      [{ kinds: [42], '#e': [chanHex], since: Math.floor(Date.now() / 1000) }],
+      (ev) => this._addMessage(this._eventToMsg(ev)));
+  }
+
+  async deleteMessage(id) {
+    const signed = await this.auth.sign({ kind: 5, created_at: Math.floor(Date.now() / 1000), tags: [['e', id]], content: 'deleted' });
+    this.pool.publish(signed);
+    this.messages = this.messages.filter(m => m.id !== id);
+    this._emit('messages', { list: this.messages });
+  }
+
+  _eventToMsg(event) {
+    const tTags = (event.tags || []).filter(t => t[0] === 't').map(t => t[1]);
+    this._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 (this.messages.find(m => m.id === msg.id)) return;
+    this.messages = [...this.messages, msg];
+    this._emit('message', { message: msg });
+    this._emit('messages', { list: this.messages });
+  }
+
+  resolveProfile(pubkey) {
+    const p = this.profiles.get(pubkey);
+    if (p) return p.name || this.auth.npubShort(pubkey);
+    this._fetchProfile(pubkey);
+    return this.auth.npubShort(pubkey);
+  }
+
+  _fetchProfile(pubkey) {
+    if (this.fetching.has(pubkey)) return;
+    this.fetching.add(pubkey);
+    this.pool.subscribe('profile-' + pubkey,
+      [{ kinds: [0], authors: [pubkey], limit: 1 }],
+      (event) => { try { this.profiles.set(pubkey, JSON.parse(event.content)); this._emit('profile', { pubkey, profile: this.profiles.get(pubkey) }); } catch {} },
+      () => { this.pool.unsubscribe('profile-' + pubkey); this.fetching.delete(pubkey); });
+  }
+
+  updateProfile(pubkey, profile) { this.profiles.set(pubkey, profile); this._emit('profile', { pubkey, profile }); }
+
+  _emit(t, d) { this.dispatchEvent(new CustomEvent(t, { detail: d })); }
+}
+
+export const createChat = (opts) => new Chat(opts);

package/src/fsm.js

@@ -0,0 +1,51 @@
+export const createFSM = (xstate) => {
+  if (!xstate?.createMachine) throw new Error('xstate required');
+  return {
+    voiceMachine: xstate.createMachine({
+      initial: 'idle',
+      states: {
+        idle: { on: { connect: 'connecting' } },
+        connecting: { on: { connected: 'connected', fail: 'idle' } },
+        connected: { on: { disconnect: 'disconnecting' } },
+        disconnecting: { on: { done: 'idle' } }
+      }
+    }),
+    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: {}
+      }
+    }),
+    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' } }
+      }
+    }),
+    relayMachine: 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' } }
+      }
+    }),
+    sfuMachine: xstate.createMachine({
+      initial: 'mesh',
+      states: {
+        mesh: { on: { elect: 'electing' } },
+        electing: { on: { elected: 'star', dissolve: 'mesh' } },
+        star: { on: { dissolve: 'mesh' } }
+      }
+    })
+  };
+};

package/src/index.js

@@ -1,3 +1,6 @@
 export { RelayPool, createRelayPool } from './relay-pool.js';
 export { NostrAuth, createAuth } from './auth.js';
+export { createFSM } from './fsm.js';
+export { VoiceSession, createVoiceSession } from './voice.js';
+export { Chat, createChat } from './chat.js';
 export * as debug from './debug.js';

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);