arnacon-webrtc-service 0.2.0 → 0.2.2

package/package.json

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

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

@@ -3,6 +3,7 @@ const assert = require("node:assert/strict");
 
 const { WebRtcNegotiation } = require("../negotiation/WebRtcNegotiation");
 const { FakeSignaling, FakePeerConnection, fakePrimitives, silentLogger } = require("./fakes");
+const { CallSdpUseCases } = require("../../useCases/CallSdpUseCases");
 
 function build({ offerSdp, answerSdp } = {}) {
     const signaling = new FakeSignaling();
@@ -54,6 +55,133 @@ class MidStrictPeerConnection extends FakePeerConnection {
     }
 }
 
+class MidLifecyclePeerConnection extends FakePeerConnection {
+    constructor({ throwOn = "none", audioMid = "2", ...opts } = {}) {
+        super(opts);
+        this.throwOn = throwOn;
+        this.transceivers = [
+            { kind: "application", mid: "0", setDirection() {}, sender: { replaceTrack: async () => {} } },
+            { kind: "audio", mid: audioMid, setDirection() {}, sender: { replaceTrack: async () => {} } },
+        ];
+        this._remoteOfferAudioMid = null;
+    }
+
+    _extractAudioMid(sdp = "") {
+        const sections = String(sdp).split(/\r?\nm=/);
+        for (const rawSection of sections) {
+            const section = rawSection.startsWith("m=") ? rawSection : `m=${rawSection}`;
+            if (!/^m=audio\b/m.test(section)) continue;
+            const mid = section.match(/^a=mid:([^\r\n]+)/m)?.[1];
+            if (mid) return mid;
+        }
+        return null;
+    }
+
+    _hasTransceiverMid(mid) {
+        if (!mid) return true;
+        return this.transceivers.some((t) => String(t.mid) === String(mid));
+    }
+
+    addTrack(track) {
+        // Simulate a stale transceiver map on reused sessions: addTrack does not
+        // necessarily repair a wrong/missing negotiated MID binding.
+        return { kind: track?.kind || "audio" };
+    }
+
+    async setRemoteDescription(d) {
+        if (d?.type === "offer") {
+            this._remoteOfferAudioMid = this._extractAudioMid(d?.sdp || "");
+        }
+        this.remoteDescription = d;
+    }
+
+    async createAnswer() {
+        if (
+            this.throwOn === "createAnswer" &&
+            this._remoteOfferAudioMid &&
+            !this._hasTransceiverMid(this._remoteOfferAudioMid)
+        ) {
+            throw new Error(`Transceiver with mid=${this._remoteOfferAudioMid} not found`);
+        }
+        return { type: "answer", sdp: this._answerSdp };
+    }
+
+    async setLocalDescription(d) {
+        if (
+            this.throwOn === "setLocalDescription" &&
+            this._remoteOfferAudioMid &&
+            !this._hasTransceiverMid(this._remoteOfferAudioMid)
+        ) {
+            throw new Error(`Transceiver with mid=${this._remoteOfferAudioMid} not found`);
+        }
+        this.localDescription = d;
+    }
+}
+
+class DuplicateTrackOnRecoveryPeerConnection extends FakePeerConnection {
+    constructor({ audioMid = "2", ...opts } = {}) {
+        super(opts);
+        this.transceivers = [
+            { kind: "application", mid: "0", setDirection() {}, sender: { replaceTrack: async () => {} } },
+            { kind: "audio", mid: audioMid, setDirection() {}, sender: { replaceTrack: async () => {}, track: null } },
+        ];
+        this._remoteOfferAudioMid = null;
+    }
+
+    _extractAudioMid(sdp = "") {
+        const sections = String(sdp).split(/\r?\nm=/);
+        for (const rawSection of sections) {
+            const section = rawSection.startsWith("m=") ? rawSection : `m=${rawSection}`;
+            if (!/^m=audio\b/m.test(section)) continue;
+            const mid = section.match(/^a=mid:([^\r\n]+)/m)?.[1];
+            if (mid) return String(mid);
+        }
+        return null;
+    }
+
+    _hasAudioMid(mid) {
+        return this.transceivers.some((t) => t.kind === "audio" && String(t.mid || "") === String(mid || ""));
+    }
+
+    addTrack(track) {
+        const audio = this.transceivers.find((t) => t.kind === "audio");
+        if (audio?.sender?.track === track) {
+            throw new Error("Track already added");
+        }
+        if (audio?.sender) audio.sender.track = track;
+        return { kind: track?.kind || "audio" };
+    }
+
+    async setRemoteDescription(d) {
+        if (d?.type === "offer") {
+            this._remoteOfferAudioMid = this._extractAudioMid(d?.sdp || "");
+            if (this._remoteOfferAudioMid && !this._hasAudioMid(this._remoteOfferAudioMid)) {
+                throw new Error(`Transceiver with mid=${this._remoteOfferAudioMid} not found`);
+            }
+        }
+        this.remoteDescription = d;
+    }
+}
+
+function deepLifecyclePrimitives() {
+    const base = fakePrimitives();
+    const callSdpUseCases = new CallSdpUseCases({
+        sessions: new Map(),
+        MediaStreamTrack: base.MediaStreamTrack,
+        patchInactiveToSendrecv: base.patchInactiveToSendrecv,
+        logSdp: () => {},
+        enqueueSignaling: (_sessionId, _label, fn) => Promise.resolve().then(fn),
+        sendDataChannelMessage: () => {},
+        callRuntime: null,
+        logger: silentLogger,
+    });
+    return {
+        ...base,
+        ensureLocalAudioTrack: (...args) => callSdpUseCases.ensureLocalAudioTrack(...args),
+        createAnswerSdp: (...args) => callSdpUseCases.createAnswerSdp(...args),
+    };
+}
+
 test("ring sends a signaling offer with the caller's bare label", async () => {
     const { neg, signaling } = build();
     await neg.ring({ from: "alice.secnum.global" });
@@ -317,3 +445,116 @@ test("BUG REPRO: redial offer after end/reuse must not fail on mid mismatch", as
         "redial offer should recover from transceiver mismatch instead of wedging",
     );
 });
