arnacon-webrtc-service 0.2.7 → 0.2.9

package/package.json

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

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/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 {
@@ -47,7 +38,7 @@ class PolySessionRegistry {
     }
 
     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,7 +47,7 @@ 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);

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

@@ -68,6 +68,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 +142,22 @@ 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);
+});

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

@@ -172,3 +172,28 @@ test("double-end race then immediate redial does not leak teardown state", async
     await bAnswers(ctx, "answer-2");
     expectInCall(ctx);
 });
+
+test("parallel calls that share a callee label stay isolated", async () => {
+    const first = buildWebRtcScenario();
+    const second = buildWebRtcScenario();
+
+    await transportOpenA(first);
+    await transportOpenB(first);
+    await transportOpenA(second);
+    await transportOpenB(second);
+
+    await aOffers(first, "offer-a");
+    await bAnswers(first, "answer-a");
+    await aOffers(second, "offer-c");
+    await bAnswers(second, "answer-c");
+
+    expectInCall(first);
+    expectInCall(second);
+
+    await aEnds(second);
+    await bCompletesEnd(second, "end-second");
+
+    // Ending one pair must not disturb the other active pair.
+    expectInCall(first);
+    expectEnded(second);
+});

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

@@ -1015,3 +1015,13 @@ test("DEEP BUG REPRO: parser m-line failure realigns on data-only offer", async
     );
     assert.equal(pc.transceivers.find((t) => t.kind === "audio")?.sender?.track, null);
 });
+
+test("ring signaling keeps canonical caller label in payload", async () => {
+    const { neg, signaling } = build();
+    await neg.ring({ from: "alice.secnum.global" });
+    const message = signaling.sent.at(-1);
+    assert.equal(message?.msgType, "signaling");
+    assert.equal(message?.payload?.type, "offer");
+    assert.equal(message?.payload?.from, "alice");
+    assert.equal(message?.payload?.to, "bob.secnum.global");
+});

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

@@ -253,3 +253,16 @@ test("WERIFT REPLAY: decline/end then redial with audio mid=2 stays reusable", a
         await harness.dispose();
     }
 });
+
+test("WERIFT REPLAY: ring payload keeps caller label normalized", async () => {
+    const harness = buildWeriftNegotiationHarness({ withAudioTrack: true, withDataChannel: true });
+    try {
+        await assert.doesNotReject(() => harness.neg.ring({ from: "alice.secnum.global" }));
+        const message = harness.signaling.sent.at(-1);
+        assert.equal(message?.msgType, "signaling");
+        assert.equal(message?.payload?.from, "alice");
+        assert.equal(message?.payload?.to, "bob.secnum.global");
+    } finally {
+        await harness.dispose();
+    }
+});

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

@@ -13,16 +13,9 @@ const {
     alignEndCallAnswerSdp,
     audioDirection,
 } = require("./sdp");
