arnacon-webrtc-service 0.2.2 → 0.2.4

package/package.json

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

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

@@ -6,6 +6,8 @@ const {
     transportOpenA,
     transportOpenB,
     aOffers,
+    bOffers,
+    aAnswers,
     bAnswers,
     bRejects,
     aEnds,
@@ -92,3 +94,81 @@ test("B ends -> clean teardown -> both reusable", async () => {
     await aCompletesEnd(ctx, "end-answer-a");
     expectEnded(ctx);
 });
+
+test("long reuse soak: repeated decline/end cycles stay reusable and reconnect cleanly", async () => {
+    const ctx = buildWebRtcScenario();
+    await transportOpenA(ctx);
+    await transportOpenB(ctx);
+
+    const rounds = 8;
+    for (let i = 1; i <= rounds; i += 1) {
+        await aOffers(ctx, `offer-${i}`);
+        if (i % 2 === 0) {
+            await bRejects(ctx);
+            expectLegStates(ctx, S.ENDING, S.REJECTED);
+            await aCompletesEnd(ctx, `end-answer-${i}`);
+        } else {
+            await bAnswers(ctx, `answer-${i}`);
+            expectInCall(ctx);
+            await aEnds(ctx);
+            expectLegStates(ctx, S.CONNECTED, S.ENDING);
+            await bCompletesEnd(ctx, `end-answer-${i}`);
+        }
+        expectReusable(ctx);
+    }
+
+    await aOffers(ctx, "final-offer");
+    await bAnswers(ctx, "final-answer");
+    expectInCall(ctx);
+    // Odd rounds establish media before ending (4 times for rounds=8), then one
+    // final successful call at the end => 5 total connect operations.
+    const expectedConnects = Math.ceil(rounds / 2) + 1;
+    expectMediaDisconnected(ctx, Math.ceil(rounds / 2));
+    if (ctx.media.connects.length !== expectedConnects) {
+        throw new Error(`expected ${expectedConnects} media connects, got ${ctx.media.connects.length}`);
+    }
+});
+
+test("glare after reuse converges and still tears down cleanly", async () => {
+    const ctx = buildWebRtcScenario();
+    await transportOpenA(ctx);
+    await transportOpenB(ctx);
+
+    await aOffers(ctx, "offer-1");
+    await bRejects(ctx);
+    await aCompletesEnd(ctx, "end-answer-1");
+    expectReusable(ctx);
+
+    await Promise.all([
+        aOffers(ctx, "offer-glare-a"),
+        bOffers(ctx, "offer-glare-b"),
+    ]);
+    await aAnswers(ctx, "answer-glare-a");
+    await bAnswers(ctx, "answer-glare-b");
+    expectInCall(ctx);
+
+    await bEnds(ctx);
+    await aCompletesEnd(ctx, "end-answer-glare");
+    expectEnded(ctx);
+});
+
+test("double-end race then immediate redial does not leak teardown state", async () => {
+    const ctx = buildWebRtcScenario();
+    await transportOpenA(ctx);
+    await transportOpenB(ctx);
+    await aOffers(ctx, "offer-1");
+    await bAnswers(ctx, "answer-1");
+    expectInCall(ctx);
+
+    await Promise.all([aEnds(ctx), bEnds(ctx)]);
+    await Promise.all([
+        aCompletesEnd(ctx, "end-answer-a"),
+        bCompletesEnd(ctx, "end-answer-b"),
+    ]);
+    expectReusable(ctx);
+    expectMediaDisconnected(ctx, 1);
+
+    await aOffers(ctx, "offer-2");
+    await bAnswers(ctx, "answer-2");
+    expectInCall(ctx);
+});

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();
@@ -163,6 +164,99 @@ class DuplicateTrackOnRecoveryPeerConnection extends FakePeerConnection {
     }
 }
 
