diff --git a/zebra-report/how-it-works.html b/zebra-report/how-it-works.html
index 81440a1..e3f055c 100644
--- a/zebra-report/how-it-works.html
+++ b/zebra-report/how-it-works.html
@@ -266,9 +266,9 @@
diff --git a/zebra-report/index.html b/zebra-report/index.html
index 840352a..c37ec31 100644
--- a/zebra-report/index.html
+++ b/zebra-report/index.html
@@ -1168,6 +1168,7 @@ function ensurePC() {
logLine('sys', 'codec preference: G.711/G.722 ahead of Opus (clean amplitude)');
}
} catch (_) {}
+ const selfPc = pc; /* snapshot so a superseded pc's late events are ignored */
pc.ontrack = (ev) => {
const stream = ev.streams[0] || new MediaStream([ev.track]);
attachInboundTrack(stream, ev.track.id);
@@ -1181,20 +1182,34 @@ function ensurePC() {
logLine('sys', `ice candidate: ${typ}${mdns}`);
};
pc.onconnectionstatechange = () => {
+ if (selfPc !== pc) return; /* event from a superseded pc — ignore */
const s = pc.connectionState;
rtcStatus.textContent = 'connection: ' + s;
if (s === 'connected') {
dotRtc.className = 'dot ok';
+ clearRtcRecover(); rtcReconnectTries = 0;
logLine('sys', 'webrtc connected');
announceHello().catch(() => {});
setTimeout(reportTransport, 1200);
- } else if (s === 'failed' || s === 'closed' || s === 'disconnected') {
+ } else if (s === 'disconnected') {
+ dotRtc.className = 'dot warn';
+ setPath('path: reconnecting…', null);
+ logLine('sys', 'webrtc disconnected — waiting for ICE to recover');
+ clearRtcRecover();
+ rtcRecoverTimer = setTimeout(attemptRtcRestart, 5000); /* often self-heals */
+ } else if (s === 'failed') {
+ dotRtc.className = 'dot warn';
+ setPath('path: reconnecting…', null);
+ logLine('sys', 'webrtc failed — restarting ICE');
+ attemptRtcRestart();
+ } else if (s === 'closed') {
dotRtc.className = 'dot';
+ clearRtcRecover();
setPath('path: not connected', null);
- logLine('err', `webrtc ${s} — click "reset connection" then retry`);
}
};
pc.oniceconnectionstatechange = () => {
+ if (selfPc !== pc) return;
rtcStatus.textContent = 'ice: ' + pc.iceConnectionState;
};
return pc;
@@ -1233,6 +1248,7 @@ async function reportTransport() {
function resetConnection() {
if (typeof disconnectRelay === 'function') disconnectRelay();
+ clearRtcRecover(); rtcReconnectTries = 0;
if (pc) {
try { pc.close(); } catch (_) {}
pc = null;
@@ -1288,6 +1304,10 @@ const SIGNAL_SALT = new TextEncoder().encode('zebra-signal-v1');
let relayWS = null;
let relayRole = null;
let relayKey = null;
+let relayWantOpen = false; /* true from connect until the user disconnects */
+let relayReconnectTimer = null; /* auto-rejoin the signaling socket if it drops */
+let rtcRecoverTimer = null; /* grace timer before forcing an ICE restart */
+let rtcReconnectTries = 0;
async function deriveSignalRoom(code) {
const h = await crypto.subtle.digest('SHA-256',
@@ -1313,13 +1333,35 @@ async function relaySendSDP(kind, desc) {
const ct = await aesEncrypt(relayKey, JSON.stringify(desc));
relaySend({ type: 'sdp', kind, data: b64(ct) });
}
-async function relayMakeOffer() {
+async function relayMakeOffer(iceRestart = false) {
ensurePC();
- const off = await pc.createOffer();
+ const off = await pc.createOffer(iceRestart ? { iceRestart: true } : undefined);
await pc.setLocalDescription(off);
await waitForIceGathering(pc);
await relaySendSDP('offer', pc.localDescription);
- relaySet('offer sent — waiting for answer', 'ok');
+ relaySet(iceRestart ? 'reconnecting — new offer sent' : 'offer sent — waiting for answer', 'ok');
+}
+/* Relay-path ICE recovery. A transient blip drops us to 'disconnected' (usually
+ * self-heals) or 'failed' (needs an ICE restart). The offerer owns restarts so
+ * the two sides don't both re-offer at once (glare); the answerer waits for the
+ * new offer to arrive over the relay and answers it on its existing pc. */
+function clearRtcRecover() { if (rtcRecoverTimer) { clearTimeout(rtcRecoverTimer); rtcRecoverTimer = null; } }
+async function attemptRtcRestart() {
+ clearRtcRecover();
+ if (!pc || pc.connectionState === 'connected') { rtcReconnectTries = 0; return; }
+ if (!relayWS || relayWS.readyState !== WebSocket.OPEN) return; /* WS rejoin re-offers */
+ if (relayRole !== 'offerer') { relaySet('reconnecting — waiting for peer'); return; }
+ if (rtcReconnectTries >= 6) { relaySet('reconnect failed — click "reset" then retry', 'err'); return; }
+ rtcReconnectTries++;
+ try {
+ await refreshTurnCred();
+ if (pc.setConfiguration) { try { pc.setConfiguration(rtcConfig); } catch (_) {} }
+ await relayMakeOffer(true);
+ logLine('sys', `ice restart attempt ${rtcReconnectTries}`);
+ } catch (e) { logLine('err', 'ice restart failed: ' + e.message); }
+ if (!pc || pc.connectionState !== 'connected') {
+ rtcRecoverTimer = setTimeout(attemptRtcRestart, Math.min(2000 * rtcReconnectTries, 10000));
+ }
}
async function onRelaySDP(kind, descJSON) {
const desc = JSON.parse(descJSON);
@@ -1354,54 +1396,69 @@ async function connectRelay() {
try {
relayKey = await deriveSignalKey(code);
const room = await deriveSignalRoom(code);
+ relayWantOpen = true;
relaySet('connecting to relay…');
- relayWS = new WebSocket(SIGNAL_URL + '?room=' + encodeURIComponent(room));
- relayWS.onopen = () => {
- $('dot-relay').className = 'dot ok';
- $('btn-relay-connect').disabled = true;
- $('btn-relay-disconnect').disabled = false;
- logLine('sys', 'relay connected — waiting for peer');
- };
- relayWS.onclose = () => {
- $('dot-relay').className = 'dot warn';
- $('btn-relay-connect').disabled = false;
- $('btn-relay-disconnect').disabled = true;
- if (relayWS) relaySet('relay disconnected');
- relayWS = null; relayRole = null;
- };
- relayWS.onerror = () => relaySet('relay connection error', 'err');
- relayWS.onmessage = async (ev) => {
- let m; try { m = JSON.parse(ev.data); } catch (_) { return; }
- if (m.type === 'welcome') {
- relayRole = m.role;
- relaySet(`in room as ${m.role} — ${m.peers} peer(s) present`);
- logLine('sys', `relay role: ${m.role} (${m.peers} present)`);
- if (relayRole === 'offerer' && m.peers >= 2) await relayMakeOffer();
- } else if (m.type === 'peer-joined') {
- logLine('sys', 'peer joined the room');
- if (relayRole === 'offerer') await relayMakeOffer();
- } else if (m.type === 'peer-left') {
- logLine('sys', 'peer left the room');
- relaySet('peer left — waiting for a peer');
- } else if (m.type === 'sdp') {
- try {
- const pt = await aesDecrypt(relayKey, unb64(m.data));
- await onRelaySDP(m.kind, pt);
- } catch (e) {
- logLine('err', 'relay sdp failed (wrong code?): ' + e.message);
- relaySet('sdp exchange failed — codes must match', 'err');
- }
- } else if (m.type === 'error') {
- relaySet('relay: ' + m.message, 'err');
- logLine('err', 'relay: ' + m.message);
- }
- };
+ openRelaySocket(room);
} catch (e) {
relaySet('connect failed: ' + e.message, 'err');
if (relayWS) { try { relayWS.close(); } catch (_) {} relayWS = null; }
}
}
+function openRelaySocket(room) {
+ relayWS = new WebSocket(SIGNAL_URL + '?room=' + encodeURIComponent(room));
+ relayWS.onopen = () => {
+ $('dot-relay').className = 'dot ok';
+ $('btn-relay-connect').disabled = true;
+ $('btn-relay-disconnect').disabled = false;
+ logLine('sys', 'relay connected — waiting for peer');
+ };
+ relayWS.onclose = () => {
+ $('dot-relay').className = 'dot warn';
+ relayWS = null; relayRole = null;
+ if (relayWantOpen) {
+ $('btn-relay-disconnect').disabled = false;
+ relaySet('relay dropped — reconnecting…');
+ if (relayReconnectTimer) clearTimeout(relayReconnectTimer);
+ relayReconnectTimer = setTimeout(() => { if (relayWantOpen) openRelaySocket(room); }, 1500);
+ } else {
+ $('btn-relay-connect').disabled = false;
+ $('btn-relay-disconnect').disabled = true;
+ relaySet('relay disconnected');
+ }
+ };
+ relayWS.onerror = () => relaySet('relay connection error', 'err');
+ relayWS.onmessage = async (ev) => {
+ let m; try { m = JSON.parse(ev.data); } catch (_) { return; }
+ if (m.type === 'welcome') {
+ relayRole = m.role;
+ relaySet(`in room as ${m.role} — ${m.peers} peer(s) present`);
+ logLine('sys', `relay role: ${m.role} (${m.peers} present)`);
+ /* pc already exists ⇒ this is a re-join after a drop: ICE-restart offer */
+ if (relayRole === 'offerer' && m.peers >= 2) await relayMakeOffer(!!pc);
+ } else if (m.type === 'peer-joined') {
+ logLine('sys', 'peer joined the room');
+ if (relayRole === 'offerer') await relayMakeOffer(!!pc);
+ } else if (m.type === 'peer-left') {
+ logLine('sys', 'peer left the room');
+ relaySet('peer left — waiting for a peer');
+ } else if (m.type === 'sdp') {
+ try {
+ const pt = await aesDecrypt(relayKey, unb64(m.data));
+ await onRelaySDP(m.kind, pt);
+ } catch (e) {
+ logLine('err', 'relay sdp failed (wrong code?): ' + e.message);
+ relaySet('sdp exchange failed — codes must match', 'err');
+ }
+ } else if (m.type === 'error') {
+ relaySet('relay: ' + m.message, 'err');
+ logLine('err', 'relay: ' + m.message);
+ }
+ };
+}
function disconnectRelay() {
+ relayWantOpen = false;
+ if (relayReconnectTimer) { clearTimeout(relayReconnectTimer); relayReconnectTimer = null; }
+ clearRtcRecover();
if (relayWS) { const w = relayWS; relayWS = null; try { w.close(); } catch (_) {} }
$('dot-relay').className = 'dot warn';
$('btn-relay-connect').disabled = false;
@@ -1591,9 +1648,9 @@ logLine('sys', 'chat content lives in encrypted SRTP audio. no IP packets carry
})();