wireweave 0.3.41 → 0.3.43

package/package.json

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

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,3 +1,6 @@
+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
@@ -12,12 +15,94 @@ const DEFAULT_RELAYS = [
   '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://relay.0xchat.com'
+];
+
 const SEEN_MAX = 10000;
 const PENDING_MAX = 500;
 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);
@@ -34,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();
@@ -48,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() {
@@ -71,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) {
@@ -78,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; }
@@ -95,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);
     };
@@ -116,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));
@@ -142,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') {
@@ -163,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;
@@ -290,3 +512,4 @@ export class RelayPool extends EventTarget {
 }
 
 export const createRelayPool = (opts) => new RelayPool(opts);
+export { RelayHealth };

package/src/voice.js

@@ -36,6 +36,18 @@ const DC_LABEL = 'wireweave-queue';
 const DC_CHUNK_MAX = 14000;           // ~14 KB SCTP-friendly chunks
 const DC_HEADER = 'WW1';              // protocol marker
 
+// Opus bitrate ladder: named quality tiers applied to the outbound audio
+// RTCRtpSender's encoding via setParameters(). This is the real mechanism
+// available for a single (non-simulcast) Opus sender — see the simulcast
+// note on VoiceSession below for why per-layer simulcast is out of scope.
+const OPUS_BITRATE_LADDER = {
+  low: 16000,
+  medium: 32000,
+  high: 48000,
+  max: 64000
+};
+const DEFAULT_AUDIO_QUALITY = 'high';
+
 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);
