arnacon-webrtc-service 0.2.3 → 0.2.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "arnacon-webrtc-service",
-  "version": "0.2.3",
+  "version": "0.2.5",
   "description": "Arnacon WebRTC core runtime and service modules",
   "main": "./webRTCservice/core.js",
   "type": "commonjs",
@@ -23,6 +23,8 @@
   "scripts": {
     "test": "npm run test:poly",
     "test:poly": "node --test webRTCservice/modules/calls/poly/__tests__/*.test.js",
+    "test:werift": "node --test --test-concurrency=1 webRTCservice/modules/calls/poly/__tests__/WebRtcNegotiation.werift.integration.test.js",
+    "test:poly:all": "npm run test:poly && npm run test:werift",
     "test:scenarios": "node --test webRTCservice/modules/calls/poly/__tests__/Scenarios.test.js",
     "build": "node webRTCservice/build.js",
     "clean": "node webRTCservice/clean.js",

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

@@ -4,6 +4,7 @@ const assert = require("node:assert/strict");
 const { WebRtcNegotiation } = require("../negotiation/WebRtcNegotiation");
 const { FakeSignaling, FakePeerConnection, fakePrimitives, silentLogger } = require("./fakes");
 const { CallSdpUseCases } = require("../../useCases/CallSdpUseCases");
+const { addIceCandidates: addIceCandidatesUtil } = require("../../../media/negotiation/SdpUtils");
 
 function build({ offerSdp, answerSdp } = {}) {
     const signaling = new FakeSignaling();
@@ -234,6 +235,56 @@ class MidMapLagPeerConnection extends FakePeerConnection {
     }
 }
 
+class CandidateMLineStrictPeerConnection extends FakePeerConnection {
+    constructor(opts = {}) {
+        super(opts);
+        this._remoteMLineCount = 0;
+        this.appliedCandidates = [];
+    }
+
+    async setRemoteDescription(d) {
+        this.remoteDescription = d;
+        const sdp = String(d?.sdp || "");
+        this._remoteMLineCount = (sdp.match(/^m=/gm) || []).length;
+    }
+
+    async addIceCandidate(candidate) {
+        const idx = Number(candidate?.sdpMLineIndex);
+        if (Number.isFinite(idx) && (idx < 0 || idx >= this._remoteMLineCount)) {
+            throw new Error("m line not found");
+        }
+        this.appliedCandidates.push(candidate);
+    }
+}
+
+class ParserMLineRecoveryPeerConnection extends FakePeerConnection {
+    constructor(opts = {}) {
+        super(opts);
+        this.transceivers = [
+            { kind: "application", mid: "0", setDirection() {}, sender: { replaceTrack: async () => {}, track: null } },
+            { kind: "audio", mid: "1", setDirection() {}, sender: { replaceTrack: async () => {}, track: null } },
+        ];
+        this.failOnce = true;
+    }
+
+    addTrack(track) {
+        const audio = this.transceivers.find((t) => t.kind === "audio");
+        if (audio?.sender) audio.sender.track = track;
+        return { kind: track?.kind || "audio" };
+    }
+
+    async setRemoteDescription(d) {
+        const sdp = String(d?.sdp || "");
+        const hasAudio = /^m=audio\b/m.test(sdp);
+        const audio = this.transceivers.find((t) => t.kind === "audio");
+        if (!hasAudio && this.failOnce && audio?.sender?.track) {
+            this.failOnce = false;
+            throw new Error("Cannot read properties of undefined (reading 'iceParams')");
+        }
+        this.remoteDescription = d;
+    }
+}
+
 function deepLifecyclePrimitives() {
     const base = fakePrimitives();
     const callSdpUseCases = new CallSdpUseCases({
@@ -250,6 +301,12 @@ function deepLifecyclePrimitives() {
         ...base,
         ensureLocalAudioTrack: (...args) => callSdpUseCases.ensureLocalAudioTrack(...args),
         createAnswerSdp: (...args) => callSdpUseCases.createAnswerSdp(...args),
+        addIceCandidates: (...args) =>
+            addIceCandidatesUtil(...args, class RTCIceCandidate {
+                constructor(init = {}) {
+                    Object.assign(this, init);
+                }
+            }),
     };
 }
 
@@ -828,3 +885,81 @@ test("DEEP BUG REPRO: ice-restart after reuse survives stale mid map", async ()
         "ice-restart path should recover from stale reused mid mappings",
     );
 });
+
+test("DEEP BUG REPRO: applyOffer ignores stale ICE candidate m-line mismatch", async () => {
+    const signaling = new FakeSignaling();
+    const pc = new CandidateMLineStrictPeerConnection({
+        answerSdp: "v=0\r\nm=application 9 UDP/DTLS/SCTP webrtc-datachannel\r\na=mid:0\r\n",
+    });
+    const session = {
+        sessionId: "alice|bob|mline",
+        callerEns: "alice.secnum.global",
+        toIdentity: "bob.secnum.global",
+        peerConnection: pc,
+        localAudioTrack: { kind: "audio" },
+    };
+    const neg = new WebRtcNegotiation({
+        id: "alice",
+        endpoint: "alice.secnum.global",
+        session,
+        signaling,
+        primitives: deepLifecyclePrimitives(),
+        logger: silentLogger,
+    });
+    const dataOnlyOffer =
+        "v=0\r\n" +
+        "a=group:BUNDLE 0\r\n" +
+        "m=application 9 UDP/DTLS/SCTP webrtc-datachannel\r\n" +
+        "a=mid:0\r\n";
+    await assert.doesNotReject(
+        () =>
+            neg.applyOffer({
+                mode: "ring",
+                payload: {
+                    sdp: dataOnlyOffer,
+                    candidates: [
+                        { candidate: "candidate:1 1 udp 1 1.1.1.1 11111 typ host", sdpMid: "0", sdpMLineIndex: 0 },
+                        { candidate: "candidate:2 1 udp 1 2.2.2.2 22222 typ host", sdpMid: "1", sdpMLineIndex: 1 },
+                    ],
+                },
+            }),
+        "stale candidate with missing m-line must be ignored instead of failing offer ingress",
+    );
+    assert.equal(pc.appliedCandidates.length, 1, "valid candidate should still be applied");
+    assert.equal(pc.appliedCandidates[0].sdpMLineIndex, 0);
+});
+
+test("DEEP BUG REPRO: parser m-line failure realigns on data-only offer", async () => {
+    const signaling = new FakeSignaling();
+    const localTrack = { kind: "audio" };
+    const pc = new ParserMLineRecoveryPeerConnection({
+        answerSdp: "v=0\r\nm=application 9 UDP/DTLS/SCTP webrtc-datachannel\r\na=mid:0\r\n",
+    });
+    pc.transceivers.find((t) => t.kind === "audio").sender.track = localTrack;
+    const session = {
+        sessionId: "alice|bob|parser-mline",
+        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 dataOnlyOffer =
+        "v=0\r\n" +
+        "a=group:BUNDLE 0\r\n" +
+        "m=application 9 UDP/DTLS/SCTP webrtc-datachannel\r\n" +
+        "a=mid:0\r\n";
+
+    await assert.doesNotReject(
+        () => neg.applyOffer({ mode: "ring", payload: { sdp: dataOnlyOffer } }),
+        "parser-style m-line failures should realign and recover on data-only offers",
+    );
+    assert.equal(pc.transceivers.find((t) => t.kind === "audio")?.sender?.track, null);
+});

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

@@ -0,0 +1,198 @@
+const { test } = require("node:test");
+const assert = require("node:assert/strict");
+
+const { buildWeriftNegotiationHarness } = require("./helpers/weriftHarness");
+
+const dataOnlyOfferSdp =
+    "v=0\r\n" +
+    "o=- 5832931903811073529 2 IN IP4 127.0.0.1\r\n" +
+    "s=-\r\n" +
+    "t=0 0\r\n" +
+    "a=group:BUNDLE 0\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:57EQ\r\n" +
+    "a=ice-pwd:JQGLYFDLhxBWo6r5hauNiYkM\r\n" +
+    "a=ice-options:trickle renomination\r\n" +
+    "a=fingerprint:sha-256 D9:5A:99:6F:F1:81:12:49:04:97:BC:76:96:D4:EE:C9:B5:27:4B:D6:8C:A4:68:8E:CF:27:D1:DC:90:96:3A:42\r\n" +
+    "a=setup:actpass\r\n" +
+    "a=mid:0\r\n" +
+    "a=sctp-port:5000\r\n" +
+    "a=max-message-size:262144\r\n";
+
+const activeAudioOfferSdp =
+    "v=0\r\n" +
+    "o=- 41053953 0 IN IP4 0.0.0.0\r\n" +
+    "s=-\r\n" +
+    "t=0 0\r\n" +
+    "a=group:BUNDLE 0 1\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:d0a8\r\n" +
+    "a=ice-pwd:5dc2124050d8b131def772\r\n" +
+    "a=ice-options:trickle\r\n" +
+    "a=fingerprint:sha-256 6A:1B:8B:C4:EF:AE:BF:48:9E:52:B6:B9:E7:86:5E:CC:1A:74:C6:1E:0E:5C:7C:89:66:EA:D5:D7:E7:23:FE:B7\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:d0a8\r\n" +
+    "a=ice-pwd:5dc2124050d8b131def772\r\n" +
+    "a=ice-options:trickle\r\n" +
+    "a=fingerprint:sha-256 6A:1B:8B:C4:EF:AE:BF:48:9E:52:B6:B9:E7:86:5E:CC:1A:74:C6:1E:0E:5C:7C:89:66:EA:D5:D7:E7:23:FE:B7\r\n" +
+    "a=setup:passive\r\n" +
+    "a=sendrecv\r\n" +
+    "a=mid:1\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 inactiveEndCallOfferSdp =
+    "v=0\r\n" +
+    "o=- 12159584 0 IN IP4 0.0.0.0\r\n" +
+    "s=-\r\n" +
+    "t=0 0\r\n" +
+    "a=group:BUNDLE 0 1\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:5377\r\n" +
+    "a=ice-pwd:ab5d1f31727880b2875978\r\n" +
+    "a=ice-options:trickle\r\n" +
+    "a=fingerprint:sha-256 6A:1B:8B:C4:EF:AE:BF:48:9E:52:B6:B9:E7:86:5E:CC:1A:74:C6:1E:0E:5C:7C:89:66:EA:D5:D7:E7:23:FE:B7\r\n" +
+    "a=setup:active\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:5377\r\n" +
+    "a=ice-pwd:ab5d1f31727880b2875978\r\n" +
+    "a=ice-options:trickle\r\n" +
+    "a=fingerprint:sha-256 6A:1B:8B:C4:EF:AE:BF:48:9E:52:B6:B9:E7:86:5E:CC:1A:74:C6:1E:0E:5C:7C:89:66:EA:D5:D7:E7:23:FE:B7\r\n" +
+    "a=setup:active\r\n" +
+    "a=inactive\r\n" +
+    "a=mid:1\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" +
+    "s=-\r\n" +
+    "t=0 0\r\n" +
+    "a=group:BUNDLE 0 1\r\n" +
+    "m=application 9 UDP/DTLS/SCTP webrtc-datachannel\r\n" +
+    "c=IN IP4 0.0.0.0\r\n" +
+    "a=mid:0\r\n" +
+    "a=sctp-port:5000\r\n" +
+    "m=audio 9 UDP/TLS/RTP/SAVPF 8\r\n" +
+    "c=IN IP4 0.0.0.0\r\n" +
+    "a=sendrecv\r\n" +
+    "a=mid:1\r\n" +
+    "a=rtpmap:8 PCMA/8000\r\n";
+
+const candidateM0 = {
+    sdpMLineIndex: 0,
+    sdpMid: "0",
+    candidate: "candidate:3054239307 1 udp 41820927 134.209.88.4 50878 typ relay raddr 0.0.0.0 rport 0 generation 0 ufrag 57EQ network-id 7 network-cost 900",
+};
+
+const candidateM1Stale = {
+    sdpMLineIndex: 1,
+    sdpMid: "1",
+    candidate: "candidate:123456789 1 udp 41819903 10.0.0.10 20002 typ host generation 0 ufrag dead network-id 1",
+};
+
+test("WERIFT REPLAY: data-only offer with stale m-line candidate does not fail ingress", async () => {
+    const harness = buildWeriftNegotiationHarness({ withAudioTrack: true, withDataChannel: true });
+    try {
+        await assert.doesNotReject(() =>
+            harness.neg.applyOffer({
+                mode: "ring",
+                payload: {
+                    sdp: dataOnlyOfferSdp,
+                    candidates: [candidateM0, candidateM1Stale],
+                },
+            }),
+        );
+        assert.match(String(harness.session.lastAnswerSdp || ""), /m=application/i);
+    } finally {
+        await harness.dispose();
+    }
+});
+
+test("WERIFT REPLAY: baseline malformed offer reproduces werift parser rejection", async () => {
+    const harness = buildWeriftNegotiationHarness({ withAudioTrack: true, withDataChannel: true });
+    try {
+        await assert.rejects(
+            () =>
+                harness.neg.applyOffer({
+                    mode: "ring",
+                    payload: { sdp: malformedAudioOfferSdp, candidates: [candidateM0] },
+                }),
+            /iceParams|media section/i,
+        );
+    } finally {
+        await harness.dispose();
+    }
+});
+
+test("WERIFT REPLAY: end-call remote offer then redial on reused session", 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: activeAudioOfferSdp, candidates: [candidateM0] },
+            }),
+        );
+    } finally {
+        await harness.dispose();
+    }
+});
+
+test("WERIFT REPLAY: ackEnd path then redial on same session", 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.ackEnd({
+                payload: { sdp: inactiveEndCallOfferSdp },
+            }),
+        );
+        await assert.doesNotReject(() =>
+            harness.neg.applyOffer({
+                mode: "ring",
+                payload: { sdp: activeAudioOfferSdp, candidates: [candidateM0] },
+            }),
+        );
+    } finally {
+        await harness.dispose();
+    }
+});

