wireweave 0.3.40 → 0.3.42

package/README.md

@@ -83,7 +83,38 @@ session.broadcast(new Uint8Array(payload));     // → all open peers
 session.send(somePeerPubkey, new Uint8Array(p)); // → one peer
 ```
 
-Options: `dataChannelOptions` (default `{ ordered: true }`) and `iceServers` (override the default STUN/TURN list). Construct multiple `DataSession`s in the same page to use distinct rooms / channel configurations.
+Options: `dataChannelOptions` (default `{ ordered: true }`), `iceServers` (override the default STUN/TURN list for this session only), and `createPeerConnection` (see below). Construct multiple `DataSession`s in the same page to use distinct rooms / channel configurations.
+
+`setIceServers(list)` / `getIceServers()` (also exported from `wireweave/data` and `wireweave/voice`) override the module-wide default ICE server list for every session created afterward — useful for pointing at your own TURN infrastructure once, instead of passing `iceServers` to each session.
+
+## Node hosts behind NAT: `createPeerConnection`
+
+Both `DataSession` and `VoiceSession` accept a `createPeerConnection(config)` option. It defaults to a plain `new RTCPeerConnection(config)` (browser-shaped, works as-is with any WebRTC-polyfilled `globalThis`) — wireweave itself never imports a Node-specific WebRTC binding. A Node host that is itself likely to sit behind a restrictive NAT (a CLI tool, a headless server) can instead construct its own natively-tuned peer and hand it back:
+
+```js
+import * as ndc from 'node-datachannel';
+import { RTCPeerConnection as PolyfillRTCPeerConnection } from 'node-datachannel/polyfill';
+
+const session = createDataSession({
+  fsm, xstate, relayPool: pool, auth, namespace: 'mygame',
+  createPeerConnection: (config) => {
+    // node-datachannel's native RtcConfig is richer than the W3C shape:
+    // enableIceUdpMux shares one UDP port across all peer connections
+    // (fewer ports to traverse through a firewall); portRangeBegin/End
+    // pins ICE to a fixed range you can port-forward; proxyServer routes
+    // ICE through a SOCKS5/HTTP proxy on networks that block direct UDP/TCP.
+    const nativePc = new ndc.PeerConnection('peer', {
+      iceServers: config.iceServers.map(s => s.urls),
+      enableIceUdpMux: true,
+      // portRangeBegin: 50000, portRangeEnd: 51000,
+      // proxyServer: { type: 'Socks5', ip: '127.0.0.1', port: 1080 }
+    });
+    return new PolyfillRTCPeerConnection({ peerConnection: nativePc });
+  }
+});
+```
+
+This is opt-in and additive — omit `createPeerConnection` and Node hosts behave exactly as before (a plain polyfilled `RTCPeerConnection`).
 
 ## game / 3-mode usage pattern
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wireweave",
-  "version": "0.3.40",
+  "version": "0.3.42",
   "description": "nostr + webrtc voice + data SDK. networking layer for 247420 projects.",
   "type": "module",
   "main": "./src/index.js",
@@ -55,8 +55,8 @@
     "nostr-tools": "^2.7.0"
   },
   "devDependencies": {
-    "nostr-tools": "^2.7.0",
-    "ws": "^8.18.0"
+    "nostr-tools": "^2.23.12",
+    "ws": "^8.21.1"
   },
   "publishConfig": {
     "access": "public"

package/src/data.js

@@ -1,11 +1,23 @@
-const ICE_SERVERS = [
+// STUN handles same-LAN / non-symmetric-NAT cases; TURN is required when both
+// peers sit behind symmetric or restricted-cone NAT (typical home routers,
+// most carrier-grade NAT, corporate networks). UDP, TCP, and TLS TURN variants
+// are included so at least one path survives strict egress filtering. Kept in
+// sync with voice.js's DEFAULT_ICE_SERVERS.
+const DEFAULT_ICE_SERVERS = [
   { urls: 'stun:stun.l.google.com:19302' },
   { urls: 'stun:stun1.l.google.com:19302' },
   { urls: 'stun:stun.cloudflare.com:3478' },
-  { urls: 'turn:openrelay.metered.ca:80', username: 'openrelayproject', credential: 'openrelayproject' },
-  { urls: 'turn:openrelay.metered.ca:443', username: 'openrelayproject', credential: 'openrelayproject' },
+  { urls: 'stun:global.stun.twilio.com:3478' },
+  { urls: 'turn:global.relay.metered.ca:80', username: 'openrelayproject', credential: 'openrelayproject' },
+  { urls: 'turn:global.relay.metered.ca:80?transport=tcp', username: 'openrelayproject', credential: 'openrelayproject' },
+  { urls: 'turn:global.relay.metered.ca:443', username: 'openrelayproject', credential: 'openrelayproject' },
+  { urls: 'turns:global.relay.metered.ca:443?transport=tcp', username: 'openrelayproject', credential: 'openrelayproject' },
+  // Legacy hostname kept as a low-priority fallback in case some deployments still resolve it.
   { urls: 'turn:openrelay.metered.ca:443?transport=tcp', username: 'openrelayproject', credential: 'openrelayproject' }
 ];
+let ICE_SERVERS = DEFAULT_ICE_SERVERS;
+export const setIceServers = (list) => { if (Array.isArray(list) && list.length) ICE_SERVERS = list; };
+export const getIceServers = () => ICE_SERVERS.slice();
 
 const PRESENCE_EXPIRY = 300000;
 const HEARTBEAT = 30000;
@@ -17,14 +29,24 @@ const deriveRoomId = async (namespace, room) => {
   return 'wwdata' + Array.from(new Uint8Array(h)).map(b => b.toString(16).padStart(2, '0')).join('').slice(0, 16);
 };
 
+// Default: a plain browser-shaped RTCPeerConnection. Node hosts that want
+// deeper NAT-traversal tuning (ICE/UDP port muxing, a fixed port range for
+// port-forwarded firewalls, a SOCKS5/HTTP proxy for locked-down networks)
+// can pass createPeerConnection to construct their own native peer (e.g.
+// node-datachannel's PeerConnection with its richer RtcConfig) and hand it
+// back wrapped as an RTCPeerConnection-shaped object — wireweave itself never
+// depends on any Node-specific WebRTC binding.
+const defaultCreatePeerConnection = (config) => new RTCPeerConnection(config);
+
 export class DataSession extends EventTarget {
-  constructor({ fsm, xstate, relayPool, auth, namespace = '', dataChannelOptions = { ordered: true }, iceServers = null }) {
+  constructor({ fsm, xstate, relayPool, auth, namespace = '', dataChannelOptions = { ordered: true }, iceServers = null, createPeerConnection = defaultCreatePeerConnection }) {
     super();
     if (!fsm || !xstate || !relayPool || !auth) throw new Error('DataSession: missing deps');
     this.fsm = fsm; this.xstate = xstate; this.pool = relayPool; this.auth = auth;
     this.namespace = namespace;
     this.dcOptions = dataChannelOptions;
     this.iceServers = iceServers || ICE_SERVERS;
+    this.createPeerConnection = createPeerConnection;
     this.actor = null;
     this.room = ''; this.roomId = '';
     this.peers = new Map(); this.participants = new Map();
@@ -152,7 +174,7 @@ export class DataSession extends EventTarget {
     fsmActor.start();
     const peer = { pc: null, dc: null, pendingCandidates: [], bufferedCandidates: [], iceTimer: null, disconnectTimer: null, failCount: 0, state: 'new', fsm: fsmActor, remoteDescSet: false };
     this.peers.set(peerPubkey, peer);
-    const pc = new RTCPeerConnection({ iceServers: this.iceServers, bundlePolicy: 'max-bundle' });
+    const pc = this.createPeerConnection({ iceServers: this.iceServers, bundlePolicy: 'max-bundle', iceCandidatePoolSize: 4, iceTransportPolicy: 'all' });
     peer.pc = pc;
     const isOfferer = this.auth.pubkey > peerPubkey;
     this._wirePeer(peer, peerPubkey, fsmActor, isOfferer);

package/src/index.js

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

package/src/relay-pool.js

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

package/src/servers.js

@@ -62,13 +62,13 @@ export class Servers extends EventTarget {
     await this.switchTo(serverId);
   }
 
-  async join(serverId) {
+  async join(serverId, { name = null, iconColor = '#5865F2', select = true } = {}) {
     try {
       const joined = JSON.parse(this.storage.getItem('zn_joined_servers') || '[]');
       if (!joined.includes(serverId)) { joined.push(serverId); safeSetItem(this.storage, this, '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);
+    if (!this.servers.find(s => s.id === serverId)) { this.servers = [...this.servers, { id: serverId, name: name || serverId.slice(0, 8), iconColor }]; this._persist(); this._emit('updated', { servers: this.servers }); }
+    if (select) await this.switchTo(serverId);
   }
 
   async delete(serverId) {

package/src/voice.js

@@ -41,13 +41,19 @@ const deriveRoomId = async (serverId, channel) => {
   return 'zellous' + Array.from(new Uint8Array(h)).map(b => b.toString(16).padStart(2, '0')).join('').slice(0, 16);
 };
 
+// See data.js's defaultCreatePeerConnection for why this hook exists: it lets
+// a Node host inject a natively-tuned peer (ICE/UDP muxing, fixed port range,
+// proxy passthrough) without wireweave depending on any Node WebRTC binding.
+const defaultCreatePeerConnection = (config) => new RTCPeerConnection(config);
+
 export class VoiceSession extends EventTarget {
-  constructor({ fsm, xstate, relayPool, auth, mediaDevices, bans = null, serverId = '', onAudioTrack = null, onVideoTrack = null }) {
+  constructor({ fsm, xstate, relayPool, auth, mediaDevices, bans = null, serverId = '', onAudioTrack = null, onVideoTrack = null, createPeerConnection = defaultCreatePeerConnection }) {
     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.createPeerConnection = createPeerConnection;
     this.actor = null;
     this.channelName = ''; this.roomId = '';
     this.peers = new Map(); this.participants = new Map();
@@ -520,7 +526,7 @@ export class VoiceSession extends EventTarget {
     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', iceCandidatePoolSize: 4, iceTransportPolicy: 'all' });
+    const pc = this.createPeerConnection({ iceServers: ICE_SERVERS, bundlePolicy: 'max-bundle', iceCandidatePoolSize: 4, iceTransportPolicy: 'all' });
     peer.pc = pc;
     const isOfferer = this.auth.pubkey > peerPubkey;
     if (isOfferer) {