@@ -46,8 +58,26 @@ const deriveRoomId = async (serverId, channel) => {
 // proxy passthrough) without wireweave depending on any Node WebRTC binding.
 const defaultCreatePeerConnection = (config) => new RTCPeerConnection(config);
 
+// SIMULCAST-LITE — scope verified against the real API surface used in this
+// file before promising it. Real browser simulcast (multiple RTCRtpEncodingParameters
+// with distinct `rid`/`scaleResolutionDownBy` on one RTCRtpSender) is a VIDEO-only
+// technique: Opus is not encoded per-layer, and every addTransceiver/addTrack call
+// site in this file (see `_maybeConnect`, `_handleSignal`'s doAnswer) sends audio
+// only — `cameraStream` is a field with no producer, there is no video sendrecv
+// transceiver anywhere in this module. Promising `sendEncodings` simulcast here
+// would be fabricated. The honest, reachable analog for a single-encoding Opus
+// sender is *adaptive bitrate switching* driven by live getStats() (already
+// polled in `_sfuPoll`) — `setAudioQuality`/the bitrate ladder below is that
+// real, verifiable mechanism, not simulcast. If/when this module gains a real
+// video sender, true simulcast (sendEncodings on addTransceiver) becomes
+// reachable and should replace this note.
 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, createPeerConnection = defaultCreatePeerConnection,
+    pttMode = true, micSensitivity = SPEAKER_ACTIVE_RMS, noiseSuppression = true,
+    echoCancellation = true, autoGainControl = true, audioQuality = DEFAULT_AUDIO_QUALITY, dtx = true
+  }) {
     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;
@@ -63,8 +93,55 @@ export class VoiceSession extends EventTarget {
     this.sfu = { mode: 'mesh', hub: null, hubLostAt: null, rttMatrix: new Map(), electionTimer: null, statsInterval: null, actor: null };
     this.retrySchedule = {};
     this._epoch = 0;
+    // Push-to-talk mode: when true (default, matches prior hardcoded behavior),
+    // connect() starts muted and the caller must setMuted(false)/requestTransmit()
+    // to speak. When false, connect() starts unmuted (open-mic / voice-activity mode).
+    this.pttMode = !!pttMode;
+    // Mic-sensitivity threshold: RMS level above which the speaker-activity
+    // detector (_pollActivity) counts a stream as "speaking". Was a hardcoded
+    // module constant (SPEAKER_ACTIVE_RMS); now a real per-instance, live-settable value.
+    this.micSensitivity = typeof micSensitivity === 'number' && micSensitivity > 0 ? micSensitivity : SPEAKER_ACTIVE_RMS;
+    // getUserMedia audio constraints — were hardcoded `true` at the single
+    // getUserMedia call site in connect(); now real constructor-configurable
+    // fields actually threaded into that call.
+    this.noiseSuppression = !!noiseSuppression;
+    this.echoCancellation = !!echoCancellation;
+    this.autoGainControl = !!autoGainControl;
+    // Opus bitrate ladder tier + DTX (discontinuous transmission / silence
+    // suppression). Applied for real in _applyAudioHints (bitrate, via the
+    // existing RTCRtpSender.setParameters call) and _mungeDtx (DTX, via
+    // real SDP fmtp munging — DTX is not an RTCRtpEncodingParameters field in
+    // the actual spec, it is negotiated in the Opus fmtp line).
+    this.setAudioQuality(audioQuality);
+    this.dtx = !!dtx;
+  }
+
+  // Live-settable: mic-sensitivity threshold used by the speaker-activity poller.
+  setMicSensitivity(rms) {
+    if (typeof rms !== 'number' || !(rms > 0)) return;
+    this.micSensitivity = rms;
+  }
+
+  // Live-settable: push-to-talk vs open-mic mode. Does not itself mute/unmute —
+  // it changes what connect() defaults to and what releaseTransmit() restores to.
+  setPttMode(on) { this.pttMode = !!on; }
+
+  // Live-settable: Opus target bitrate tier. Re-applies immediately to every
+  // connected peer's audio sender via the same setParameters() path _applyAudioHints
+  // uses, so a mid-call quality change actually reaches the wire.
+  setAudioQuality(tier) {
+    const kbps = OPUS_BITRATE_LADDER[tier];
+    this.audioQuality = kbps ? tier : DEFAULT_AUDIO_QUALITY;
+    this._targetBitrate = kbps || OPUS_BITRATE_LADDER[DEFAULT_AUDIO_QUALITY];
+    for (const [, peer] of this.peers) if (peer.pc) this._applyAudioHints(peer.pc);
   }
 
+  // Live-settable: DTX (silence suppression) toggle. Re-negotiation of an
+  // already-open connection isn't forced (that would require a fresh offer/answer);
+  // it takes effect on the next SDP exchange (offer, answer, or ICE restart) for
+  // open peers, and immediately for any new connection.
+  setDtx(on) { this.dtx = !!on; }
+
   _initActor() {
     this.actor = this.xstate.createActor(this.fsm.voiceMachine);
     this.actor.subscribe((snap) => this.dispatchEvent(new CustomEvent('state', { detail: { value: snap.value } })));
@@ -92,15 +169,16 @@ export class VoiceSession extends EventTarget {
     try {
       const roomId = await deriveRoomId(this.serverId, channelName);
       if (epoch !== this._epoch) return;
-      const stream = await this.md.getUserMedia({ audio: { echoCancellation: true, noiseSuppression: true, autoGainControl: true } });
+      const stream = await this.md.getUserMedia({ audio: { echoCancellation: this.echoCancellation, noiseSuppression: this.noiseSuppression, autoGainControl: this.autoGainControl } });
       if (epoch !== this._epoch) { stream.getTracks().forEach(t => t.stop()); return; }
       this.roomId = roomId;
       this.localStream = stream;
-      // PTT default: gate closed at join. Apps that want always-on call setMuted(false).
-      this.muted = true;
-      this.localStream.getAudioTracks().forEach(t => t.enabled = false);
+      // PTT mode: gate closed at join, caller opens it via setMuted(false)/requestTransmit().
+      // Open-mic mode (pttMode=false): start unmuted.
+      this.muted = this.pttMode;
+      this.localStream.getAudioTracks().forEach(t => t.enabled = !this.pttMode);
       this.participants.clear();
-      this.participants.set('local', { identity: displayName, isSpeaking: false, isMuted: true, isLocal: true, hasVideo: false, connectionQuality: 'good' });
+      this.participants.set('local', { identity: displayName, isSpeaking: false, isMuted: this.pttMode, isLocal: true, hasVideo: false, connectionQuality: 'good' });
       this._attachAnalyzer('local', this.localStream);
       this.actor.send({ type: 'connected' });
       this._subscribeSignals();
@@ -209,7 +287,7 @@ export class VoiceSession extends EventTarget {
       a.an.getByteTimeDomainData(buf);
       let sum = 0; for (let i = 0; i < buf.length; i++) { const v = (buf[i] - 128) / 128; sum += v * v; }
       const rms = Math.sqrt(sum / buf.length);
-      const active = rms > SPEAKER_ACTIVE_RMS;
+      const active = rms > this.micSensitivity;
       if (active) a.lastActive = now;
       const stillSpeaking = active || (now - a.lastActive) < SPEAKER_HOLD_MS;
       if (stillSpeaking !== a.speaking) { a.speaking = stillSpeaking; this._setSpeaking(key, stillSpeaking); }
@@ -258,7 +336,9 @@ export class VoiceSession extends EventTarget {
   releaseTransmit() {
     this._wantsTransmit = false;
     if (this._outboundRec) this._finalizeOutboundCapture();
-    if (!this.muted) this.setMuted(true);
+    // Only re-close the gate in PTT mode. In open-mic mode there is no "release"
+    // to fall back to — the mic stays live per pttMode's own semantics.
+    if (this.pttMode && !this.muted) this.setMuted(true);
     this._emit('transmit', { mode: 'idle' });
   }
 
@@ -591,19 +671,44 @@ export class VoiceSession extends EventTarget {
     this._ensureDataChannel(peer, peerPubkey, isOfferer);
     if (isOfferer) {
       fsmActor.send({ type: 'offer' });
-      pc.createOffer().then(o => pc.setLocalDescription(o).then(() => this._publishSignal(peerPubkey, 'offer', o))).catch(() => {});
+      pc.createOffer().then(o => { o.sdp = this._mungeDtx(o.sdp); return pc.setLocalDescription(o).then(() => this._publishSignal(peerPubkey, 'offer', o)); }).catch(() => {});
     }
   }
 
+  // Real DTX (discontinuous transmission / silence suppression) toggle.
+  // DTX is not an RTCRtpEncodingParameters field in the actual WebRTC spec —
+  // it's negotiated per the Opus fmtp SDP line (`usedtx=1`). This mutates the
+  // outgoing SDP's audio m-section fmtp lines for the Opus payload type(s)
+  // found via the SDP itself (matches "opus" case-insensitively, same as the
+  // codec-preference filter in _applyAudioHints), adding/removing usedtx=1.
+  _mungeDtx(sdp) {
+    if (!sdp) return sdp;
+    const lines = sdp.split('\r\n');
+    const opusPts = new Set();
+    for (const line of lines) {
+      const m = /^a=rtpmap:(\d+)\s+opus\//i.exec(line);
+      if (m) opusPts.add(m[1]);
+    }
+    if (!opusPts.size) return sdp;
+    const out = lines.map(line => {
+      const m = /^a=fmtp:(\d+)\s+(.*)$/.exec(line);
+      if (!m || !opusPts.has(m[1])) return line;
+      const params = m[2].split(';').map(p => p.trim()).filter(p => p && !/^usedtx=/i.test(p));
+      if (this.dtx) params.push('usedtx=1');
+      return 'a=fmtp:' + m[1] + ' ' + params.join(';');
+    });
+    return out.join('\r\n');
+  }
+
   _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;
-        // Opus inband-FEC + DTX: lower bitrate use under silence, better recovery on packet loss.
-        // Reduces the chance of fallback to TURN-relay on flaky direct UDP paths.
+        // Opus bitrate ladder: real per-tier target set via setAudioQuality(),
+        // applied here through the actual RTCRtpSender.setParameters() call.
+        p.encodings[0].maxBitrate = this._targetBitrate || OPUS_BITRATE_LADDER[DEFAULT_AUDIO_QUALITY];
         p.encodings[0].priority = 'high';
         s.setParameters(p).catch(() => {});
       });
@@ -634,7 +739,7 @@ export class VoiceSession extends EventTarget {
     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));
+      pc.createOffer({ iceRestart: true }).then(o => { o.sdp = this._mungeDtx(o.sdp); return pc.setLocalDescription(o).then(() => this._publishSignal(peerPubkey, 'offer', o)); }).catch(() => this._closePeer(peerPubkey));
     } else { this._closePeer(peerPubkey); this._scheduleReconnect(peerPubkey, peer.failCount); }
   }
 
@@ -654,7 +759,7 @@ export class VoiceSession extends EventTarget {
       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);
+      const a = await pc.createAnswer(); a.sdp = this._mungeDtx(a.sdp); 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';