package/webRTCservice/modules/calls/poly/__tests__/helpers/weriftHarness.js

@@ -0,0 +1,125 @@
+const { WebRtcNegotiation } = require("../../negotiation/WebRtcNegotiation");
+const { CallSdpUseCases } = require("../../../useCases/CallSdpUseCases");
+const { applyPolyfills } = require("../../../../media/werift/Polyfills");
+const {
+    fixSdpForWerift,
+    waitForIceGathering,
+    formatIceCandidates,
+    getRelayCandidates,
+    embedCandidatesInSdp,
+    patchInactiveToSendrecv,
+    logSdp,
+    addIceCandidates: addIceCandidatesUtil,
+} = require("../../../../media/negotiation/SdpUtils");
+const { narrowAudioOfferForCodecPolicy } = require("../../../../media/negotiation/SdpCodecNegotiator");
+
+const silentLogger = { log() {}, warn() {}, error() {} };
+
+function ensureWeriftPolyfills() {
+    if (globalThis.__polyWeriftTestPolyfillsApplied) return;
+    applyPolyfills({ fixSdpForWerift, logger: silentLogger });
+    globalThis.__polyWeriftTestPolyfillsApplied = true;
+}
+
+function createSignalingRecorder() {
+    return {
+        sent: [],
+        send(message) {
+            this.sent.push(message);
+        },
+        isOpen() {
+            return true;
+        },
+        lastOfType(msgType, action) {
+            return [...this.sent].reverse().find(
+                (m) => m.msgType === msgType && (action === undefined || m.action === action || m.payload?.type === action),
+            );
+        },
+    };
+}
+
+function createProductionLikePrimitives({ sessionMap, logger = silentLogger } = {}) {
+    const callSdpUseCases = new CallSdpUseCases({
+        sessions: sessionMap,
+        MediaStreamTrack: globalThis.MediaStreamTrack,
+        patchInactiveToSendrecv,
+        logSdp: (_id, _label, _sdp) => {},
+        enqueueSignaling: (_sessionId, _label, fn) => Promise.resolve().then(fn),
+        sendDataChannelMessage: () => {},
+        callRuntime: null,
+        logger,
+    });
+    return {
+        RTCSessionDescription: globalThis.RTCSessionDescription,
+        MediaStreamTrack: globalThis.MediaStreamTrack,
+        waitForIceGathering,
+        formatIceCandidates,
+        getRelayCandidates,
+        embedCandidatesInSdp,
+        patchInactiveToSendrecv,
+        narrowAudioOfferForCodecPolicy,
+        logSdp: (...args) => logSdp(...args, logger),
+        addIceCandidates: (...args) => addIceCandidatesUtil(...args, globalThis.RTCIceCandidate),
+        ensureLocalAudioTrack: (...args) => callSdpUseCases.ensureLocalAudioTrack(...args),
+        createAnswerSdp: (...args) => callSdpUseCases.createAnswerSdp(...args),
+    };
+}
+
+function buildWeriftNegotiationHarness({
+    id = "alice",
+    endpoint = "alice.secnum.global",
+    sessionId = "alice|bob",
+    callerEns = "alice.secnum.global",
+    toIdentity = "bob.secnum.global",
+    withDataChannel = true,
+    withAudioTrack = true,
+} = {}) {
+    ensureWeriftPolyfills();
+    const sessionMap = new Map();
+    const pc = new globalThis.RTCPeerConnection({ iceServers: [] });
+    if (withDataChannel && typeof pc.createDataChannel === "function") {
+        pc.createDataChannel("chat");
+    }
+
+    const session = {
+        sessionId,
+        callerEns,
+        toIdentity,
+        peerConnection: pc,
+        localAudioTrack: null,
+        remoteTracks: [],
+        iceCandidates: [],
+    };
+    if (withAudioTrack) {
+        session.localAudioTrack = new globalThis.MediaStreamTrack({ kind: "audio" });
+        if (typeof pc.addTrack === "function") {
+            pc.addTrack(session.localAudioTrack);
+        }
+    }
+
+    sessionMap.set(sessionId, session);
+    const signaling = createSignalingRecorder();
+    const primitives = createProductionLikePrimitives({ sessionMap });
+    const neg = new WebRtcNegotiation({
+        id,
+        endpoint,
+        session,
+        signaling,
+        primitives,
+        logger: silentLogger,
+    });
+
+    const dispose = async () => {
+        try { pc.close(); } catch (_) {}
+    };
+
+    return { neg, session, signaling, primitives, pc, dispose };
+}
+
+module.exports = {
+    buildWeriftNegotiationHarness,
+    ensureWeriftPolyfills,
+    createProductionLikePrimitives,
+    createSignalingRecorder,
+    silentLogger,
+};

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