+
+test("DEEP BUG REPRO: stale audio MID can fail during createAnswer (not only setRemoteDescription)", async () => {
+    const signaling = new FakeSignaling();
+    const session = {
+        sessionId: "alice|bob",
+        callerEns: "alice.secnum.global",
+        toIdentity: "bob.secnum.global",
+        peerConnection: new MidLifecyclePeerConnection({
+            throwOn: "createAnswer",
+            audioMid: "2", // stale vs incoming offer's mid=1
+            answerSdp: "v=0\r\nm=audio 9 UDP/TLS/RTP/SAVPF 8\r\na=mid:1\r\na=sendrecv\r\n",
+        }),
+        localAudioTrack: null,
+    };
+    const neg = new WebRtcNegotiation({
+        id: "alice",
+        endpoint: "alice.secnum.global",
+        session,
+        signaling,
+        primitives: deepLifecyclePrimitives(),
+        logger: silentLogger,
+    });
+
+    const redialOfferWithAudioMid =
+        "v=0\r\n" +
+        "a=group:BUNDLE 0 1\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:1\r\n" +
+        "a=sendrecv\r\n";
+
+    await assert.doesNotReject(
+        () => neg.applyOffer({ mode: "ring", payload: { sdp: redialOfferWithAudioMid } }),
+        "redial offer should not wedge even when MID mismatch surfaces at createAnswer time",
+    );
+});
+
+test("DEEP BUG REPRO: stale audio MID can fail during setLocalDescription", async () => {
+    const signaling = new FakeSignaling();
+    const session = {
+        sessionId: "alice|bob",
+        callerEns: "alice.secnum.global",
+        toIdentity: "bob.secnum.global",
+        peerConnection: new MidLifecyclePeerConnection({
+            throwOn: "setLocalDescription",
+            audioMid: "2", // stale vs incoming offer's mid=1
+            answerSdp: "v=0\r\nm=audio 9 UDP/TLS/RTP/SAVPF 8\r\na=mid:1\r\na=sendrecv\r\n",
+        }),
+        localAudioTrack: null,
+    };
+    const neg = new WebRtcNegotiation({
+        id: "alice",
+        endpoint: "alice.secnum.global",
+        session,
+        signaling,
+        primitives: deepLifecyclePrimitives(),
+        logger: silentLogger,
+    });
+
+    const redialOfferWithAudioMid =
+        "v=0\r\n" +
+        "a=group:BUNDLE 0 1\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:1\r\n" +
+        "a=sendrecv\r\n";
+
+    await assert.doesNotReject(
+        () => neg.applyOffer({ mode: "ring", payload: { sdp: redialOfferWithAudioMid } }),
+        "redial offer should not wedge even when MID mismatch surfaces at setLocalDescription time",
+    );
+});
+
+test("DEEP BUG REPRO: recovery must not throw when local track is already bound", async () => {
+    const signaling = new FakeSignaling();
+    const localTrack = { kind: "audio" };
+    const pc = new DuplicateTrackOnRecoveryPeerConnection({
+        audioMid: "2",
+        answerSdp: "v=0\r\nm=audio 9 UDP/TLS/RTP/SAVPF 8\r\na=mid:1\r\na=sendrecv\r\n",
+    });
+    pc.transceivers.find((t) => t.kind === "audio").sender.track = localTrack;
+    const session = {
+        sessionId: "alice|bob",
+        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 redialOfferWithAudioMid =
+        "v=0\r\n" +
+        "a=group:BUNDLE 0 1\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:1\r\n" +
+        "a=sendrecv\r\n";
+
+    await assert.doesNotReject(
+        () => neg.applyOffer({ mode: "ring", payload: { sdp: redialOfferWithAudioMid } }),
+        "recovery should tolerate already-bound tracks and continue",
+    );
+});

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

@@ -181,9 +181,10 @@ class WebRtcNegotiation extends CallNegotiationPort {
         try {
             await pc.setRemoteDescription(new this.p.RTCSessionDescription(offerSdp, "offer"));
         } catch (err) {
-            if (!isIceRestart && this._isMissingMidError(err) && this._offerHasAudioMLine(offerSdp)) {
-                // Recovery for reused sessions that retained DC but lost local m=audio mapping.
-                this._ensureAudioReadyForOffer(offerSdp, pc, { force: true });
+            if (this._isMissingMidError(err) && this._offerHasAudioMLine(offerSdp)) {
+                // Recovery for reused sessions that retained DC but drifted the audio MID
+                // mapping after end/reuse renegotiations.
+                this._repairAudioForOfferMid(offerSdp, pc);
                 await pc.setRemoteDescription(new this.p.RTCSessionDescription(offerSdp, "offer"));
             } else {
                 throw err;
@@ -196,7 +197,19 @@ class WebRtcNegotiation extends CallNegotiationPort {
             this.p.ensureLocalAudioTrack(this.session, pc, this.id);
         }
         const label = isIceRestart ? "ICE-RESTART ANSWER SDP" : "ANSWER SDP";
-        const answerSdp = await this.p.createAnswerSdp(pc, this.id, label);
+        let answerSdp;
+        try {
+            answerSdp = await this.p.createAnswerSdp(pc, this.id, label);
+        } catch (err) {
+            if (this._isMissingMidError(err) && this._offerHasAudioMLine(offerSdp)) {
+                // Some stacks surface the same MID mismatch only when generating/applying
+                // the local answer, not on setRemoteDescription.
+                this._repairAudioForOfferMid(offerSdp, pc);
+                answerSdp = await this.p.createAnswerSdp(pc, this.id, label);
+            } else {
+                throw err;
+            }
+        }
         this.session.lastAnswerSdp = answerSdp;
         // In-call renegotiation (ICE restart) answers immediately. For a fresh
         // ring we hold the answer: the caller must not see "connected" until the
@@ -225,21 +238,101 @@ class WebRtcNegotiation extends CallNegotiationPort {
         return /\bm=audio\b/.test(sdp);
     }
 
+    _offerAudioMid(sdp = "") {
+        const sections = String(sdp).split(/\r?\nm=/);
+        for (const rawSection of sections) {
+            const section = rawSection.startsWith("m=") ? rawSection : `m=${rawSection}`;
+            if (!/^m=audio\b/m.test(section)) continue;
+            const mid = section.match(/^a=mid:([^\r\n]+)/m)?.[1];
+            if (mid) return String(mid).trim();
+        }
+        return null;
+    }
+
     _isMissingMidError(err) {
         const msg = String(err?.message || "");
         return /Transceiver with mid=\d+ not found/i.test(msg);
     }
 
+    _isTrackAlreadyAddedError(err) {
+        const msg = String(err?.message || "");
+        return /Track already added/i.test(msg);
+    }
+
+    _isTrackBoundToAudioTransceiver(pc, track) {
+        if (!track) return false;
+        const audioTransceivers = pc.getTransceivers?.().filter((t) => t.kind === "audio") || [];
+        return audioTransceivers.some((t) => t?.sender?.track === track);
+    }
+
+    _primeAudioTransceiver(transceiver, track) {
+        if (!transceiver) return;
+        try { transceiver.setDirection?.("sendrecv"); } catch (_) {}
+        if (!track) return;
+        try { transceiver.sender?.registerTrack?.(track); } catch (_) {}
+        try { transceiver.sender?.replaceTrack?.(track); } catch (_) {}
+    }
+
+    _repairAudioForOfferMid(sdp, pc) {
+        this._ensureAudioReadyForOffer(sdp, pc, { force: true });
+        const offerMid = this._offerAudioMid(sdp);
+        const track = this.session.localAudioTrack || null;
+        const audioTransceivers = pc.getTransceivers?.().filter((t) => t.kind === "audio") || [];
+        for (const transceiver of audioTransceivers) this._primeAudioTransceiver(transceiver, track);
+        if (!offerMid || audioTransceivers.length === 0) return;
+
+        const hasExactMid = () =>
+            (pc.getTransceivers?.().some((t) => t.kind === "audio" && String(t.mid || "") === offerMid) ?? false);
+        if (hasExactMid()) return;
+
+        // Best-effort realignment for reused PCs: if we have one audio transceiver but
+        // its MID drifted, align it to the current offer's audio MID.
+        const candidate =
+            audioTransceivers.find((t) => t.mid == null || t.mid === "") ||
+            audioTransceivers[0];
+        if (candidate && String(candidate.mid || "") !== offerMid) {
+            try { candidate.mid = offerMid; } catch (_) {}
+        }
+        if (hasExactMid()) return;
+
+        // Final fallback: try creating/binding a fresh audio transceiver if the
+        // implementation supports it.
+        if (typeof pc.addTransceiver === "function") {
+            try {
+                const created = track
+                    ? pc.addTransceiver(track, { direction: "sendrecv" })
+                    : pc.addTransceiver("audio", { direction: "sendrecv" });
+                if (created) {
+                    try { created.mid = offerMid; } catch (_) {}
+                    this._primeAudioTransceiver(created, track);
+                }
+            } catch (_) {}
+        }
+    }
+
     _ensureAudioReadyForOffer(sdp, pc, opts = {}) {
         if (!this._offerHasAudioMLine(sdp)) return;
         const force = opts.force === true;
         const audioTransceiver = pc.getTransceivers?.().find((t) => t.kind === "audio");
-        if (audioTransceiver && !force) return;
+        if (audioTransceiver && !force) {
+            this._primeAudioTransceiver(audioTransceiver, this.session.localAudioTrack || null);
+            return;
+        }
 
         if (!this.session.localAudioTrack) {
             this.session.localAudioTrack = new this.MediaStreamTrack({ kind: "audio" });
         }
-        pc.addTrack?.(this.session.localAudioTrack);
+        const track = this.session.localAudioTrack;
+        const alreadyBound = this._isTrackBoundToAudioTransceiver(pc, track);
+        if (!alreadyBound && typeof pc.addTrack === "function") {
+            try {
+                pc.addTrack(track);
+            } catch (err) {
+                if (!this._isTrackAlreadyAddedError(err)) throw err;
+            }
+        }
+        const latestAudio = pc.getTransceivers?.().find((t) => t.kind === "audio");
+        if (latestAudio) this._primeAudioTransceiver(latestAudio, track);
     }
 
     // The caller's client offered a ring and we are connected: ack it so the