+class MidMapLagPeerConnection extends FakePeerConnection {
+    constructor({ initialAudioMid = "1", ...opts } = {}) {
+        super(opts);
+        this.transceivers = [
+            { kind: "application", mid: "0", setDirection() {}, sender: { replaceTrack: async () => {} } },
+            { kind: "audio", mid: initialAudioMid, setDirection() {}, sender: { replaceTrack: async () => {}, track: null } },
+        ];
+        this.acceptedAudioMids = new Set([String(initialAudioMid)]);
+        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).trim();
+        }
+        return null;
+    }
+
+    addTrack(track) {
+        const audio = this.transceivers.find((t) => t.kind === "audio");
+        if (audio?.sender) audio.sender.track = track;
+        return { kind: track?.kind || "audio" };
+    }
+
+    addTransceiver(kindOrTrack) {
+        const isAudio = kindOrTrack === "audio" || kindOrTrack?.kind === "audio";
+        if (!isAudio) return null;
+        const existingNumericMids = this.transceivers
+            .map((t) => Number.parseInt(String(t.mid ?? ""), 10))
+            .filter((n) => Number.isFinite(n));
+        const nextMid = String(existingNumericMids.length ? Math.max(...existingNumericMids) + 1 : 1);
+        const created = {
+            kind: "audio",
+            setDirection() {},
+            sender: { replaceTrack: async () => {}, track: kindOrTrack?.kind === "audio" ? kindOrTrack : null },
+        };
+        let currentMid = nextMid;
+        Object.defineProperty(created, "mid", {
+            get() {
+                return currentMid;
+            },
+            set: (newMid) => {
+                const normalized = String(newMid ?? "").trim();
+                if (normalized === currentMid) return;
+                this.acceptedAudioMids.delete(currentMid);
+                currentMid = normalized;
+                if (currentMid) this.acceptedAudioMids.add(currentMid);
+            },
+            enumerable: true,
+            configurable: true,
+        });
+        this.transceivers.push(created);
+        this.acceptedAudioMids.add(nextMid);
+        return created;
+    }
+
+    async setRemoteDescription(d) {
+        if (d?.type === "offer") {
+            this._remoteOfferAudioMid = this._extractAudioMid(d?.sdp || "");
+            if (this._remoteOfferAudioMid && !this.acceptedAudioMids.has(this._remoteOfferAudioMid)) {
+                throw new Error(`Transceiver with mid=${this._remoteOfferAudioMid} not found`);
+            }
+        }
+        this.remoteDescription = d;
+    }
+}
+
+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);
+    }
+}
+
 function deepLifecyclePrimitives() {
     const base = fakePrimitives();
     const callSdpUseCases = new CallSdpUseCases({
@@ -179,6 +273,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);
+                }
+            }),
     };
 }
 
@@ -558,3 +658,245 @@ test("DEEP BUG REPRO: recovery must not throw when local track is already bound"
         "recovery should tolerate already-bound tracks and continue",
     );
 });