@@ -177,12 +177,13 @@ class WebRtcNegotiation extends CallNegotiationPort {
         if (audioDirection(offerSdp) === "inactive" && this.p.patchInactiveToSendrecv) {
             offerSdp = this.p.patchInactiveToSendrecv(offerSdp);
         }
-        if (!isIceRestart) this._ensureAudioReadyForOffer(offerSdp, pc);
+        const offerHasAudio = this._offerHasAudioMLine(offerSdp);
+        if (!isIceRestart && offerHasAudio) this._ensureAudioReadyForOffer(offerSdp, pc);
         await this._setRemoteOfferWithRecovery(pc, offerSdp);
         await this.p.addIceCandidates?.(pc, payload.candidates || []);
         // On ICE restart the track set is unchanged; only the caller-ring path
         // needs to (re)attach the local audio track.
-        if (!isIceRestart && this.p.ensureLocalAudioTrack) {
+        if (!isIceRestart && offerHasAudio && this.p.ensureLocalAudioTrack) {
             this.p.ensureLocalAudioTrack(this.session, pc, this.id);
         }
         const label = isIceRestart ? "ICE-RESTART ANSWER SDP" : "ANSWER SDP";
@@ -231,6 +232,47 @@ class WebRtcNegotiation extends CallNegotiationPort {
         return /Transceiver with mid=\d+ not found/i.test(msg);
     }
 
+    _isMLineOrParserMappingError(err) {
+        const msg = String(err?.message || "");
+        return (
+            /m[-\s]?line not found/i.test(msg) ||
+            /iceParams/i.test(msg) ||
+            /media section/i.test(msg)
+        );
+    }
+
+    _offerMediaSections(sdp = "") {
+        const out = [];
+        const parts = String(sdp).split(/\r?\nm=/);
+        for (let i = 0; i < parts.length; i += 1) {
+            const section = i === 0 ? parts[i] : `m=${parts[i]}`;
+            if (!/^m=/m.test(section)) continue;
+            const kind = section.match(/^m=([^\s]+)/m)?.[1] || null;
+            const mid = section.match(/^a=mid:([^\r\n]+)/m)?.[1] || null;
+            out.push({ kind, mid: mid ? String(mid).trim() : null, raw: section });
+        }
+        return out;
+    }
+
+    _alignTransceiversToOffer(pc, sdp) {
+        const sections = this._offerMediaSections(sdp);
+        const hasAudio = sections.some((s) => s.kind === "audio");
+        const audioOfferMids = new Set(
+            sections
+                .filter((s) => s.kind === "audio" && s.mid)
+                .map((s) => String(s.mid)),
+        );
+        const audioTransceivers = pc.getTransceivers?.().filter((t) => t.kind === "audio") || [];
+        if (!audioTransceivers.length) return;
+        for (const transceiver of audioTransceivers) {
+            const currentMid = String(transceiver?.mid || "").trim();
+            const midIsOffered = currentMid && audioOfferMids.has(currentMid);
+            if (hasAudio && midIsOffered) continue;
+            try { transceiver.setDirection?.("inactive"); } catch (_) {}
+            try { transceiver.sender?.replaceTrack?.(null); } catch (_) {}
+        }
+    }
+
     _extractMissingMidFromError(err) {
         const msg = String(err?.message || "");
         const mid = msg.match(/Transceiver with mid=(\d+) not found/i)?.[1];
@@ -244,9 +286,15 @@ class WebRtcNegotiation extends CallNegotiationPort {
                 await pc.setRemoteDescription(new this.p.RTCSessionDescription(offerSdp, "offer"));
                 return;
             } catch (err) {
-                if (!this._isMissingMidError(err) || !this._offerHasAudioMLine(offerSdp)) throw err;
-                const missingMid = this._extractMissingMidFromError(err);
-                this._repairAudioForOfferMid(offerSdp, pc, { preferredMid: missingMid, forceCreate });
+                const hasAudio = this._offerHasAudioMLine(offerSdp);
+                const isMissingMid = this._isMissingMidError(err);
+                const isParserMapping = this._isMLineOrParserMappingError(err);
+                if (!isMissingMid && !isParserMapping) throw err;
+                this._alignTransceiversToOffer(pc, offerSdp);
+                if (hasAudio) {
+                    const missingMid = this._extractMissingMidFromError(err);
+                    this._repairAudioForOfferMid(offerSdp, pc, { preferredMid: missingMid, forceCreate });
+                }
                 forceCreate = true;
                 if (attempt === 2) throw err;
             }
@@ -259,9 +307,15 @@ class WebRtcNegotiation extends CallNegotiationPort {
             try {
                 return await this.p.createAnswerSdp(pc, this.id, label);
             } catch (err) {
-                if (!this._isMissingMidError(err) || !this._offerHasAudioMLine(offerSdp)) throw err;
-                const missingMid = this._extractMissingMidFromError(err);
-                this._repairAudioForOfferMid(offerSdp, pc, { preferredMid: missingMid, forceCreate });
+                const hasAudio = this._offerHasAudioMLine(offerSdp);
+                const isMissingMid = this._isMissingMidError(err);
+                const isParserMapping = this._isMLineOrParserMappingError(err);
+                if (!isMissingMid && !isParserMapping) throw err;
+                this._alignTransceiversToOffer(pc, offerSdp);
+                if (hasAudio) {
+                    const missingMid = this._extractMissingMidFromError(err);
+                    this._repairAudioForOfferMid(offerSdp, pc, { preferredMid: missingMid, forceCreate });
+                }
                 forceCreate = true;
                 if (attempt === 2) throw err;
             }

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

@@ -93,10 +93,24 @@ function logSdp(sessionId, label, sdp, logger = console) {
 
 async function addIceCandidates(pc, candidates, RTCIceCandidate) {
     let added = 0;
+    const isMLineMismatch = (err) => {
+        const msg = String(err?.message || "");
+        return (
+            /m[-\s]?line not found/i.test(msg) ||
+            /iceParams/i.test(msg) ||
+            /media section/i.test(msg)
+        );
+    };
     for (const c of (candidates || [])) {
         if (c && c.candidate) {
-            await pc.addIceCandidate(new RTCIceCandidate(c));
-            added++;
+            try {
+                await pc.addIceCandidate(new RTCIceCandidate(c));
+                added++;
+            } catch (err) {
+                // Reused sessions can receive stale trickle candidates that refer to
+                // an m-line no longer present in the latest negotiated SDP.
+                if (!isMLineMismatch(err)) throw err;
+            }
         }
     }
     return added;