arnacon-webrtc-service 0.2.8 → 0.2.10

package/package.json

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

package/services/secnum.json

@@ -3,7 +3,7 @@
     "providerId": "secnum",
     "static": {
       "status": "active",
-      "domains": ["secnumtest.global", "secnum.global", "cellactm.global", "cellactl.global"],
+      "domains": ["secnumtest.global", "secnum.global"],
       "trustedIngressIps": ["51.85.90.127"],
       "outboundSbcAddress": "185.62.121.10",
       "minuteLimitSeconds": 600
@@ -13,7 +13,10 @@
     "providerId": "secnum",
     "static": {
       "status": "active",
-      "domains": ["secnum.global", "secnumtest.global", "cellactm.global", "cellactl.global"],
+      "domains": [
+        "secnumtest.global",
+        "secnum.global"
+      ],
       "trustedIngressIps": ["51.85.90.127"],
       "outboundSbcAddress": "185.62.121.10",
       "minuteLimitSeconds": 600

package/webRTCservice/modules/calls/inbound/InboundCallFlow.js

@@ -1,14 +1,7 @@
 const { buildOfferPayload, serializeNotifyPayload } = require("../../participants/signaling/SignalingEnvelope");
-
-function identityLabel(identity) {
-    if (!identity || typeof identity !== "string") return identity;
-    const trimmed = identity.trim();
-    const atPos = trimmed.indexOf("@");
-    if (atPos > 0) return trimmed.slice(0, atPos);
-    const dotPos = trimmed.indexOf(".");
-    if (dotPos > 0) return trimmed.slice(0, dotPos);
-    return trimmed;
-}
+const {
+    identityLabel,
+} = require("../../runtime/CallPairRef");
 
 function createInboundCallFlow({
     createSession,

package/webRTCservice/modules/calls/poly/PolyIngress.js

@@ -36,6 +36,9 @@ class PolyIngress {
     // (payload.type for signaling, msg.action for call messages, or "bye").
     toLegEvent(action, payload = {}, meta = {}) {
         if (action === "offer") {
+            if (meta.forceOffer === true) {
+                return makeLegEvent(LEG_EVENTS.OFFER, payload, meta);
+            }
             const type = isInactiveOffer(payload.sdp) ? LEG_EVENTS.END_RENEGOTIATION : LEG_EVENTS.OFFER;
             return makeLegEvent(type, payload, meta);
         }

package/webRTCservice/modules/calls/poly/PolySession.js

@@ -8,6 +8,7 @@
 const { reconcile } = require("./ReconcileRules");
 const { LEG_INTENTS } = require("./ports");
 const { LEG_STATES, isActiveCall } = require("./states");
+const { identityLabel } = require("../../runtime/CallPairRef");
 
 const MAX_RECONCILE_PASSES = 50;
 
@@ -22,6 +23,11 @@ const FAIL_ON_ERROR_INTENTS = new Set([
     LEG_INTENTS.ACK_CONNECTED,
     LEG_INTENTS.ACK_RING,
 ]);
+const RETRY_ON_NO_OPEN_DC_INTENTS = new Set([
+    LEG_INTENTS.RING,
+    LEG_INTENTS.ACK_CONNECTED,
+    LEG_INTENTS.ACK_RING,
+]);
 
 class PolySession {
     constructor({ id, legA, legB, mediaController, rules = reconcile, teardownHooks = [], logger = console } = {}) {
@@ -35,6 +41,16 @@ class PolySession {
         // billing). Kept as a list so callers compose without subclassing.
         this._teardownHooks = teardownHooks.filter((h) => typeof h === "function");
         this._teardownRan = false;
+        // Call-lifecycle hooks, fired on the active<->inactive edge derived from leg
+        // states (a call is "active" while either leg isActiveCall). This is the
+        // single robust seam for per-call side-effects that must bracket the call
+        // itself -- NOT the poly's disposal -- so they fire once per call on EVERY
+        // end path (hangup either side, mid-call failure, transport drop, reject)
+        // and again on a reused poly's next call. Used for minute-counter
+        // start/finish so billing always stops regardless of how the call ends.
+        this._onCallStart = null;
+        this._onCallEnd = null;
+        this._callActive = false;
         this.logger = logger;
 
         this.mediaHandle = null;
@@ -56,8 +72,14 @@ class PolySession {
     }
 
     legByEndpoint(endpoint) {
-        if (this.legs.a.endpoint === endpoint || this.legs.a.id === endpoint) return this.legs.a;
-        if (this.legs.b.endpoint === endpoint || this.legs.b.id === endpoint) return this.legs.b;
+        const wanted = identityLabel(String(endpoint || "").toLowerCase());
+        if (!wanted) return null;
+        const aEndpoint = identityLabel(String(this.legs.a.endpoint || "").toLowerCase());
+        const aId = identityLabel(String(this.legs.a.id || "").toLowerCase());
+        if (aEndpoint === wanted || aId === wanted) return this.legs.a;
+        const bEndpoint = identityLabel(String(this.legs.b.endpoint || "").toLowerCase());
+        const bId = identityLabel(String(this.legs.b.id || "").toLowerCase());
+        if (bEndpoint === wanted || bId === wanted) return this.legs.b;
         return null;
     }
 
@@ -110,11 +132,38 @@ class PolySession {
                 }
                 this._recoverFailedLegs();
             }
+            await this._settleCallActivity();
         } finally {
             this._running = false;
         }
     }
 
+    // Detect the in-call edge from the quiesced leg states and fire the lifecycle
+    // hooks once per transition. "In call" = BOTH legs are IN_CALL, i.e. the actual
+    // answered conversation (the media-bridged window) -- ring/setup/teardown are
+    // deliberately excluded. The falling edge is the reliable "conversation is over"
+    // signal that fires on every end path (hangup either side, mid-call failure,
+    // transport drop) while the poly itself survives for reuse.
+    async _settleCallActivity() {
+        const active = this.legs.a.state === LEG_STATES.IN_CALL && this.legs.b.state === LEG_STATES.IN_CALL;
+        if (active === this._callActive) return;
+        this._callActive = active;
+        const hook = active ? this._onCallStart : this._onCallEnd;
+        if (typeof hook !== "function") return;
+        try {
+            await hook(this);
+        } catch (err) {
+            this.logger.error(`[${this.id}] call-${active ? "start" : "end"} hook failed: ${err.message}`);
+        }
+    }
+
+    // Inject per-call lifecycle side-effects (e.g. minuteCounter start/finish).
+    // Idempotent to set; safe to (re)assign on a reused poly before its next call.
+    setCallActivityHooks({ onCallStart = null, onCallEnd = null } = {}) {
+        if (onCallStart !== undefined) this._onCallStart = typeof onCallStart === "function" ? onCallStart : null;
+        if (onCallEnd !== undefined) this._onCallEnd = typeof onCallEnd === "function" ? onCallEnd : null;
+    }
+
     async _execute(action) {
         if (action.kind === "media") {
             return this._executeMedia(action);
@@ -143,6 +192,17 @@ class PolySession {
             }
         } catch (err) {
             this.logger.error(`[${this.id}] intent ${action.intent} on leg ${leg.id} failed: ${err.message}`);
+            // Dead/missing data channel on forward signaling is recoverable transport
+            // loss: drop this leg to DISCONNECTED so reconcile drives CONNECT -> RING.
+            if (err?.code === "NO_OPEN_DC" && RETRY_ON_NO_OPEN_DC_INTENTS.has(action.intent)) {
+                if (leg.state !== LEG_STATES.DISCONNECTED) {
+                    leg.setState(LEG_STATES.DISCONNECTED, {
+                        reason: `intent-no-open-dc:${action.intent}`,
+                        from: "self",
+                    });
+                }
+                return;
+            }
             // A reaching intent failed -> the leg cannot carry the call. Fail it so
             // reconcile drives the peer into an end-call reneg (a FAILED leg is a
             // teardown trigger). Idempotent: no-op if already FAILED/torn down.

package/webRTCservice/modules/calls/poly/PolySessionRegistry.js

@@ -4,22 +4,13 @@
 // Replaces the old linkedSessionId / bridgedWith / pendingBridges pairing.
 
 const { PolySession } = require("./PolySession");
-
-// Bare label of an identity: "972...@x" / "972....global" / "972..." -> "972...".
-function identityLabel(identity) {
-    if (!identity || typeof identity !== "string") return identity;
-    const trimmed = identity.trim();
-    const atPos = trimmed.indexOf("@");
-    if (atPos > 0) return trimmed.slice(0, atPos);
-    const dotPos = trimmed.indexOf(".");
-    if (dotPos > 0) return trimmed.slice(0, dotPos);
-    return trimmed;
-}
+const {
+    identityLabel,
+    pairKeyFromIdentities,
+} = require("../../runtime/CallPairRef");
 
 function pairKey(a, b) {
-    return [identityLabel(String(a || "").toLowerCase()), identityLabel(String(b || "").toLowerCase())]
-        .sort()
-        .join("|");
+    return pairKeyFromIdentities(a, b);
 }
 
 class PolySessionRegistry {
@@ -46,8 +37,21 @@ class PolySessionRegistry {
         return key ? (this.byKey.get(key) || null) : null;
     }
 
+    // All PolySessions that currently include this endpoint.
+    listByEndpoint(endpoint) {
+        if (!endpoint) return [];
+        const wanted = identityLabel(String(endpoint).toLowerCase());
+        if (!wanted) return [];
+        const matches = [];
+        for (const poly of this.byKey.values()) {
+            if (!poly) continue;
+            if (poly.legByEndpoint(wanted)) matches.push(poly);
+        }
+        return matches;
+    }
+
     keyForPair(a, b) {
-        return pairKey(a, b);
+        return pairKeyFromIdentities(a, b);
     }
 
     // Resolve (or create) the PolySession for a pair and return which leg the
@@ -56,13 +60,16 @@ class PolySessionRegistry {
         if (!a?.endpoint || !b?.endpoint) {
             throw new Error("PolySessionRegistry.resolve requires both leg endpoints");
         }
-        const key = pairKey(a.endpoint, b.endpoint);
+        const key = pairKeyFromIdentities(a.endpoint, b.endpoint);
         let poly = this.byKey.get(key);
         if (!poly) {
             poly = this._create(key, a, b);
         }
         const targetEndpoint = target === "b" ? b.endpoint : target === "a" ? a.endpoint : (target || a.endpoint);
-        const leg = poly.legByEndpoint(targetEndpoint) || poly.legs.a;
+        const leg = poly.legByEndpoint(targetEndpoint);
+        if (!leg) {
+            throw new Error(`PolySessionRegistry.resolve target endpoint not found in pair ${key}: ${targetEndpoint}`);
+        }
         return { poly, leg, ref: poly.refOf(leg), key };
     }
 

package/webRTCservice/modules/calls/poly/ReconcileRules.js

@@ -73,6 +73,13 @@ function reconcile(snapshot, event = null) {
         if (a.state === LEG_STATES.RINGING && isCaller(b.state)) actions.push(intent("b", LEG_INTENTS.ACK_RING, "a"));
         if (b.state === LEG_STATES.RINGING && isCaller(a.state)) actions.push(intent("a", LEG_INTENTS.ACK_RING, "b"));
     }
+    // Glare guard: two fresh caller legs can coexist briefly. Keep this strictly
+    // user-driven (no auto-answer) and deterministically present one side so
+    // the state machine does not stall in CALLING+CALLING.
+    if (a.state === LEG_STATES.CALLING && b.state === LEG_STATES.CALLING) {
+        actions.push(intent("b", LEG_INTENTS.RING, "a"));
+        return actions;
+    }
 
     // One side reached in-call while the peer is still ringing/calling -> they
     // picked up: finalize the peer (flush its held answer) and bridge media.

package/webRTCservice/modules/calls/poly/SessionLeg.js

@@ -210,6 +210,13 @@ class SessionLeg {
                     await this._tx(() => this.negotiation.applyOffer?.({ leg: this, mode: "ice-restart", ...event }));
                     return;
                 }
+                // Glare guard: if this leg is already being presented as the callee,
+                // accept the fresh SDP but keep RINGING so reconcile can still
+                // progress toward a user-driven answer.
+                if (this.state === LEG_STATES.RINGING) {
+                    await this._tx(() => this.negotiation.applyOffer?.({ leg: this, mode: "ring", ...event }));
+                    return;
+                }
                 // Otherwise this endpoint wants to start a call.
                 await this._tx(() => this.negotiation.applyOffer?.({ leg: this, mode: "ring", ...event }));
                 this.setState(LEG_STATES.CALLING, { reason: "client-offer", from: "self", payload: event.payload });

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

@@ -37,6 +37,12 @@ test("late inactive offer maps to END_RENEGOTIATION (teardown, not ring)", () =>
     assert.equal(ev.type, LEG_EVENTS.END_RENEGOTIATION);
 });
 
+test("forced offer meta keeps datachannel-only offer as OFFER", () => {
+    const { ingress } = build();
+    const ev = ingress.toLegEvent("offer", { sdp: "v=0\r\nm=application 9 UDP/DTLS/SCTP webrtc-datachannel\r\n" }, { forceOffer: true });
+    assert.equal(ev.type, LEG_EVENTS.OFFER);
+});
+
 test("call actions map to their leg events", () => {
     const { ingress } = build();
     assert.equal(ingress.toLegEvent("answer", {}).type, LEG_EVENTS.ANSWER);

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

@@ -5,6 +5,8 @@ const { PolySession } = require("../PolySession");
 const { LEG_STATES: S } = require("../states");
 const { LEG_EVENTS, makeLegEvent } = require("../ports");
 const { FakeMediaController, makeWebRtcLeg, makeSipLeg, silentLogger } = require("./fakes");
+const { MediaBridge } = require("../../../media/MediaBridge");
+const { MediaLeg } = require("../../../media/MediaLeg");
 
 function buildPoly(legAInfo, legBInfo) {
     const media = new FakeMediaController();
@@ -218,6 +220,26 @@ test("sip ring failure ends the webrtc caller, then the sip leg recovers for reu
     assert.equal(media.connects.length, 1, "media bridged on the reused call");
 });
 
+test("no-open-dc during ring marks callee disconnected and reconnects instead of ending caller", async () => {
+    const a = makeWebRtcLeg("alice");
+    const b = makeWebRtcLeg("bob", { deferConnect: true });
+    const { poly } = buildPoly(a, b);
+    await poly.onIngress("a", makeLegEvent(LEG_EVENTS.TRANSPORT_OPEN));
+    await poly.onIngress("b", makeLegEvent(LEG_EVENTS.TRANSPORT_OPEN));
+
+    b.negotiation.ring = async () => {
+        const err = new Error("no open data channel for offer");
+        err.code = "NO_OPEN_DC";
+        throw err;
+    };
+
+    await poly.onIngress("a", makeLegEvent(LEG_EVENTS.OFFER, { sdp: "o" }));
+    assert.equal(a.leg.state, S.CALLING, "caller must remain alive for retry");
+    assert.equal(b.leg.state, S.CONNECTING, "callee should reconnect after no-open-dc");
+    assert.equal(a.negotiation.named("endCall").length, 0, "no forced teardown on caller");
+    assert.equal(b.negotiation.named("connect").length, 1, "reconnect should be triggered");
+});
+
 test("reject before answer: caller is ended, no media ever bridged", async () => {
     const a = makeWebRtcLeg("alice");
     const b = makeWebRtcLeg("bob");
@@ -253,6 +275,26 @@ test("teardown hooks (e.g. minuteCounter.finish) run exactly once on dispose", a
     assert.deepEqual(reasons, ["call-ended"]);
 });
 
+test("call activity hooks fire once on call start/end edges", async () => {
+    const a = makeWebRtcLeg("alice");
+    const b = makeWebRtcLeg("bob");
+    const { poly } = buildPoly(a, b);
+    const activity = [];
+    poly.setCallActivityHooks({
+        onCallStart: () => activity.push("start"),
+        onCallEnd: () => activity.push("end"),
+    });
+
+    await poly.onIngress("a", makeLegEvent(LEG_EVENTS.TRANSPORT_OPEN));
+    await poly.onIngress("b", makeLegEvent(LEG_EVENTS.TRANSPORT_OPEN));
+    await poly.onIngress("a", makeLegEvent(LEG_EVENTS.OFFER, { sdp: "o" }));
+    await poly.onIngress("b", makeLegEvent(LEG_EVENTS.ANSWER, { sdp: "ans" }));
+    await poly.onIngress("a", makeLegEvent(LEG_EVENTS.END));
+    await poly.onIngress("b", makeLegEvent(LEG_EVENTS.END_RENEGOTIATION, { type: "answer", sdp: "end-ans" }));
+
+    assert.deepEqual(activity, ["start", "end"]);
+});
+
 test("second call reuse: after end, a fresh offer rings the peer again", async () => {
     const a = makeWebRtcLeg("alice");
     const b = makeWebRtcLeg("bob");
@@ -314,7 +356,7 @@ test("caller transport closes during callee connect: no media, no duplicate tear
     assert.equal(b.negotiation.named("endCall").length, 0);
 });
 
-test("simultaneous offers (glare) converges to a single connected call graph", async () => {
+test("simultaneous offers (glare) remains ring-driven until explicit answer", async () => {
     const a = makeWebRtcLeg("alice");
     const b = makeWebRtcLeg("bob");
     const { poly, media } = buildPoly(a, b);
@@ -324,13 +366,14 @@ test("simultaneous offers (glare) converges to a single connected call graph", a
     await poly.onIngress("a", makeLegEvent(LEG_EVENTS.OFFER, { sdp: "o-a" }));
     await poly.onIngress("b", makeLegEvent(LEG_EVENTS.OFFER, { sdp: "o-b" }));
     assert.equal(a.leg.state, S.CALLING);
-    assert.equal(b.leg.state, S.CALLING);
+    assert.equal(b.leg.state, S.RINGING);
+    assert.equal(media.connects.length, 0, "glare must not auto-bridge media");
+    assert.equal(media.disconnects.length, 0);
 
     await poly.onIngress("b", makeLegEvent(LEG_EVENTS.ANSWER, { sdp: "ans-b" }));
     assert.equal(a.leg.state, S.IN_CALL);
     assert.equal(b.leg.state, S.IN_CALL);
-    assert.equal(media.connects.length, 1, "glare must not duplicate media bridge");
-    assert.equal(media.disconnects.length, 0);
+    assert.equal(media.connects.length, 1, "media bridges only after explicit answer");
 });
 
 test("repeated settle passes do not duplicate media disconnect", async () => {
@@ -349,3 +392,111 @@ test("repeated settle passes do not duplicate media disconnect", async () => {
     await poly._settle();
     assert.equal(media.disconnects.length, 1, "teardown reconcile remains idempotent");
 });
+
+test("shared endpoint across AB and AC: transport close in AB does not impact AC", async () => {
+    const abA = makeWebRtcLeg("alice");
+    const abB = makeWebRtcLeg("bob");
+    const acA = makeWebRtcLeg("alice");
+    const acC = makeWebRtcLeg("carol");
+    const first = buildPoly(abA, abB);
+    const second = buildPoly(acA, acC);
+
+    await first.poly.onIngress("a", makeLegEvent(LEG_EVENTS.TRANSPORT_OPEN));
+    await first.poly.onIngress("b", makeLegEvent(LEG_EVENTS.TRANSPORT_OPEN));
+    await second.poly.onIngress("a", makeLegEvent(LEG_EVENTS.TRANSPORT_OPEN));
+    await second.poly.onIngress("b", makeLegEvent(LEG_EVENTS.TRANSPORT_OPEN));
+    await first.poly.onIngress("a", makeLegEvent(LEG_EVENTS.OFFER, { sdp: "offer-ab" }));
+    await first.poly.onIngress("b", makeLegEvent(LEG_EVENTS.ANSWER, { sdp: "answer-ab" }));
+    await second.poly.onIngress("a", makeLegEvent(LEG_EVENTS.OFFER, { sdp: "offer-ac" }));
+    await second.poly.onIngress("b", makeLegEvent(LEG_EVENTS.ANSWER, { sdp: "answer-ac" }));
+
+    assert.equal(abA.leg.state, S.IN_CALL);
+    assert.equal(abB.leg.state, S.IN_CALL);
+    assert.equal(acA.leg.state, S.IN_CALL);
+    assert.equal(acC.leg.state, S.IN_CALL);
+
+    await first.poly.onIngress("b", makeLegEvent(LEG_EVENTS.TRANSPORT_CLOSE));
+    assert.equal(abB.leg.state, S.FAILED);
+    assert.equal(abA.leg.state, S.ENDING);
+    assert.equal(acA.leg.state, S.IN_CALL, "AB transport close must not affect AC");
+    assert.equal(acC.leg.state, S.IN_CALL, "AB transport close must not affect AC");
+    assert.equal(first.media.disconnects.length, 1);
+    assert.equal(second.media.disconnects.length, 0);
+});
+
+class FakeRtpLeg extends MediaLeg {
+    constructor({ id, kind, payloadType = 8 } = {}) {
+        super({ id, kind, payloadType, logger: silentLogger });
+        this._handler = null;
+        this.writtenPackets = 0;
+    }
+
+    onRtp(handler) {
+        this._handler = handler;
+        const dispose = () => { this._handler = null; };
+        this.addDisposer(dispose);
+        return dispose;
+    }
+
+    writeRtp() {
+        this.writtenPackets += 1;
+        this.noteOutbound();
+    }
+
+    emitRtp(packet) {
+        if (!this._handler) return;
+        this.noteInbound();
+        this._handler(packet);
+    }
+}
+
+function fakeRtpPacket(ssrc, seq) {
+    return {
+        header: {
+            ssrc,
+            sequenceNumber: seq,
+            timestamp: seq * 160,
+            payloadType: 8,
+        },
+    };
+}
+
+test("media bridge passes RTP both directions", async () => {
+    const a = new FakeRtpLeg({ id: "webrtc:a", kind: "webrtc" });
+    const b = new FakeRtpLeg({ id: "sip:b", kind: "sip" });
+    const bridge = new MediaBridge({ sessionId: "webrtc<->sip", a, b, logger: silentLogger, statsIntervalMs: 10000 });
+    await bridge.start();
+
+    for (let i = 0; i < 5; i += 1) a.emitRtp(fakeRtpPacket(1111, i + 1));
+    for (let i = 0; i < 4; i += 1) b.emitRtp(fakeRtpPacket(2222, i + 1));
+
+    const health = bridge.health();
+    assert.equal(health.aToB, 5);
+    assert.equal(health.bToA, 4);
+    assert.equal(a.stats.inboundPackets > 0, true);
+    assert.equal(b.stats.inboundPackets > 0, true);
+    await bridge.stop();
+});
+
+test("media bridge still bidirectional after teardown and reconnect", async () => {
+    const a1 = new FakeRtpLeg({ id: "webrtc:reuse-a", kind: "webrtc" });
+    const b1 = new FakeRtpLeg({ id: "sip:reuse-b", kind: "sip" });
+    const first = new MediaBridge({ sessionId: "reuse-call-1", a: a1, b: b1, logger: silentLogger, statsIntervalMs: 10000 });
+    await first.start();
+    a1.emitRtp(fakeRtpPacket(3333, 1));
+    b1.emitRtp(fakeRtpPacket(4444, 1));
+    await first.stop();
+    assert.equal(first.health().aToB, 1);
+    assert.equal(first.health().bToA, 1);
+
+    const a2 = new FakeRtpLeg({ id: "webrtc:reuse-a", kind: "webrtc" });
+    const b2 = new FakeRtpLeg({ id: "sip:reuse-b", kind: "sip" });
+    const second = new MediaBridge({ sessionId: "reuse-call-2", a: a2, b: b2, logger: silentLogger, statsIntervalMs: 10000 });
+    await second.start();
+    for (let i = 0; i < 3; i += 1) a2.emitRtp(fakeRtpPacket(5555, i + 1));
+    for (let i = 0; i < 2; i += 1) b2.emitRtp(fakeRtpPacket(6666, i + 1));
+    const health = second.health();
+    assert.equal(health.aToB, 3);
+    assert.equal(health.bToA, 2);
+    await second.stop();
+});

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

@@ -59,6 +59,19 @@ test("resolve targets the correct leg by endpoint", () => {
     assert.equal(toBob.leg.kind, "sip");
 });
 
+test("resolve throws when target endpoint is not part of pair", () => {
+    const reg = buildRegistry();
+    assert.throws(
+        () =>
+            reg.resolve({
+                a: { endpoint: "alice", kind: "webrtc" },
+                b: { endpoint: "bob", kind: "sip" },
+                target: "carol",
+            }),
+        /target endpoint not found/i,
+    );
+});
+
 test("different pair creates a different PolySession", () => {
     const reg = buildRegistry();
     const r1 = reg.resolve({ a: { endpoint: "alice", kind: "webrtc" }, b: { endpoint: "bob", kind: "webrtc" } });
@@ -68,6 +81,7 @@ test("different pair creates a different PolySession", () => {
 
 test("pairKey is order-independent and label-normalized", () => {
     assert.equal(pairKey("A.x.global", "b"), pairKey("b", "a"));
+    assert.equal(pairKey("Alice.SecNum.Global", "BOB"), pairKey("alice", "bob"));
 });
 
 test("destroy removes the PolySession and frees the key", async () => {
@@ -141,3 +155,61 @@ test("supports two simultaneous calls without cross-wiring state/media", async (
     assert.equal(second.poly.legs.b.state, S.IN_CALL);
     assert.equal(media.connects.length, 2, "media must bridge each call once");
 });
+
+test("same callee with different callers keeps separate pair records", () => {
+    const reg = buildRegistry();
+    const first = reg.resolve({
+        a: { endpoint: "alice.secnum.global", kind: "webrtc" },
+        b: { endpoint: "*9225", kind: "sip" },
+        target: "a",
+    });
+    const second = reg.resolve({
+        a: { endpoint: "carol.secnum.global", kind: "webrtc" },
+        b: { endpoint: "*9225", kind: "sip" },
+        target: "a",
+    });
+
+    assert.notEqual(first.key, second.key);
+    assert.notEqual(first.poly, second.poly);
+    assert.equal(reg.get(first.key), first.poly);
+    assert.equal(reg.get(second.key), second.poly);
+});
+
+test("shared caller across AB and AC keeps pair-isolated lifecycle", async () => {
+    const { reg, media } = buildRegistryWithMedia();
+    const ab = reg.resolve({
+        a: { endpoint: "alice", kind: "webrtc" },
+        b: { endpoint: "bob", kind: "webrtc" },
+        target: "alice",
+    });
+    const ac = reg.resolve({
+        a: { endpoint: "alice", kind: "webrtc" },
+        b: { endpoint: "carol", kind: "webrtc" },
+        target: "alice",
+    });
+    assert.notEqual(ab.key, ac.key);
+    assert.notEqual(ab.poly, ac.poly);
+
+    await ab.poly.onIngress("a", makeLegEvent(LEG_EVENTS.TRANSPORT_OPEN));
+    await ab.poly.onIngress("b", makeLegEvent(LEG_EVENTS.TRANSPORT_OPEN));
+    await ac.poly.onIngress("a", makeLegEvent(LEG_EVENTS.TRANSPORT_OPEN));
+    await ac.poly.onIngress("b", makeLegEvent(LEG_EVENTS.TRANSPORT_OPEN));
+    await ab.poly.onIngress("a", makeLegEvent(LEG_EVENTS.OFFER, { sdp: "offer-ab" }));
+    await ab.poly.onIngress("b", makeLegEvent(LEG_EVENTS.ANSWER, { sdp: "answer-ab" }));
+    await ac.poly.onIngress("a", makeLegEvent(LEG_EVENTS.OFFER, { sdp: "offer-ac" }));
+    await ac.poly.onIngress("b", makeLegEvent(LEG_EVENTS.ANSWER, { sdp: "answer-ac" }));
+
+    assert.equal(ab.poly.legs.a.state, S.IN_CALL);
+    assert.equal(ab.poly.legs.b.state, S.IN_CALL);
+    assert.equal(ac.poly.legs.a.state, S.IN_CALL);
+    assert.equal(ac.poly.legs.b.state, S.IN_CALL);
+    assert.equal(media.connects.length, 2);
+
+    await ab.poly.onIngress("a", makeLegEvent(LEG_EVENTS.END));
+    await ab.poly.onIngress("b", makeLegEvent(LEG_EVENTS.END_RENEGOTIATION, { type: "answer", sdp: "end-ab" }));
+
+    assert.equal(ab.poly.legs.a.state, S.CONNECTED);
+    assert.equal(ab.poly.legs.b.state, S.CONNECTED);
+    assert.equal(ac.poly.legs.a.state, S.IN_CALL, "ending AB must not affect AC");
+    assert.equal(ac.poly.legs.b.state, S.IN_CALL, "ending AB must not affect AC");
+});

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

@@ -102,6 +102,16 @@ test("peer just rang: ackRing the caller (gated on the RINGING event)", () => {
     assert.deepEqual(intents(actions), [{ kind: "intent", leg: "a", intent: I.ACK_RING, from: "b" }]);
 });
 
+test("glare: calling+calling stays user-driven and presents one ringing side", () => {
+    const actions = reconcile(snap(S.CALLING, S.CALLING, false), ringEvent);
+    assert.deepEqual(intents(actions), [
+        { kind: "intent", leg: "a", intent: I.ACK_CONNECTED, from: "self" },
+        { kind: "intent", leg: "b", intent: I.ACK_CONNECTED, from: "self" },
+        { kind: "intent", leg: "b", intent: I.RING, from: "a" },
+    ]);
+    assert.equal(intents(actions).some((x) => x.intent === I.ANSWER), false);
+});
+
 test("no fresh-ring event: do not ack (a later pass must not re-ack the same ring)", () => {
     const actions = reconcile(snap(S.CALLING, S.CONNECTED, false), { state: S.CONNECTED });
     assert.deepEqual(intents(actions), [{ kind: "intent", leg: "b", intent: I.RING, from: "a" }]);