+
+test("DEEP BUG REPRO: mid=2 map-lag recovers via forced transceiver create", async () => {
+    const signaling = new FakeSignaling();
+    const localTrack = { kind: "audio" };
+    const pc = new MidMapLagPeerConnection({
+        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",
+        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 } }),
+        "recovery should survive mid=2 drift where transceiver maps lag behind exposed mids",
+    );
+});
+
+test("DEEP BUG REPRO: repeated decline/reuse can advance to mid=2 then mid=3", async () => {
+    const signaling = new FakeSignaling();
+    const localTrack = { kind: "audio" };
+    const pc = new MidMapLagPeerConnection({
+        initialAudioMid: "1",
+        answerSdp: "v=0\r\nm=audio 9 UDP/TLS/RTP/SAVPF 8\r\na=mid:3\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 offerMid2 =
+        "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";
+    const offerMid3 =
+        "v=0\r\n" +
+        "a=group:BUNDLE 0 3\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:3\r\n" +
+        "a=sendrecv\r\n";
+
+    await assert.doesNotReject(
+        () => neg.applyOffer({ mode: "ring", payload: { sdp: offerMid2 } }),
+        "first reuse cycle should recover from mid=2 mismatch",
+    );
+    await assert.doesNotReject(
+        () => neg.applyOffer({ mode: "ring", payload: { sdp: offerMid3 } }),
+        "second reuse cycle should recover from mid=3 mismatch",
+    );
+});
+
+test("DEEP MATRIX: createAnswer recovery handles missing mids 1/2/3", async () => {
+    for (const mid of ["1", "2", "3"]) {
+        const signaling = new FakeSignaling();
+        const session = {
+            sessionId: `alice|bob|create|${mid}`,
+            callerEns: "alice.secnum.global",
+            toIdentity: "bob.secnum.global",
+            peerConnection: new MidLifecyclePeerConnection({
+                throwOn: "createAnswer",
+                audioMid: "9",
+                answerSdp: `v=0\r\nm=audio 9 UDP/TLS/RTP/SAVPF 8\r\na=mid:${mid}\r\na=sendrecv\r\n`,
+            }),
+            localAudioTrack: null,
+        };
+        const neg = new WebRtcNegotiation({
+            id: "alice",
+            endpoint: "alice.secnum.global",
+            session,
+            signaling,
+            primitives: deepLifecyclePrimitives(),
+            logger: silentLogger,
+        });
+        const offer =
+            "v=0\r\n" +
+            `a=group:BUNDLE 0 ${mid}\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:${mid}\r\n` +
+            "a=sendrecv\r\n";
+        await assert.doesNotReject(
+            () => neg.applyOffer({ mode: "ring", payload: { sdp: offer } }),
+            `createAnswer recovery should handle missing mid=${mid}`,
+        );
+    }
+});
+
+test("DEEP MATRIX: setLocalDescription recovery handles missing mids 1/2/3", async () => {
+    for (const mid of ["1", "2", "3"]) {
+        const signaling = new FakeSignaling();
+        const session = {
+            sessionId: `alice|bob|setlocal|${mid}`,
+            callerEns: "alice.secnum.global",
+            toIdentity: "bob.secnum.global",
+            peerConnection: new MidLifecyclePeerConnection({
+                throwOn: "setLocalDescription",
+                audioMid: "9",
+                answerSdp: `v=0\r\nm=audio 9 UDP/TLS/RTP/SAVPF 8\r\na=mid:${mid}\r\na=sendrecv\r\n`,
+            }),
+            localAudioTrack: null,
+        };
+        const neg = new WebRtcNegotiation({
+            id: "alice",
+            endpoint: "alice.secnum.global",
+            session,
+            signaling,
+            primitives: deepLifecyclePrimitives(),
+            logger: silentLogger,
+        });
+        const offer =
+            "v=0\r\n" +
+            `a=group:BUNDLE 0 ${mid}\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:${mid}\r\n` +
+            "a=sendrecv\r\n";
+        await assert.doesNotReject(
+            () => neg.applyOffer({ mode: "ring", payload: { sdp: offer } }),
+            `setLocalDescription recovery should handle missing mid=${mid}`,
+        );
+    }
+});
+
+test("DEEP BUG REPRO: ice-restart after reuse survives stale mid map", async () => {
+    const signaling = new FakeSignaling();
+    const session = {
+        sessionId: "alice|bob|icerestart",
+        callerEns: "alice.secnum.global",
+        toIdentity: "bob.secnum.global",
+        peerConnection: new MidLifecyclePeerConnection({
+            throwOn: "setLocalDescription",
+            audioMid: "9",
+            answerSdp: "v=0\r\nm=audio 9 UDP/TLS/RTP/SAVPF 8\r\na=mid:2\r\na=sendrecv\r\n",
+        }),
+        localAudioTrack: { kind: "audio" },
+    };
+    const neg = new WebRtcNegotiation({
+        id: "alice",
+        endpoint: "alice.secnum.global",
+        session,
+        signaling,
+        primitives: deepLifecyclePrimitives(),
+        logger: silentLogger,
+    });
+    const restartOffer =
+        "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: "ice-restart", payload: { sdp: restartOffer } }),
+        "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);
+});

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

@@ -178,18 +178,7 @@ class WebRtcNegotiation extends CallNegotiationPort {
             offerSdp = this.p.patchInactiveToSendrecv(offerSdp);
         }
         if (!isIceRestart) this._ensureAudioReadyForOffer(offerSdp, pc);
-        try {
-            await pc.setRemoteDescription(new this.p.RTCSessionDescription(offerSdp, "offer"));
-        } catch (err) {
-            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;
-            }
-        }
+        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.
@@ -197,19 +186,7 @@ class WebRtcNegotiation extends CallNegotiationPort {
             this.p.ensureLocalAudioTrack(this.session, pc, this.id);
         }
         const label = isIceRestart ? "ICE-RESTART ANSWER SDP" : "ANSWER SDP";
-        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;
-            }
-        }
+        const answerSdp = await this._createAnswerWithRecovery(pc, offerSdp, label);
         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
