arnacon-webrtc-service 0.2.5 → 0.2.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "arnacon-webrtc-service",
-  "version": "0.2.5",
+  "version": "0.2.7",
   "description": "Arnacon WebRTC core runtime and service modules",
   "main": "./webRTCservice/core.js",
   "type": "commonjs",

package/webRTCservice/modules/calls/poly/__tests__/WebRtcNegotiation.test.js

@@ -235,6 +235,15 @@ class MidMapLagPeerConnection extends FakePeerConnection {
     }
 }
 
+class MidMapLagTrackCreateFailsPeerConnection extends MidMapLagPeerConnection {
+    addTransceiver(kindOrTrack) {
+        if (kindOrTrack && typeof kindOrTrack === "object" && kindOrTrack.kind === "audio") {
+            throw new Error("Track already added");
+        }
+        return super.addTransceiver(kindOrTrack);
+    }
+}
+
 class CandidateMLineStrictPeerConnection extends FakePeerConnection {
     constructor(opts = {}) {
         super(opts);
@@ -260,9 +269,15 @@ class CandidateMLineStrictPeerConnection extends FakePeerConnection {
 class ParserMLineRecoveryPeerConnection extends FakePeerConnection {
     constructor(opts = {}) {
         super(opts);
+        const makeSender = () => ({
+            track: null,
+            async replaceTrack(nextTrack) {
+                this.track = nextTrack || null;
+            },
+        });
         this.transceivers = [
-            { kind: "application", mid: "0", setDirection() {}, sender: { replaceTrack: async () => {}, track: null } },
-            { kind: "audio", mid: "1", setDirection() {}, sender: { replaceTrack: async () => {}, track: null } },
+            { kind: "application", mid: "0", setDirection() {}, sender: makeSender() },
+            { kind: "audio", mid: "1", setDirection() {}, sender: makeSender() },
         ];
         this.failOnce = true;
     }
@@ -777,6 +792,43 @@ test("DEEP BUG REPRO: repeated decline/reuse can advance to mid=2 then mid=3", a
     );
 });
 
+test("DEEP BUG REPRO: recovery falls back to addTransceiver('audio') when addTransceiver(track) fails", async () => {
+    const signaling = new FakeSignaling();
+    const localTrack = { kind: "audio" };
+    const pc = new MidMapLagTrackCreateFailsPeerConnection({
+        initialAudioMid: "1",
+        answerSdp: "v=0\r\nm=audio 9 UDP/TLS/RTP/SAVPF 8\r\na=mid:2\r\na=sendrecv\r\n",
+    });
+    pc.transceivers.find((t) => t.kind === "audio").sender.track = localTrack;
+    const session = {
+        sessionId: "alice|bob|mid2-fallback",
+        callerEns: "alice.secnum.global",
+        toIdentity: "bob.secnum.global",
+        peerConnection: pc,
+        localAudioTrack: localTrack,
+    };
+    const neg = new WebRtcNegotiation({
+        id: "alice",
+        endpoint: "alice.secnum.global",
+        session,
+        signaling,
+        primitives: deepLifecyclePrimitives(),
+        logger: silentLogger,
+    });
+    const offerWithAudioMid2 =
+        "v=0\r\n" +
+        "a=group:BUNDLE 0 2\r\n" +
+        "m=application 9 UDP/DTLS/SCTP webrtc-datachannel\r\n" +
+        "a=mid:0\r\n" +
+        "m=audio 9 UDP/TLS/RTP/SAVPF 8\r\n" +
+        "a=mid:2\r\n" +
+        "a=sendrecv\r\n";
+    await assert.doesNotReject(
+        () => neg.applyOffer({ mode: "ring", payload: { sdp: offerWithAudioMid2 } }),
+        "mid recovery should succeed even if addTransceiver(track) fails on reused track",
+    );
+});
+
 test("DEEP MATRIX: createAnswer recovery handles missing mids 1/2/3", async () => {
     for (const mid of ["1", "2", "3"]) {
         const signaling = new FakeSignaling();

package/webRTCservice/modules/calls/poly/__tests__/WebRtcNegotiation.werift.integration.test.js

@@ -84,6 +84,37 @@ const inactiveEndCallOfferSdp =
     "a=rtcp-mux\r\n" +
     "a=rtpmap:8 PCMA/8000\r\n";
 
+const activeAudioOfferMid2Sdp =
+    "v=0\r\n" +
+    "o=- 83392955 0 IN IP4 0.0.0.0\r\n" +
+    "s=-\r\n" +
+    "t=0 0\r\n" +
+    "a=group:BUNDLE 0 2\r\n" +
+    "a=extmap-allow-mixed\r\n" +
+    "a=msid-semantic:WMS *\r\n" +
+    "m=application 9 UDP/DTLS/SCTP webrtc-datachannel\r\n" +
+    "c=IN IP4 0.0.0.0\r\n" +
+    "a=ice-ufrag:ddcb\r\n" +
+    "a=ice-pwd:701e83d2d6de10d14b0eea\r\n" +
+    "a=ice-options:trickle\r\n" +
+    "a=fingerprint:sha-256 F8:C4:0C:11:3F:96:C8:6A:48:A6:88:42:28:86:2B:9D:77:11:E2:75:65:DE:81:F5:7E:CA:B5:AB:0A:6B:64:F1\r\n" +
+    "a=setup:passive\r\n" +
+    "a=mid:0\r\n" +
+    "a=sctp-port:5000\r\n" +
+    "a=max-message-size:65536\r\n" +
+    "m=audio 9 UDP/TLS/RTP/SAVPF 8\r\n" +
+    "c=IN IP4 0.0.0.0\r\n" +
+    "a=ice-ufrag:ddcb\r\n" +
+    "a=ice-pwd:701e83d2d6de10d14b0eea\r\n" +
+    "a=ice-options:trickle\r\n" +
+    "a=fingerprint:sha-256 F8:C4:0C:11:3F:96:C8:6A:48:A6:88:42:28:86:2B:9D:77:11:E2:75:65:DE:81:F5:7E:CA:B5:AB:0A:6B:64:F1\r\n" +
+    "a=setup:passive\r\n" +
+    "a=sendrecv\r\n" +
+    "a=mid:2\r\n" +
+    "a=rtcp:9 IN IP4 0.0.0.0\r\n" +
+    "a=rtcp-mux\r\n" +
+    "a=rtpmap:8 PCMA/8000\r\n";
+
 const malformedAudioOfferSdp =
     "v=0\r\n" +
     "o=- 41053953 0 IN IP4 0.0.0.0\r\n" +
@@ -196,3 +227,29 @@ test("WERIFT REPLAY: ackEnd path then redial on same session", async () => {
         await harness.dispose();
     }
 });
+
+test("WERIFT REPLAY: decline/end then redial with audio mid=2 stays reusable", async () => {
+    const harness = buildWeriftNegotiationHarness({ withAudioTrack: true, withDataChannel: true });
+    try {
+        await assert.doesNotReject(() =>
+            harness.neg.applyOffer({
+                mode: "ring",
+                payload: { sdp: activeAudioOfferSdp, candidates: [candidateM0] },
+            }),
+        );
+        await assert.doesNotReject(() =>
+            harness.neg.endCall({
+                mode: "remote",
+                payload: { type: "offer", sdp: inactiveEndCallOfferSdp },
+            }),
+        );
+        await assert.doesNotReject(() =>
+            harness.neg.applyOffer({
+                mode: "ring",
+                payload: { sdp: activeAudioOfferMid2Sdp, candidates: [candidateM0] },
+            }),
+        );
+    } finally {
+        await harness.dispose();
+    }
+});

package/webRTCservice/modules/calls/poly/negotiation/WebRtcNegotiation.js

@@ -373,15 +373,23 @@ class WebRtcNegotiation extends CallNegotiationPort {
         // Final fallback: try creating/binding a fresh audio transceiver if the
         // implementation supports it.
         if (typeof pc.addTransceiver === "function") {
+            let created = null;
             try {
-                const created = track
+                created = track
                     ? pc.addTransceiver(track, { direction: "sendrecv" })
                     : pc.addTransceiver("audio", { direction: "sendrecv" });
-                if (created) {
-                    try { created.mid = offerMid; } catch (_) {}
-                    this._primeAudioTransceiver(created, track);
-                }
             } catch (_) {}
+            // Some stacks reject addTransceiver(track) when that track is already
+            // attached; retry with kind-only to still create the missing MID slot.
+            if (!created) {
+                try {
+                    created = pc.addTransceiver("audio", { direction: "sendrecv" });
+                } catch (_) {}
+            }
+            if (created) {
+                try { created.mid = offerMid; } catch (_) {}
+                this._primeAudioTransceiver(created, track);
+            }
         }
 
         if (!hasExactMid()) {

package/webRTCservice/modules/media/negotiation/SdpUtils.js

@@ -98,7 +98,8 @@ async function addIceCandidates(pc, candidates, RTCIceCandidate) {
         return (
             /m[-\s]?line not found/i.test(msg) ||
             /iceParams/i.test(msg) ||
-            /media section/i.test(msg)
+            /media section/i.test(msg) ||
+            /reading 'kind'/i.test(msg)
         );
     };
     for (const c of (candidates || [])) {

package/webRTCservice/webRTCmanager.js

@@ -1129,6 +1129,17 @@ function onPeerConnected(sessionId) {
     // No pending-bridge bookkeeping anymore — pairing is handled by the registry.
 }
 
+function isRecoverableOfferIngressError(err) {
+    const msg = String(err?.message || "");
+    return (
+        /Transceiver with mid=\d+ not found/i.test(msg) ||
+        /m[-\s]?line not found/i.test(msg) ||
+        /iceParams/i.test(msg) ||
+        /media section/i.test(msg) ||
+        /reading 'kind'/i.test(msg)
+    );
+}
+
 /**
  * Data channel ingress -> normalized leg events for the owning PolySession.
  * Replaces SignalingMessageRouter phase-gating (leg states gate instead).
@@ -1208,6 +1219,24 @@ function onDataChannelMessage(sessionId, rawMessage, meta = {}) {
     if (!event) return;
     const ref = polyWebrtcRef(poly, session, channelRole);
     poly.onIngress(ref, event).catch((err) => {
+        if (action === "offer" && isRecoverableOfferIngressError(err) && !payload.__polyIngressRetriedOnce) {
+            payload.__polyIngressRetriedOnce = true;
+            (async () => {
+                const latestSession = sessions.get(sessionId);
+                if (!latestSession) return;
+                const existing = polyForSession(latestSession);
+                if (existing) {
+                    await polyRegistry.destroy(
+                        polyRegistry.keyForPair(existing.legs.a.endpoint, existing.legs.b.endpoint),
+                        "offer-recover-reset",
+                    );
+                }
+                await onDcRing(sessionId, payload);
+            })().catch((retryErr) => {
+                console.error(`[${sessionId}] poly ingress (${action}) retry failed: ${retryErr.message}`);
+            });
+            return;
+        }
         console.error(`[${sessionId}] poly ingress (${action}) failed: ${err.message}`);
     });
 }