-
-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");
 
 class WebRtcNegotiation extends CallNegotiationPort {
     constructor({

package/webRTCservice/modules/calls/webrtc/WebRtcOfferUseCase.js

@@ -1,3 +1,9 @@
+const {
+    identityLabel,
+    normalizeSessionId,
+    pairKeyFromIdentities,
+} = require("../../runtime/CallPairRef");
+
 function createOfferFlow({
     sessions,
     sessionsByUser,
@@ -23,21 +29,6 @@ function createOfferFlow({
         return addr;
     }
 
-    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;
-    }
-
-    function normalizeSessionId(sessionId) {
-        if (!sessionId || typeof sessionId !== "string") return sessionId;
-        return sessionId.split("|").map(identityLabel).join("|");
-    }
-
     function relationSessionCandidates(from, to, sessionId) {
         const fromLabel = identityLabel(from);
         const toLabel = identityLabel(to);
@@ -47,6 +38,7 @@ function createOfferFlow({
             candidates.add(`${fromLabel}|${toLabel}`);
             candidates.add(`${toLabel}|${fromLabel}`);
             candidates.add(stableKey(from, to));
+            candidates.add(pairKeyFromIdentities(from, to));
         }
         return candidates;
     }

package/webRTCservice/modules/participants/signaling/SignalingEnvelope.js

@@ -1,13 +1,6 @@
-// Bare label for an identity: strips an @domain or a .sub.global suffix.
-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");
 
 // The single source of truth for the wire sessionId we hand a client. Every
 // client keys a session as sort(ownFullEns, peerBareNumber): it stores ITSELF as

package/webRTCservice/modules/participants/signaling/SignalingPipeline.js

@@ -1,17 +1,11 @@
-function authIdentityLabel(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;
-}
-function authNormalizeSessionId(sessionId) {
-    if (!sessionId || typeof sessionId !== "string") return sessionId;
-    if (!sessionId.includes("|")) return sessionId;
-    return sessionId.split("|").map(authIdentityLabel).join("|");
-}
+const {
+    identityLabel,
+    normalizeSessionId,
+    pairKeyFromIdentities,
+} = require("../../runtime/CallPairRef");
+
+const authIdentityLabel = identityLabel;
+const authNormalizeSessionId = normalizeSessionId;
 
 class SignalingAuthVerifier {
     constructor({ blockchainGateway, sessions }) {
@@ -32,6 +26,7 @@ class SignalingAuthVerifier {
         if (fromLabel && toLabel) {
             candidates.add(`${fromLabel}|${toLabel}`);
             candidates.add(`${toLabel}|${fromLabel}`);
+            candidates.add(pairKeyFromIdentities(fromLabel, toLabel));
         }
         for (const candidate of candidates) {
             const session = this.sessions.get(candidate);
@@ -85,22 +80,6 @@ function createSignalingPipeline({
         return null;
     }
 
-    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;
-    }
-
-    function normalizeSessionId(sessionId) {
-        if (!sessionId || typeof sessionId !== "string") return sessionId;
-        if (!sessionId.includes("|")) return sessionId;
-        return sessionId.split("|").map(identityLabel).join("|");
-    }
-
     function normalizeNotifyPayload(rawPayload) {
         const source = rawPayload || {};
         const nestedPayload = parseObjectPayload(source.payload);

package/webRTCservice/modules/runtime/CallPairRef.js

@@ -0,0 +1,46 @@
+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;
+}
+
+function normalizeIdentityForKey(identity) {
+    return identityLabel(String(identity || "").toLowerCase());
+}
+
+function createCallPairRef(caller, callee) {
+    return {
+        caller: caller || null,
+        callee: callee || null,
+    };
+}
+
+function pairKeyFromIdentities(a, b) {
+    return [normalizeIdentityForKey(a), normalizeIdentityForKey(b)]
+        .sort()
+        .join("|");
+}
+
+function pairKeyFromRef(callPairRef) {
+    if (!callPairRef) return pairKeyFromIdentities("", "");
+    return pairKeyFromIdentities(callPairRef.caller, callPairRef.callee);
+}
+
+function normalizeSessionId(sessionId) {
+    if (!sessionId || typeof sessionId !== "string") return sessionId;
+    if (!sessionId.includes("|")) return sessionId;
+    return sessionId.split("|").map((part) => identityLabel(part)).join("|");
+}
+
+module.exports = {
+    identityLabel,
+    normalizeIdentityForKey,
+    createCallPairRef,
+    pairKeyFromIdentities,
+    pairKeyFromRef,
+    normalizeSessionId,
+};

package/webRTCservice/modules/runtime/CallPairResolver.js

@@ -0,0 +1,60 @@
+const {
+    createCallPairRef,
+    pairKeyFromRef,
+    pairKeyFromIdentities,
+} = require("./CallPairRef");
+
+class CallPairResolver {
+    constructor({ polyRegistry } = {}) {
+        if (!polyRegistry) throw new Error("CallPairResolver requires polyRegistry");
+        this.polyRegistry = polyRegistry;
+    }
+
+    fromSession(session) {
+        if (!session) return null;
+        if (session.callPairRef?.caller && session.callPairRef?.callee) return session.callPairRef;
+        return createCallPairRef(session.callerEns, session.toIdentity);
+    }
+
+    fromIdentities(caller, callee) {
+        return createCallPairRef(caller, callee);
+    }
+
+    keyFromSession(session) {
+        const ref = this.fromSession(session);
+        if (!ref) return null;
+        return pairKeyFromRef(ref);
+    }
+
+    keyFromIdentities(caller, callee) {
+        return pairKeyFromIdentities(caller, callee);
+    }
+
+    keyFromPoly(poly) {
+        if (!poly) return null;
+        return pairKeyFromIdentities(poly.legs.a.endpoint, poly.legs.b.endpoint);
+    }
+
+    polyForSession(session) {
+        const key = this.keyFromSession(session);
+        if (!key) return null;
+        return this.polyRegistry.get(key) || null;
+    }
+
+    polyForOffer(offer) {
+        if (!offer) return null;
+        const key = this.keyFromIdentities(offer.from, offer.to);
+        if (!key) return null;
+        return this.polyRegistry.get(key) || null;
+    }
+
+    bindSessionPairRef(session, caller, callee) {
+        if (!session) return null;
+        session.callPairRef = createCallPairRef(caller, callee);
+        return session.callPairRef;
+    }
+}
+
+module.exports = {
+    CallPairResolver,
+};

package/webRTCservice/modules/runtime/SessionStore.js

@@ -1,3 +1,10 @@
+const {
+    identityLabel,
+    pairKeyFromIdentities,
+    normalizeSessionId,
+    createCallPairRef,
+} = require("./CallPairRef");
+
 class SessionStore {
     constructor() {
         this.sessions = new Map();
@@ -42,23 +49,15 @@ class SessionStore {
     }
 
     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;
+        return identityLabel(identity);
     }
 
     normalizeSessionId(sessionId) {
-        if (!sessionId || typeof sessionId !== "string") return sessionId;
-        if (!sessionId.includes("|")) return sessionId;
-        return sessionId.split("|").map((part) => this.identityLabel(part)).join("|");
+        return normalizeSessionId(sessionId);
     }
 
     stableKey(a, b) {
-        return [this.identityLabel(a), this.identityLabel(b)].sort().join("|");
+        return pairKeyFromIdentities(a, b);
     }
 
     createSession(sessionId, callerEns, toIdentity, logger = console) {
@@ -92,6 +91,7 @@ class SessionStore {
                 },
             },
             inboundRingSent: false,
+            callPairRef: createCallPairRef(callerEns, toIdentity),
         };
         this.sessions.set(canonicalSessionId, session);
         if (callerEns && toIdentity) {

package/webRTCservice/webRTCmanager.js

@@ -143,6 +143,11 @@ const { LEG_STATES, canBeRung, isActiveCall } = require("./modules/calls/poly/st
 const { isInactiveOffer } = require("./modules/calls/poly/negotiation/sdp");
 const { routeToCodecPolicy } = require("./modules/media/negotiation/CodecPolicy");
 const { narrowAudioOfferForCodecPolicy } = require("./modules/media/negotiation/SdpCodecNegotiator");
+const {
+    identityLabel,
+    createCallPairRef,
+} = require("./modules/runtime/CallPairRef");
+const { CallPairResolver } = require("./modules/runtime/CallPairResolver");
 const {
     MediaStreamTrack,
 } = werift;
@@ -720,6 +725,7 @@ const polyCore = createPolyCore({
 });
 const polyRegistry = polyCore.registry;
 const polyIngress = polyCore.ingress;
+const callPairResolver = new CallPairResolver({ polyRegistry });
 console.log("[poly] PolySession core is the live coordinator");
 
 
@@ -824,6 +830,7 @@ async function handleInboundCallRequest(data, serviceContext = null) {
                 // An inbound call always brings a fresh session + FCM wake, so it
                 // must own a fresh poly -> tear any stale one down first.
                 await polyRegistry.destroy(polyRegistry.keyForPair(callerNumber, calleeEns), "inbound-fresh-call");
+                callPairResolver.bindSessionPairRef(session, callerNumber, calleeEns);
                 const { poly } = polyRegistry.resolve({
                     a: { endpoint: callerNumber, kind: "sip", phoneNumber, session },
                     b: {
@@ -963,20 +970,11 @@ function createPeerConnection(...args) {
 // ─── PolySession ingress helpers (manager seam) ─────────────────────────────
 
 function pLabel(identity) {
-    if (!identity || typeof identity !== "string") return identity;
-    const t = identity.trim();
-    const at = t.indexOf("@");
-    if (at > 0) return t.slice(0, at);
-    const dot = t.indexOf(".");
-    if (dot > 0) return t.slice(0, dot);
-    return t;
+    return identityLabel(identity);
 }
 
 function polyForSession(session) {
-    if (!session) return null;
-    return polyRegistry.getByEndpoint(session.callerEns)
-        || polyRegistry.getByEndpoint(session.toIdentity)
-        || null;
+    return callPairResolver.polyForSession(session);
 }
 
 // Which leg ref a webrtc message on `session` targets. callee-webrtc role => the
@@ -1088,6 +1086,7 @@ async function onDcRing(callerSessionId, payload) {
         };
     }
 
+    callPairResolver.bindSessionPairRef(session, a.endpoint, b.endpoint);
     const { poly } = polyRegistry.resolve({ a, b, target: "a" });
     // Caller transport is already up (HTTP handshake). The SIP leg has no transport
     // to negotiate (openOutbound happens on ring), so mark it usable too. A webrtc
@@ -1183,8 +1182,9 @@ function onDataChannelMessage(sessionId, rawMessage, meta = {}) {
         if (!existing || !polyOwnsSession(existing, session, channelRole)) {
             (async () => {
                 if (existing) {
+                    const existingKey = callPairResolver.keyFromPoly(existing);
                     await polyRegistry.destroy(
-                        polyRegistry.keyForPair(existing.legs.a.endpoint, existing.legs.b.endpoint),
+                        existingKey,
                         "new-ring-reset",
                     );
                 }
@@ -1221,18 +1221,21 @@ function onDataChannelMessage(sessionId, rawMessage, meta = {}) {
     poly.onIngress(ref, event).catch((err) => {
         if (action === "offer" && isRecoverableOfferIngressError(err) && !payload.__polyIngressRetriedOnce) {
             payload.__polyIngressRetriedOnce = true;
-            (async () => {
-                const latestSession = sessions.get(sessionId);
-                if (!latestSession) return;
-                const existing = polyForSession(latestSession);
-                if (existing) {
-                    await polyRegistry.destroy(
-                        polyRegistry.keyForPair(existing.legs.a.endpoint, existing.legs.b.endpoint),
-                        "offer-recover-reset",
-                    );
-                }
-                await onDcRing(sessionId, payload);
-            })().catch((retryErr) => {
+            // Keep the current poly/session/PC alive and retry ingress in place.
+            // This mirrors client-side reuse semantics after decline/end flows.
+            const latestSession = sessions.get(sessionId);
+            const latestPoly = latestSession ? polyForSession(latestSession) : null;
+            if (!latestSession || !latestPoly) {
+                console.error(`[${sessionId}] poly ingress (${action}) retry skipped: no active session/poly`);
+                return;
+            }
+            const retryRef = polyWebrtcRef(latestPoly, latestSession, channelRole);
+            const retryEvent = polyIngress.toLegEvent(action, payload, { channelRole });
+            if (!retryEvent) {
+                console.error(`[${sessionId}] poly ingress (${action}) retry skipped: no retry event`);
+                return;
+            }
+            latestPoly.onIngress(retryRef, retryEvent).catch((retryErr) => {
                 console.error(`[${sessionId}] poly ingress (${action}) retry failed: ${retryErr.message}`);
             });
             return;
@@ -1243,7 +1246,7 @@ function onDataChannelMessage(sessionId, rawMessage, meta = {}) {
 
 // HTTP /notify "answer" (callee picked up: secnum<->secnum leg or inbound callee).
 async function onVerifiedNotifyAnswer(sessionId, offer, session) {
-    const poly = polyForSession(session) || polyRegistry.getByEndpoint(offer.from);
+    const poly = polyForSession(session) || callPairResolver.polyForOffer(offer);
     if (!poly) return { handled: false };
     const ref = polyRefByEndpoint(poly, offer.from)
         || (poly.legs.b.kind === "webrtc" ? "b" : "a");
@@ -1340,7 +1343,10 @@ async function onTransportClosed(sessionId, event = {}) {
         } catch (err) {
             console.error(`[${sessionId}] poly transport-close failed: ${err.message}`);
         }
-        try { await polyRegistry.destroy(polyRegistry.keyForPair(poly.legs.a.endpoint, poly.legs.b.endpoint), event.reason || "transport-closed"); } catch (_) {}
+        try {
+            const key = callPairResolver.keyFromPoly(poly);
+            await polyRegistry.destroy(key, event.reason || "transport-closed");
+        } catch (_) {}
     }
     destroySession(sessionId, event.notify === true);
 }
@@ -1386,6 +1392,7 @@ function sendDataChannelMessage(sessionId, message) {
 
 function createSession(sessionId, callerEns, toIdentity) {
     const session = sessionStore.createSession(sessionId, callerEns, toIdentity, console);
+    session.callPairRef = createCallPairRef(callerEns, toIdentity);
     const call = callFactory.fromSession(session);
     session.call = call;
     session.callId = call.id;