@@ -254,6 +231,44 @@ class WebRtcNegotiation extends CallNegotiationPort {
         return /Transceiver with mid=\d+ not found/i.test(msg);
     }
 
+    _extractMissingMidFromError(err) {
+        const msg = String(err?.message || "");
+        const mid = msg.match(/Transceiver with mid=(\d+) not found/i)?.[1];
+        return mid || null;
+    }
+
+    async _setRemoteOfferWithRecovery(pc, offerSdp) {
+        let forceCreate = false;
+        for (let attempt = 0; attempt < 3; attempt += 1) {
+            try {
+                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 });
+                forceCreate = true;
+                if (attempt === 2) throw err;
+            }
+        }
+    }
+
+    async _createAnswerWithRecovery(pc, offerSdp, label) {
+        let forceCreate = false;
+        for (let attempt = 0; attempt < 3; attempt += 1) {
+            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 });
+                forceCreate = true;
+                if (attempt === 2) throw err;
+            }
+        }
+        return undefined;
+    }
+
     _isTrackAlreadyAddedError(err) {
         const msg = String(err?.message || "");
         return /Track already added/i.test(msg);
@@ -273,9 +288,11 @@ class WebRtcNegotiation extends CallNegotiationPort {
         try { transceiver.sender?.replaceTrack?.(track); } catch (_) {}
     }
 
-    _repairAudioForOfferMid(sdp, pc) {
+    _repairAudioForOfferMid(sdp, pc, opts = {}) {
         this._ensureAudioReadyForOffer(sdp, pc, { force: true });
-        const offerMid = this._offerAudioMid(sdp);
+        const offerMid = String(opts.preferredMid || this._offerAudioMid(sdp) || "").trim() || null;
+        const forceCreate = opts.forceCreate === true;
+        const preferredFromError = String(opts.preferredMid || "").trim() || null;
         const track = this.session.localAudioTrack || null;
         const audioTransceivers = pc.getTransceivers?.().filter((t) => t.kind === "audio") || [];
         for (const transceiver of audioTransceivers) this._primeAudioTransceiver(transceiver, track);
@@ -283,17 +300,21 @@ class WebRtcNegotiation extends CallNegotiationPort {
 
         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() && !forceCreate) return;
+
+        // If the stack explicitly reported a missing MID, prefer creating/syncing that
+        // MID before retagging existing transceivers. Some implementations keep an
+        // internal MID map that lags behind exposed transceiver.mid changes.
+        const canRetagExisting = !preferredFromError;
+        if (canRetagExisting) {
+            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() && !forceCreate) return;
         }
-        if (hasExactMid()) return;
 
         // Final fallback: try creating/binding a fresh audio transceiver if the
         // implementation supports it.
@@ -308,6 +329,16 @@ class WebRtcNegotiation extends CallNegotiationPort {
                 }
             } catch (_) {}
         }
+
+        if (!hasExactMid()) {
+            const candidate =
+                (pc.getTransceivers?.().find((t) => t.kind === "audio" && (t.mid == null || t.mid === ""))) ||
+                (pc.getTransceivers?.().find((t) => t.kind === "audio")) ||
+                null;
+            if (candidate && String(candidate.mid || "") !== offerMid) {
+                try { candidate.mid = offerMid; } catch (_) {}
+            }
+        }
     }
 
     _ensureAudioReadyForOffer(sdp, pc, opts = {}) {

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

@@ -93,10 +93,20 @@ 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);
+    };
     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;