wireweave 0.3.40 → 0.3.41

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.41",
   "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/relay-pool.js

@@ -1,14 +1,15 @@
+// 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://relay.snort.social',
-  'wss://relay.nostr.band',
-  'wss://nostr.wine',
-  'wss://relay.current.fyi',
   'wss://offchain.pub',
   'wss://nostr-pub.wellorder.net',
-  'wss://relay.0xchat.com'
+  'wss://relay.snort.social',
+  'wss://relay.damus.io'
 ];
 
 const SEEN_MAX = 10000;

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