arnacon-webrtc-service 0.2.1 → 0.2.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "arnacon-webrtc-service",
-  "version": "0.2.1",
+  "version": "0.2.3",
   "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

@@ -118,6 +118,122 @@ class MidLifecyclePeerConnection extends FakePeerConnection {
     }
 }
 
+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;
+    }
+}
+
+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;
+    }
+}
+
 function deepLifecyclePrimitives() {
     const base = fakePrimitives();
     const callSdpUseCases = new CallSdpUseCases({
@@ -474,3 +590,241 @@ test("DEEP BUG REPRO: stale audio MID can fail during setLocalDescription", asyn
         "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",
+    );
+});
+
+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",
+    );
+});

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,55 @@ 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);
+    }
+
+    _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 (_) {}
@@ -262,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);
@@ -272,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.
@@ -297,20 +329,41 @@ 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 = {}) {
         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, this.session.localAudioTrack);
+        if (latestAudio) this._primeAudioTransceiver(latestAudio, track);
     }
 
     // The caller's client offered a ring and we are connected: ack it so the