wireweave 0.3.37 → 0.3.40

package/README.md

@@ -83,38 +83,7 @@ session.broadcast(new Uint8Array(payload));     // → all open peers
 session.send(somePeerPubkey, new Uint8Array(p)); // → one peer
 ```
 
-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`).
+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.
 
 ## game / 3-mode usage pattern
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wireweave",
-  "version": "0.3.37",
+  "version": "0.3.40",
   "description": "nostr + webrtc voice + data SDK. networking layer for 247420 projects.",
   "type": "module",
   "main": "./src/index.js",

package/src/chat.js

@@ -24,7 +24,7 @@ export class Chat extends EventTarget {
     return this._sendTimes[0] + this.rateLimitWindowMs - now;
   }
 
-  async send(content, { announcement = false } = {}) {
+  async send(content, { announcement = false, replyTo = null } = {}) {
     const { channelId, serverId } = this.getChannelContext();
     if (!this.auth.isLoggedIn() || !channelId) return;
     if (announcement && !this.isAdmin(serverId)) return;
@@ -37,6 +37,7 @@ export class Chat extends EventTarget {
     this._sendTimes.push(Date.now());
     const chanHex = await hexChannelId(channelId, serverId);
     const tags = [['e', chanHex, '', 'root']];
+    if (replyTo?.id) tags.push(['e', replyTo.id, '', 'reply']);
     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);
@@ -82,7 +83,13 @@ export class Chat extends EventTarget {
   _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 };
+    const replyTag = (event.tags || []).find(t => t[0] === 'e' && t[3] === 'reply');
+    let replyTo = null;
+    if (replyTag) {
+      const cached = this.messages.find(m => m.id === replyTag[1]);
+      replyTo = cached ? { id: cached.id, userId: cached.userId, content: cached.content } : { id: replyTag[1] };
+    }
+    return { id: event.id, type: 'text', userId: event.pubkey, content: event.content, timestamp: event.created_at * 1000, tags: tTags, replyTo };
   }
 
   _addMessage(msg) {

package/src/data.js

@@ -1,23 +1,11 @@
-// 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 = [
+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: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: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' }
 ];
-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;
@@ -29,24 +17,14 @@ 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, createPeerConnection = defaultCreatePeerConnection }) {
+  constructor({ fsm, xstate, relayPool, auth, namespace = '', dataChannelOptions = { ordered: true }, iceServers = null }) {
     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();
@@ -174,7 +152,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 = this.createPeerConnection({ iceServers: this.iceServers, bundlePolicy: 'max-bundle', iceCandidatePoolSize: 4, iceTransportPolicy: 'all' });
+    const pc = new RTCPeerConnection({ iceServers: this.iceServers, bundlePolicy: 'max-bundle' });
     peer.pc = pc;
     const isOfferer = this.auth.pubkey > peerPubkey;
     this._wirePeer(peer, peerPubkey, fsmActor, isOfferer);

package/src/relay-pool.js

@@ -1,15 +1,14 @@
-// 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.snort.social',
-  'wss://relay.damus.io'
+  'wss://relay.0xchat.com'
 ];
 
 const SEEN_MAX = 10000;

package/src/voice.js

@@ -41,19 +41,13 @@ 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, createPeerConnection = defaultCreatePeerConnection }) {
+  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.createPeerConnection = createPeerConnection;
     this.actor = null;
     this.channelName = ''; this.roomId = '';
     this.peers = new Map(); this.participants = new Map();
@@ -526,7 +520,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 = this.createPeerConnection({ iceServers: ICE_SERVERS, bundlePolicy: 'max-bundle', iceCandidatePoolSize: 4, iceTransportPolicy: 'all' });
+    const pc = new RTCPeerConnection({ iceServers: ICE_SERVERS, bundlePolicy: 'max-bundle', iceCandidatePoolSize: 4, iceTransportPolicy: 'all' });
     peer.pc = pc;
     const isOfferer = this.auth.pubkey > peerPubkey;
     if (isOfferer) {