arnacon-webrtc-service 0.1.188 → 0.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "arnacon-webrtc-service",
-  "version": "0.1.188",
+  "version": "0.2.0",
   "description": "Arnacon WebRTC core runtime and service modules",
   "main": "./webRTCservice/core.js",
   "type": "commonjs",
@@ -17,12 +17,13 @@
   "files": [
     "webRTCservice/**/*",
     "services/**/*",
-    "config.json",
     "globalserviceconfig.json",
     "demoAudio/**/*"
   ],
   "scripts": {
-    "test": "node --test webRTCservice/modules/calls/poly/__tests__/*.test.js",
+    "test": "npm run test:poly",
+    "test:poly": "node --test webRTCservice/modules/calls/poly/__tests__/*.test.js",
+    "test:scenarios": "node --test webRTCservice/modules/calls/poly/__tests__/Scenarios.test.js",
     "build": "node webRTCservice/build.js",
     "clean": "node webRTCservice/clean.js",
     "validate:exports": "node webRTCservice/validateExports.js",

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

@@ -35,16 +35,6 @@ 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;
@@ -120,38 +110,11 @@ 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);

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

@@ -65,3 +65,58 @@ test("unsupported action is ignored without throwing", async () => {
     const result = await ingress.deliver(parties, "totally-unknown", {});
     assert.equal(result, null);
 });
+
+test("cancel action routes through registry to caller leg state", async () => {
+    const { ingress, registry } = build();
+    const { poly } = registry.resolve(parties);
+    await poly.onIngress("a", { type: LEG_EVENTS.TRANSPORT_OPEN, payload: {} });
+    await poly.onIngress("b", { type: LEG_EVENTS.TRANSPORT_OPEN, payload: {} });
+    await ingress.deliver(parties, "offer", { sdp: "v=0\r\nm=audio 9 UDP\r\na=sendrecv\r\n" });
+    assert.equal(poly.legs.a.state, S.CALLING);
+    assert.equal(poly.legs.b.state, S.RINGING);
+
+    await ingress.deliver(parties, "cancel", {});
+    assert.equal(poly.legs.a.state, S.CANCELED);
+});
+
+test("reject action delivered to callee transitions to rejected and ends caller", async () => {
+    const { ingress, registry } = build();
+    const { poly } = registry.resolve(parties);
+    await poly.onIngress("a", { type: LEG_EVENTS.TRANSPORT_OPEN, payload: {} });
+    await poly.onIngress("b", { type: LEG_EVENTS.TRANSPORT_OPEN, payload: {} });
+    await ingress.deliver(parties, "offer", { sdp: "v=0\r\nm=audio 9 UDP\r\na=sendrecv\r\n" });
+
+    await ingress.deliver({ ...parties, target: "bob" }, "reject", {});
+    assert.equal(poly.legs.b.state, S.REJECTED);
+    assert.equal(poly.legs.a.state, S.ENDING);
+});
+
+test("end-call answer is routed as END_RENEGOTIATION completion", async () => {
+    const { ingress, registry } = build();
+    const { poly } = registry.resolve(parties);
+    await poly.onIngress("a", { type: LEG_EVENTS.TRANSPORT_OPEN, payload: {} });
+    await poly.onIngress("b", { type: LEG_EVENTS.TRANSPORT_OPEN, payload: {} });
+    await ingress.deliver(parties, "offer", { sdp: "v=0\r\nm=audio 9 UDP\r\na=sendrecv\r\n" });
+    await ingress.deliver({ ...parties, target: "bob" }, "answer", { sdp: "ans" });
+    assert.equal(poly.legs.a.state, S.IN_CALL);
+    assert.equal(poly.legs.b.state, S.IN_CALL);
+
+    await ingress.deliver(parties, "end", {});
+    assert.equal(poly.legs.a.state, S.CONNECTED);
+    assert.equal(poly.legs.b.state, S.ENDING);
+
+    await ingress.deliver({ ...parties, target: "bob" }, "end-call", { type: "answer", sdp: "end-ans" });
+    assert.equal(poly.legs.b.state, S.CONNECTED);
+});
+
+test("ice and ice-batch actions reach aux handler without state churn", async () => {
+    const { ingress, registry } = build();
+    const { poly } = registry.resolve(parties);
+    await poly.onIngress("a", { type: LEG_EVENTS.TRANSPORT_OPEN, payload: {} });
+
+    await ingress.deliver(parties, "ice", { candidates: [{ candidate: "cand-1" }] });
+    await ingress.deliver(parties, "ice-batch", { candidates: [{ candidate: "cand-2" }] });
+
+    assert.equal(poly.legs.a.state, S.CONNECTED);
+    assert.equal(poly.legs.a.negotiation.named("aux").length, 2);
+});

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

@@ -275,3 +275,77 @@ test("second call reuse: after end, a fresh offer rings the peer again", async (
     assert.equal(b.leg.state, S.RINGING);
     assert.equal(b.negotiation.named("ring").length, 2);
 });
+
+test("caller cancels while callee is still connecting (deferred connect)", async () => {
+    const a = makeWebRtcLeg("alice");
+    const b = makeWebRtcLeg("bob", { deferConnect: true });
+    const { poly, media } = buildPoly(a, b);
+    await poly.onIngress("a", makeLegEvent(LEG_EVENTS.TRANSPORT_OPEN));
+    await poly.onIngress("a", makeLegEvent(LEG_EVENTS.OFFER, { sdp: "o" }));
+    assert.equal(a.leg.state, S.CALLING);
+    assert.equal(b.leg.state, S.CONNECTING);
+
+    await poly.onIngress("a", makeLegEvent(LEG_EVENTS.CANCEL));
+    assert.equal(a.leg.state, S.CANCELED);
+    assert.equal(b.leg.state, S.CONNECTING, "callee keeps its connect lifecycle");
+    assert.equal(media.connects.length, 0);
+    assert.equal(b.negotiation.named("ring").length, 0);
+
+    // If the callee transport opens later, it must not be auto-rung from stale state.
+    await poly.onIngress("b", makeLegEvent(LEG_EVENTS.TRANSPORT_OPEN));
+    assert.equal(b.leg.state, S.CONNECTED);
+    assert.equal(b.negotiation.named("ring").length, 0);
+});
+
+test("caller transport closes during callee connect: no media, no duplicate teardown intents", async () => {
+    const a = makeWebRtcLeg("alice");
+    const b = makeWebRtcLeg("bob", { deferConnect: true });
+    const { poly, media } = buildPoly(a, b);
+    await poly.onIngress("a", makeLegEvent(LEG_EVENTS.TRANSPORT_OPEN));
+    await poly.onIngress("a", makeLegEvent(LEG_EVENTS.OFFER, { sdp: "o" }));
+    assert.equal(a.leg.state, S.CALLING);
+    assert.equal(b.leg.state, S.CONNECTING);
+
+    await poly.onIngress("a", makeLegEvent(LEG_EVENTS.TRANSPORT_CLOSE));
+    assert.equal(a.leg.state, S.DISCONNECTED, "failed caller collapses to idle after teardown settles");
+    assert.equal(b.leg.state, S.CONNECTING);
+    assert.equal(media.connects.length, 0);
+    assert.equal(media.disconnects.length, 0);
+    assert.equal(b.negotiation.named("endCall").length, 0);
+});
+
+test("simultaneous offers (glare) converges to a single connected call graph", async () => {
+    const a = makeWebRtcLeg("alice");
+    const b = makeWebRtcLeg("bob");
+    const { poly, media } = buildPoly(a, b);
+    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-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);
+
+    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);
+});
+
+test("repeated settle passes do not duplicate media disconnect", async () => {
+    const a = makeWebRtcLeg("alice");
+    const b = makeWebRtcLeg("bob");
+    const { poly, media } = buildPoly(a, b);
+    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" }));
+    assert.equal(media.connects.length, 1);
+
+    await poly.onIngress("a", makeLegEvent(LEG_EVENTS.END));
+    assert.equal(media.disconnects.length, 1);
+    await poly._settle();
+    await poly._settle();
+    assert.equal(media.disconnects.length, 1, "teardown reconcile remains idempotent");
+});

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

@@ -3,6 +3,8 @@ const assert = require("node:assert/strict");
 
 const { PolySessionRegistry, pairKey } = require("../PolySessionRegistry");
 const { LegFactory } = require("../LegFactory");
+const { LEG_EVENTS, makeLegEvent } = require("../ports");
+const { LEG_STATES: S } = require("../states");
 const { FakeNegotiation, FakeMediaController, silentLogger } = require("./fakes");
 
 function buildRegistry() {
@@ -15,6 +17,18 @@ function buildRegistry() {
     return new PolySessionRegistry({ legFactory, mediaController: new FakeMediaController(), logger: silentLogger });
 }
 
+function buildRegistryWithMedia() {
+    const negotiationFactory = ({ id }) => new FakeNegotiation({ id });
+    const legFactory = new LegFactory({
+        webRtcNegotiationFactory: negotiationFactory,
+        sipNegotiationFactory: negotiationFactory,
+        logger: silentLogger,
+    });
+    const media = new FakeMediaController();
+    const reg = new PolySessionRegistry({ legFactory, mediaController: media, logger: silentLogger });
+    return { reg, media };
+}
+
 test("same identity pair resolves to one PolySession regardless of order or label form", () => {
     const reg = buildRegistry();
     const r1 = reg.resolve({
@@ -96,3 +110,34 @@ test("getByEndpoint finds the PolySession by either party (label-normalized)", (
     assert.equal(reg.getByEndpoint("BOB@example.com"), poly);
     assert.equal(reg.getByEndpoint("nobody"), null);
 });
+
+test("supports two simultaneous calls without cross-wiring state/media", async () => {
+    const { reg, media } = buildRegistryWithMedia();
+    const first = reg.resolve({
+        a: { endpoint: "alice", kind: "webrtc" },
+        b: { endpoint: "bob", kind: "webrtc" },
+        target: "a",
+    });
+    const second = reg.resolve({
+        a: { endpoint: "carol", kind: "webrtc" },
+        b: { endpoint: "dave", kind: "webrtc" },
+        target: "a",
+    });
+    assert.notEqual(first.poly, second.poly);
+
+    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-1" }));
+    await second.poly.onIngress("a", makeLegEvent(LEG_EVENTS.OFFER, { sdp: "offer-2" }));
+    await first.poly.onIngress("b", makeLegEvent(LEG_EVENTS.ANSWER, { sdp: "answer-1" }));
+    await second.poly.onIngress("b", makeLegEvent(LEG_EVENTS.ANSWER, { sdp: "answer-2" }));
+
+    assert.equal(first.poly.legs.a.state, S.IN_CALL);
+    assert.equal(first.poly.legs.b.state, S.IN_CALL);
+    assert.equal(second.poly.legs.a.state, S.IN_CALL);
+    assert.equal(second.poly.legs.b.state, S.IN_CALL);
+    assert.equal(media.connects.length, 2, "media must bridge each call once");
+});

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

@@ -112,6 +112,27 @@ test("ackConnected fires even when the peer is not yet reachable", () => {
     assert.deepEqual(intents(actions), [{ kind: "intent", leg: "a", intent: I.ACK_CONNECTED, from: "self" }]);
 });
 
+test("connecting peer with no fresh ring event does not re-ack or ring yet", () => {
+    const actions = reconcile(snap(S.CALLING, S.CONNECTING, false), { state: S.CONNECTING });
+    assert.deepEqual(intents(actions), []);
+    assert.deepEqual(mediaOps(actions), []);
+});
+
+test("re-ring transition: ringing caller and reusable peer issues ring intent", () => {
+    const actions = reconcile(snap(S.RINGING, S.CONNECTED, false), { state: S.RINGING });
+    assert.deepEqual(intents(actions), [
+        { kind: "intent", leg: "b", intent: I.RING, from: "a" },
+    ]);
+});
+
+test("reverse re-ring transition: ended side can be rung by calling peer", () => {
+    const actions = reconcile(snap(S.ENDED, S.CALLING, false), ringEvent);
+    assert.deepEqual(intents(actions), [
+        { kind: "intent", leg: "b", intent: I.ACK_CONNECTED, from: "self" },
+        { kind: "intent", leg: "a", intent: I.RING, from: "b" },
+    ]);
+});
+
 test("progress: ringing vs ended (reusable) rings the reusable side", () => {
     const actions = reconcile(snap(S.ENDED, S.RINGING, false));
     assert.deepEqual(intents(actions), [{ kind: "intent", leg: "a", intent: I.RING, from: "b" }]);

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

@@ -0,0 +1,94 @@
+const { test } = require("node:test");
+
+const {
+    S,
+    buildWebRtcScenario,
+    transportOpenA,
+    transportOpenB,
+    aOffers,
+    bAnswers,
+    bRejects,
+    aEnds,
+    bEnds,
+    aCompletesEnd,
+    bCompletesEnd,
+    expectLegStates,
+    expectInCall,
+    expectRinging,
+    expectEnded,
+    expectReusable,
+    expectMediaConnectedOnce,
+    expectMediaDisconnected,
+    expectNoMedia,
+} = require("./helpers/scenarioHelpers");
+
+test("A calls B -> B ringing, A calling", async () => {
+    const ctx = buildWebRtcScenario();
+    await transportOpenA(ctx);
+    await transportOpenB(ctx);
+
+    await aOffers(ctx, "offer-1");
+
+    expectRinging(ctx);
+    expectNoMedia(ctx);
+});
+
+test("A calls B -> B answers -> both inCall", async () => {
+    const ctx = buildWebRtcScenario();
+    await transportOpenA(ctx);
+    await transportOpenB(ctx);
+
+    await aOffers(ctx, "offer-1");
+    await bAnswers(ctx, "answer-1");
+
+    expectInCall(ctx);
+    expectMediaConnectedOnce(ctx);
+});
+
+test("A calls B -> B declines -> A calls again -> B answers -> both inCall", async () => {
+    const ctx = buildWebRtcScenario();
+    await transportOpenA(ctx);
+    await transportOpenB(ctx);
+
+    await aOffers(ctx, "offer-1");
+    await bRejects(ctx);
+    expectLegStates(ctx, S.ENDING, S.REJECTED);
+    await aCompletesEnd(ctx, "end-answer-1");
+    expectReusable(ctx);
+    expectNoMedia(ctx);
+
+    await aOffers(ctx, "offer-2");
+    await bAnswers(ctx, "answer-2");
+    expectInCall(ctx);
+    expectMediaConnectedOnce(ctx);
+});
+
+test("A ends -> clean teardown -> both reusable", async () => {
+    const ctx = buildWebRtcScenario();
+    await transportOpenA(ctx);
+    await transportOpenB(ctx);
+    await aOffers(ctx, "offer-1");
+    await bAnswers(ctx, "answer-1");
+    expectInCall(ctx);
+
+    await aEnds(ctx);
+    expectLegStates(ctx, S.CONNECTED, S.ENDING);
+    expectMediaDisconnected(ctx, 1);
+    await bCompletesEnd(ctx, "end-answer-b");
+    expectEnded(ctx);
+});
+
+test("B ends -> clean teardown -> both reusable", async () => {
+    const ctx = buildWebRtcScenario();
+    await transportOpenA(ctx);
+    await transportOpenB(ctx);
+    await aOffers(ctx, "offer-1");
+    await bAnswers(ctx, "answer-1");
+    expectInCall(ctx);
+
+    await bEnds(ctx);
+    expectLegStates(ctx, S.ENDING, S.CONNECTED);
+    expectMediaDisconnected(ctx, 1);
+    await aCompletesEnd(ctx, "end-answer-a");
+    expectEnded(ctx);
+});

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

@@ -24,6 +24,36 @@ function build({ offerSdp, answerSdp } = {}) {
     return { neg, signaling, session };
 }
 
+class MidStrictPeerConnection extends FakePeerConnection {
+    constructor(opts = {}) {
+        super(opts);
+        // Model werift's transceiver map keyed by negotiated mids.
+        this.transceivers = [{ kind: "application", mid: "0", setDirection() {}, sender: { replaceTrack: async () => {} } }];
+    }
+
+    addTrack(track) {
+        if (track?.kind === "audio" && !this.transceivers.find((t) => t.kind === "audio")) {
+            this.transceivers.push({
+                kind: "audio",
+                mid: "1",
+                setDirection() {},
+                sender: { replaceTrack: async () => {} },
+            });
+        }
+        return { kind: track?.kind || "audio" };
+    }
+
+    async setRemoteDescription(d) {
+        // Reproduces prod failure:
+        // "Transceiver with mid=1 not found" on redial offer after end/reuse.
+        const hasAudioTransceiver = this.transceivers.some((t) => t.kind === "audio" || t.mid === "1");
+        if (d?.type === "offer" && /a=mid:1/.test(d?.sdp || "") && !hasAudioTransceiver) {
+            throw new Error("Transceiver with mid=1 not found");
+        }
+        this.remoteDescription = d;
+    }
+}
+
 test("ring sends a signaling offer with the caller's bare label", async () => {
     const { neg, signaling } = build();
     await neg.ring({ from: "alice.secnum.global" });
@@ -253,3 +283,37 @@ test("callee leg connect without inviteCallee transport throws", async () => {
     });
     await assert.rejects(() => neg.connect({}), /no inviteCallee transport/);
 });
+
+test("BUG REPRO: redial offer after end/reuse must not fail on mid mismatch", async () => {
+    const signaling = new FakeSignaling();
+    const session = {
+        sessionId: "alice|bob",
+        callerEns: "alice.secnum.global",
+        toIdentity: "bob.secnum.global",
+        peerConnection: new MidStrictPeerConnection(),
+        localAudioTrack: null,
+    };
+    const neg = new WebRtcNegotiation({
+        id: "alice",
+        endpoint: "alice.secnum.global",
+        session,
+        signaling,
+        primitives: fakePrimitives(),
+        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";
+
+    // RED test first: today this throws exactly like prod logs.
+    await assert.doesNotReject(
+        () => neg.applyOffer({ mode: "ring", payload: { sdp: redialOfferWithAudioMid } }),
+        "redial offer should recover from transceiver mismatch instead of wedging",
+    );
+});

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

@@ -3,7 +3,7 @@ const assert = require("node:assert/strict");
 
 const { createPolyCore } = require("../createPolyCore");
 const { LEG_EVENTS, LEG_STATES: S } = require("../index");
-const { fakePrimitives, silentLogger } = require("./fakes");
+const { FakePeerConnection, fakePrimitives, silentLogger } = require("./fakes");
 
 // A fake MediaGraphFactory + per-leg transport store, to prove createPolyCore
 // assembles a working core end-to-end (resolve -> ingress -> reconcile -> media).
@@ -57,6 +57,79 @@ test("createPolyCore validates required deps", () => {
     assert.throws(() => createPolyCore({}), /mediaGraphFactory/);
 });
 
+test("createPolyCore callee connect chain: offer -> deferred connect -> transport-open rings callee", async () => {
+    const graphs = [];
+    const sent = [];
+    const outboundInvites = [];
+    const mediaGraphFactory = {
+        async startGraph({ id }) {
+            const g = { id, stopped: false, stop: async () => { g.stopped = true; } };
+            graphs.push(g);
+            return g;
+        },
+    };
+    const outboundInvite = async ({ callerSessionId, destination }) => {
+        outboundInvites.push({ callerSessionId, destination });
+        return {
+            sessionId: "bob-leg",
+            signalingSessionId: "alice|bob",
+            callerEns: "alice",
+            toIdentity: "bob",
+            peerConnection: new FakePeerConnection(),
+            dataChannel: { readyState: "open", send() {} },
+            iceCandidates: [],
+        };
+    };
+    const core = createPolyCore({
+        mediaGraphFactory,
+        webrtcPrimitives: fakePrimitives(),
+        makeSignalingTransport: ({ session, id }) => ({
+            send: (m) => sent.push({ session: session?.sessionId || id, m }),
+            isOpen: () => true,
+        }),
+        sipPort: { openOutbound: async () => {}, close: async () => {} },
+        outboundInvite,
+        logger: silentLogger,
+    });
+    const parties = {
+        a: {
+            endpoint: "alice",
+            kind: "webrtc",
+            session: {
+                sessionId: "alice",
+                callerEns: "alice",
+                toIdentity: "bob",
+                peerConnection: new FakePeerConnection(),
+                dataChannel: { readyState: "open", send() {} },
+                iceCandidates: [],
+            },
+        },
+        b: {
+            endpoint: "bob",
+            kind: "webrtc",
+            role: "callee",
+            destination: { wallet: "0x1234", ensName: "bob.global" },
+            callerSessionId: "alice",
+            session: { sessionId: "bob-leg" },
+        },
+        target: "alice",
+    };
+    const { poly } = core.registry.resolve(parties);
+
+    await poly.onIngress("a", { type: LEG_EVENTS.TRANSPORT_OPEN, payload: {} });
+    await poly.onIngress("a", { type: LEG_EVENTS.OFFER, payload: { sdp: "offer" } });
+    assert.equal(poly.legs.a.state, S.CALLING);
+    assert.equal(poly.legs.b.state, S.CONNECTING);
+    assert.equal(outboundInvites.length, 1, "callee connect triggers outbound invite once");
+
+    await poly.onIngress("b", { type: LEG_EVENTS.TRANSPORT_OPEN, payload: {} });
+    assert.equal(poly.legs.b.state, S.RINGING, "transport-open advances connecting callee to ringing");
+    assert.ok(
+        sent.some((x) => x.session === "bob-leg" && x.m?.msgType === "signaling" && x.m?.payload?.type === "offer"),
+        "callee ring offer is emitted on the callee signaling transport",
+    );
+});
+
 test("poly module index loads every public export", () => {
     const poly = require("../index");
     for (const name of [

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

@@ -0,0 +1,138 @@
+const assert = require("node:assert/strict");
+
+const { PolySession } = require("../../PolySession");
+const { LEG_EVENTS, makeLegEvent } = require("../../ports");
+const { LEG_STATES: S, canBeRung } = require("../../states");
+const { FakeMediaController, makeWebRtcLeg, silentLogger } = require("../fakes");
+
+function buildWebRtcScenario({ deferConnectA = false, deferConnectB = false } = {}) {
+    const a = makeWebRtcLeg("alice", { deferConnect: deferConnectA });
+    const b = makeWebRtcLeg("bob", { deferConnect: deferConnectB });
+    const media = new FakeMediaController();
+    const poly = new PolySession({
+        id: "alice<->bob",
+        legA: a.leg,
+        legB: b.leg,
+        mediaController: media,
+        logger: silentLogger,
+    });
+    return { poly, media, a, b };
+}
+
+async function transportOpenA(ctx) {
+    await ctx.poly.onIngress("a", makeLegEvent(LEG_EVENTS.TRANSPORT_OPEN));
+}
+
+async function transportOpenB(ctx) {
+    await ctx.poly.onIngress("b", makeLegEvent(LEG_EVENTS.TRANSPORT_OPEN));
+}
+
+async function aOffers(ctx, sdp = "offer-a") {
+    await ctx.poly.onIngress("a", makeLegEvent(LEG_EVENTS.OFFER, { sdp }));
+}
+
+async function bOffers(ctx, sdp = "offer-b") {
+    await ctx.poly.onIngress("b", makeLegEvent(LEG_EVENTS.OFFER, { sdp }));
+}
+
+async function aAnswers(ctx, sdp = "answer-a") {
+    await ctx.poly.onIngress("a", makeLegEvent(LEG_EVENTS.ANSWER, { sdp }));
+}
+
+async function bAnswers(ctx, sdp = "answer-b") {
+    await ctx.poly.onIngress("b", makeLegEvent(LEG_EVENTS.ANSWER, { sdp }));
+}
+
+async function aRejects(ctx) {
+    await ctx.poly.onIngress("a", makeLegEvent(LEG_EVENTS.REJECT));
+}
+
+async function bRejects(ctx) {
+    await ctx.poly.onIngress("b", makeLegEvent(LEG_EVENTS.REJECT));
+}
+
+async function aEnds(ctx) {
+    await ctx.poly.onIngress("a", makeLegEvent(LEG_EVENTS.END));
+}
+
+async function bEnds(ctx) {
+    await ctx.poly.onIngress("b", makeLegEvent(LEG_EVENTS.END));
+}
+
+async function aCompletesEnd(ctx, sdp = "end-answer-a") {
+    await ctx.poly.onIngress("a", makeLegEvent(LEG_EVENTS.END_RENEGOTIATION, { type: "answer", sdp }));
+}
+
+async function bCompletesEnd(ctx, sdp = "end-answer-b") {
+    await ctx.poly.onIngress("b", makeLegEvent(LEG_EVENTS.END_RENEGOTIATION, { type: "answer", sdp }));
+}
+
+function expectLegStates(ctx, expectedA, expectedB) {
+    assert.equal(ctx.a.leg.state, expectedA);
+    assert.equal(ctx.b.leg.state, expectedB);
+}
+
+function expectInCall(ctx) {
+    expectLegStates(ctx, S.IN_CALL, S.IN_CALL);
+}
+
+function expectRinging(ctx) {
+    expectLegStates(ctx, S.CALLING, S.RINGING);
+}
+
+function expectEnded(ctx) {
+    expectLegStates(ctx, S.CONNECTED, S.CONNECTED);
+}
+
+function expectReusable(ctx) {
+    assert.equal(canBeRung(ctx.a.leg.state), true, `leg a is not reusable: ${ctx.a.leg.state}`);
+    assert.equal(canBeRung(ctx.b.leg.state), true, `leg b is not reusable: ${ctx.b.leg.state}`);
+}
+
+function expectMediaConnectedOnce(ctx) {
+    assert.equal(ctx.media.connects.length, 1);
+}
+
+function expectMediaDisconnected(ctx, count = 1) {
+    assert.equal(ctx.media.disconnects.length, count);
+}
+
+function expectNoMedia(ctx) {
+    assert.equal(ctx.media.connects.length, 0);
+    assert.equal(ctx.media.disconnects.length, 0);
+}
+
+function expectRingAck(ctx, count = 1) {
+    assert.equal(ctx.a.negotiation.named("ackRing").length, count);
+}
+
+function expectHeldAnswerFlush(ctx, count = 1) {
+    assert.equal(ctx.a.negotiation.named("answer").length, count);
+}
+
+module.exports = {
+    S,
+    buildWebRtcScenario,
+    transportOpenA,
+    transportOpenB,
+    aOffers,
+    bOffers,
+    aAnswers,
+    bAnswers,
+    aRejects,
+    bRejects,
+    aEnds,
+    bEnds,
+    aCompletesEnd,
+    bCompletesEnd,
+    expectLegStates,
+    expectInCall,
+    expectRinging,
+    expectEnded,
+    expectReusable,
+    expectMediaConnectedOnce,
+    expectMediaDisconnected,
+    expectNoMedia,
+    expectRingAck,
+    expectHeldAnswerFlush,
+};

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

@@ -177,7 +177,18 @@ class WebRtcNegotiation extends CallNegotiationPort {
         if (audioDirection(offerSdp) === "inactive" && this.p.patchInactiveToSendrecv) {
             offerSdp = this.p.patchInactiveToSendrecv(offerSdp);
         }
-        await pc.setRemoteDescription(new this.p.RTCSessionDescription(offerSdp, "offer"));
+        if (!isIceRestart) this._ensureAudioReadyForOffer(offerSdp, pc);
+        try {
+            await pc.setRemoteDescription(new this.p.RTCSessionDescription(offerSdp, "offer"));
+        } catch (err) {
+            if (!isIceRestart && this._isMissingMidError(err) && this._offerHasAudioMLine(offerSdp)) {
+                // Recovery for reused sessions that retained DC but lost local m=audio mapping.
+                this._ensureAudioReadyForOffer(offerSdp, pc, { force: true });
+                await pc.setRemoteDescription(new this.p.RTCSessionDescription(offerSdp, "offer"));
+            } else {
+                throw err;
+            }
+        }
         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.
@@ -210,6 +221,27 @@ class WebRtcNegotiation extends CallNegotiationPort {
         this._pendingAnswerSdp = answerSdp;
     }
 
+    _offerHasAudioMLine(sdp = "") {
+        return /\bm=audio\b/.test(sdp);
+    }
+
+    _isMissingMidError(err) {
+        const msg = String(err?.message || "");
+        return /Transceiver with mid=\d+ not found/i.test(msg);
+    }
+
+    _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 (!this.session.localAudioTrack) {
+            this.session.localAudioTrack = new this.MediaStreamTrack({ kind: "audio" });
+        }
+        pc.addTrack?.(this.session.localAudioTrack);
+    }
+
     // The caller's client offered a ring and we are connected: ack it so the
     // client stops re-offering. The ios client needs an ack-for-ring here even
     // though, server-side, the peer is only being reached now. No persistent

package/webRTCservice/modules/server/HttpServer.js

@@ -61,14 +61,13 @@ function createPublicServer({
 }
 
 function createInternalServer({
-    tlsOptions,
     internalHttpPort,
     internalBindIp,
     handlers,
     sendJsonError,
     logger = console,
 }) {
-    const internalHandler = async (req, res) => {
+    const internalServer = http.createServer(async (req, res) => {
         logger.log(`[Internal] Incoming request: ${req.method} ${req.url} from ${req.socket.remoteAddress}`);
         if (req.method !== "POST") {
             sendJsonError(res, 404, "Not found");
@@ -79,11 +78,10 @@ function createInternalServer({
             return;
         }
         await handlers.handleInboundCall(req, res);
-    };
-    const internalServer = https.createServer(tlsOptions, internalHandler);
+    });
     function start() {
         internalServer.listen(internalHttpPort, internalBindIp, () => {
-            logger.log(`WebRTCManager internal HTTPS listening on ${internalBindIp}:${internalHttpPort}`);
+            logger.log(`WebRTCManager internal HTTP listening on ${internalBindIp}:${internalHttpPort}`);
         });
     }
     function stop() {
@@ -111,7 +109,6 @@ function createHttpServers({
         verifyExternalRequest,
     });
     const internalServer = createInternalServer({
-        tlsOptions,
         internalHttpPort,
         internalBindIp,
         handlers,

package/webRTCservice/webRTCmanager.js

@@ -159,34 +159,10 @@ const { WebSocket: WsWebSocket } = require("ws");
 
 // ─── Load config from config.json + services/*.json ──────────
 const PACKAGE_ROOT = path.resolve(__dirname, "..");
-function resolveFirstExistingPath(candidates) {
-    for (const p of candidates) {
-        if (p && fs.existsSync(p)) return p;
-    }
-    return "";
-}
-
-function normalizeInputPath(inputPath) {
-    if (!inputPath) return "";
-    return path.isAbsolute(inputPath) ? inputPath : path.resolve(process.cwd(), inputPath);
-}
-
-const CONFIG_PATH = resolveFirstExistingPath([
-    path.resolve(process.cwd(), "config", "config.json"),
-    path.resolve(process.cwd(), "config.json"),
-    path.join(PACKAGE_ROOT, "config", "config.json"),
-    path.join(PACKAGE_ROOT, "config.json"),
-]);
-if (!CONFIG_PATH) {
-    throw new Error(
-        `WebRTC config not found. Checked: ${[
-            path.resolve(process.cwd(), "config", "config.json"),
-            path.resolve(process.cwd(), "config.json"),
-            path.join(PACKAGE_ROOT, "config", "config.json"),
-            path.join(PACKAGE_ROOT, "config.json"),
-        ].filter(Boolean).join(", ")}`
-    );
-}
+const CONFIG_OVERRIDE = process.env.WEBRTC_CONFIG_PATH || process.env.ARNACON_WEBRTC_CONFIG_PATH || "";
+const CONFIG_PATH = CONFIG_OVERRIDE
+    ? (path.isAbsolute(CONFIG_OVERRIDE) ? CONFIG_OVERRIDE : path.resolve(process.cwd(), CONFIG_OVERRIDE))
+    : path.join(PACKAGE_ROOT, "config.json");
 const CONFIG_BASE_DIR = path.dirname(CONFIG_PATH);
 const fullConfig = JSON.parse(fs.readFileSync(CONFIG_PATH, "utf8"));
 const IVR_DEMO_AUDIO_DIR_RAW = process.env.IVR_DEMO_AUDIO_DIR || "demoAudio";
@@ -197,19 +173,9 @@ console.log(`[IVR-AUDIO] Demo audio directory: ${IVR_DEMO_AUDIO_DIR}`);
 const _deployEnvEarly = process.env.DEPLOY_ENV || "development";
 const _commonEarly = (fullConfig[_deployEnvEarly] || {}).common || {};
 const GLOBAL_CONFIG_OVERRIDE = process.env.WEBRTC_GLOBAL_CONFIG_PATH || process.env.ARNACON_WEBRTC_GLOBAL_CONFIG_PATH || "";
-const globalOverridePath = normalizeInputPath(GLOBAL_CONFIG_OVERRIDE);
-const GLOBAL_CONFIG_PATH = resolveFirstExistingPath([
-    globalOverridePath,
-    _commonEarly.globalServiceConfigPath
-        ? (_commonEarly.globalServiceConfigPath.startsWith("/")
-            ? _commonEarly.globalServiceConfigPath
-            : path.resolve(CONFIG_BASE_DIR, _commonEarly.globalServiceConfigPath))
-        : "",
-    path.resolve(process.cwd(), "config", "globalserviceconfig.json"),
-    path.resolve(process.cwd(), "globalserviceconfig.json"),
-    path.join(PACKAGE_ROOT, "config", "globalserviceconfig.json"),
-    path.join(PACKAGE_ROOT, "globalserviceconfig.json"),
-]);
+const GLOBAL_CONFIG_PATH = GLOBAL_CONFIG_OVERRIDE
+    ? (path.isAbsolute(GLOBAL_CONFIG_OVERRIDE) ? GLOBAL_CONFIG_OVERRIDE : path.resolve(process.cwd(), GLOBAL_CONFIG_OVERRIDE))
+    : (_commonEarly.globalServiceConfigPath || path.join(PACKAGE_ROOT, "globalserviceconfig.json"));
 let fullGlobalConfig = {};
 if (fs.existsSync(GLOBAL_CONFIG_PATH)) {
     fullGlobalConfig = JSON.parse(fs.readFileSync(GLOBAL_CONFIG_PATH, "utf8"));
@@ -272,11 +238,10 @@ function pickRuntimeConfig(key, fallback = undefined) {
 }
 
 const config = {
-    // Source-of-truth is this package config.json (or an on-host file-location override).
+    // Source-of-truth stays in Kamailio config.json (no duplication in globalserviceconfig.json).
     domain: commonConfig.domain,
     kamailioWssHost: commonConfig.kamailioWssHost,
     kamailioWssPort: commonConfig.kamailioWssPort,
-    kamailioWssScheme: commonConfig.kamailioWssScheme,
     bindIp: commonConfig.bindIp,
     tlsCertPath: commonConfig.tlsCertPath,
     roflBaseUrl: pickRuntimeConfig("roflBaseUrl"),
@@ -311,15 +276,9 @@ function getServiceRuntime(serviceId = null) {
 }
 
 // Kamailio SIP config
-// Transport scheme is configurable: env > config.json > default "wss".
-// Use "ws" only for trusted/co-located hops; "wss" for cross-host.
-const KAMAILIO_WSS_SCHEME = process.env.KAMAILIO_WSS_SCHEME || config.kamailioWssScheme || "wss";
-const KAMAILIO_WSS_HOST = process.env.KAMAILIO_WSS_HOST || config.kamailioWssHost || config.domain;
-const KAMAILIO_WSS_PORT = Number(process.env.KAMAILIO_WSS_PORT || config.kamailioWssPort || 8443);
-const KAMAILIO_WSS_URL = `${KAMAILIO_WSS_SCHEME}://${KAMAILIO_WSS_HOST}:${KAMAILIO_WSS_PORT}`;
+const KAMAILIO_WSS_URL = `ws://${config.kamailioWssHost || config.domain}:${config.kamailioWssPort}`;
 const KAMAILIO_DOMAIN = config.domain;
 const KAMAILIO_REGISTER_EXPIRES = 300;
-console.log(`[Startup] SIP WSS target: ${KAMAILIO_WSS_URL}`);
 
 const INTERNAL_BIND_IP = config.bindIp || "127.0.0.1";
 const OPENAI_SIP_CONFIG = {
@@ -922,7 +881,7 @@ for (const serviceRuntime of activeServiceRuntimes) {
     console.log(
         `[Startup] service=${serviceRuntime.id} provider=${serviceRuntime.providerId} deployEnv=${deployEnv} ` +
         `domain=${config.domain || ""} notifyPort=${serviceRuntime.notifyPort} ` +
-        `callbackPort=https:${serviceRuntime.callbackPort} domains=${configuredDomains}`,
+        `callbackPort=${serviceRuntime.callbackPort} domains=${configuredDomains}`,
     );
     const handlers = createHandlers({
         buildSignalingContextFromNotify,
@@ -1071,90 +1030,6 @@ function polyRefByEndpoint(poly, endpoint) {
 }
 
 // Resolve routing at the audio RING and create the PolySession for the pair.
-// Prepaid minute gate for an SBC/SIP outbound. Resolves the per-service budget
-// and asserts the caller may still start a call. Returns { allowed, settings,
-// identity }: allowed=false means the monthly cap is exhausted (the caller has
-// already been told to end). No active policy => allowed with settings=null.
-function checkSbcMinuteBudget({ session, callerSessionId, parsedFrom, serviceId }) {
-    const settings = minuteCounterPolicy.getSettings(serviceId);
-    const identity = minuteCounterPolicy.getIdentity(parsedFrom, session);
-    if (!minuteCounterApi || !settings?.limitSeconds) return { allowed: true, settings: null, identity };
-    try {
-        minuteCounterApi.assertCanStart({
-            serviceId: settings.serviceId,
-            identity,
-            limitSeconds: settings.limitSeconds,
-        });
-    } catch (err) {
-        console.log(`[${callerSessionId}] minute limit reached for ${identity}: ${err.message}`);
-        sendDataChannelMessage(callerSessionId, { msgType: "call", action: "end", reason: "minute-limit" });
-        return { allowed: false, settings, identity };
-    }
-    return { allowed: true, settings, identity };
-}
-
-// Service-side prepaid per-call cutoff. The minute counter owns the budget, so
-// we enforce the low-balance cap here instead of stamping a "Limit" SIP header
-// for the SIP proxy to enforce (SIPhon no longer carries that header). At answer
-// we arm a timer that BYEs both legs when the caller's remaining balance for THIS
-// call runs out, and we bill via the start/finish hooks. No-op without policy.
-function applySbcMinuteCap({ session, callerSessionId, poly, settings, identity }) {
-    if (!minuteCounterApi || !settings?.limitSeconds) return;
-
-    const clearCutoff = () => {
-        if (session._minuteCutoffTimer) {
-            clearTimeout(session._minuteCutoffTimer);
-            session._minuteCutoffTimer = null;
-        }
-    };
-
-    // Bill only the answered conversation: PolySession fires onCallStart when both
-    // legs reach IN_CALL and onCallEnd when they leave it -- so the counter starts
-    // at answer and stops on ANY end (hangup either side, failure, transport drop),
-    // independent of poly disposal/reuse. finish() is idempotent.
-    poly.setCallActivityHooks({
-        onCallStart: () => {
-            minuteCounterApi.start(session, {
-                serviceId: settings.serviceId,
-                identity,
-                limitSeconds: settings.limitSeconds,
-            });
-            // Remaining balance is measured at answer. Only a low-balance caller
-            // is capped per-call (mirrors the previous <300s Limit-header gate);
-            // higher balances are bounded across calls by assertCanStart().
-            const usedSeconds = minuteCounterApi.getUsedSeconds({
-                serviceId: settings.serviceId,
-                identity,
-            });
-            const remainingSeconds = settings.limitSeconds - usedSeconds;
-            clearCutoff();
-            if (remainingSeconds > 0 && remainingSeconds < 300) {
-                console.log(`[${callerSessionId}] low balance: capping call at ${remainingSeconds}s for ${identity}`);
-                session._minuteCutoffTimer = setTimeout(() => {
-                    session._minuteCutoffTimer = null;
-                    // Prepaid is the SIP/SBC leg's concern: the service decides this
-                    // leg is out of balance and ends the SIP (S) leg of the poly.
-                    // The S leg sets itself to ENDING (BYEs the SBC) and the poly
-                    // propagates the teardown to the caller leg.
-                    const sipRef = polySipRef(poly);
-                    if (!sipRef) {
-                        console.warn(`[${callerSessionId}] minute cap reached but poly has no SIP leg -- skipping`);
-                        return;
-                    }
-                    console.log(`[${callerSessionId}] minute cap reached (${remainingSeconds}s) -- ending SIP leg for ${identity}`);
-                    poly.onIngress(sipRef, makeLegEvent(LEG_EVENTS.END)).catch((err) => {
-                        console.error(`[${callerSessionId}] minute-cap hangup failed: ${err.message}`);
-                    });
-                }, remainingSeconds * 1000);
-            }
-        },
-        onCallEnd: () => {
-            clearCutoff();
-            minuteCounterApi.finish(session);
-        },
-    });
-}
-
 async function onDcRing(callerSessionId, payload) {
     const session = sessions.get(callerSessionId);
     if (!session || !session.peerConnection) return;
@@ -1174,9 +1049,6 @@ async function onDcRing(callerSessionId, payload) {
 
     const a = { endpoint: session.callerEns, kind: "webrtc", session };
     let b;
-    // Minute metering is SBC/PSTN-outbound only; resolved in the sip branch below.
-    let minuteCounterSettings = null;
-    let minuteCounterIdentity = null;
     if (destination.route === "webrtc") {
         b = {
             endpoint: destination.ensName || destination.wallet,
@@ -1214,21 +1086,9 @@ async function onDcRing(callerSessionId, payload) {
             kind: "sip",
             session,
         };
-
-        // Minute metering for SBC/PSTN outbound. The poly cutover orphaned the
-        // legacy SbcRouteStrategy where start()/assertCanStart() lived, so gate on
-        // the per-service monthly cap here at SIP-leg origination. The cap header +
-        // billing hooks are applied below once the poly exists.
-        const budget = checkSbcMinuteBudget({ session, callerSessionId, parsedFrom, serviceId });
-        if (!budget.allowed) return;
-        minuteCounterSettings = budget.settings;
-        minuteCounterIdentity = budget.identity;
     }
 
     const { poly } = polyRegistry.resolve({ a, b, target: "a" });
-    if (b.kind === "sip") {
-        applySbcMinuteCap({ session, callerSessionId, poly, settings: minuteCounterSettings, identity: minuteCounterIdentity });
-    }
     // 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
     // callee, by contrast, starts disconnected: reconcile will connect() it (FCM
@@ -1324,19 +1184,6 @@ function onDataChannelMessage(sessionId, rawMessage, meta = {}) {
             });
             return;
         }
-        // Reused poly: the caller is redialing over its live transport, so onDcRing
-        // (and its minute gate) is bypassed. Re-run the prepaid gate here for SBC/SIP
-        // redials so an out-of-balance caller is blocked and the per-call cutoff
-        // timer is re-armed every call -- not just the first. Otherwise a stale cap
-        // (or none) from a prior call would carry over on the reused poly.
-        const sipRef = polySipRef(existing);
-        if (sipRef) {
-            const serviceId = session.serviceId || null;
-            const parsedFrom = parseAddress(session.callerEns, serviceId);
-            const budget = checkSbcMinuteBudget({ session, callerSessionId: sessionId, parsedFrom, serviceId });
-            if (!budget.allowed) return;
-            applySbcMinuteCap({ session, callerSessionId: sessionId, poly: existing, settings: budget.settings, identity: budget.identity });
-        }
     }
 
     const poly = polyForSession(session);

package/config.json

@@ -1,24 +0,0 @@
-{
-  "development": {
-    "common": {
-      "domain": "test2.cellact.nl",
-      "kamailioWssHost": "test2.cellact.nl",
-      "kamailioWssPort": 8443,
-      "kamailioWssScheme": "wss",
-      "bindIp": "0.0.0.0",
-      "tlsCertPath": "/etc/letsencrypt/live/test2.cellact.nl",
-      "globalServiceConfigPath": "./globalserviceconfig.json"
-    }
-  },
-  "production": {
-    "common": {
-      "domain": "ron1.cellact.nl",
-      "kamailioWssHost": "ron1.cellact.nl",
-      "kamailioWssPort": 8443,
-      "kamailioWssScheme": "wss",
-      "bindIp": "0.0.0.0",
-      "tlsCertPath": "/etc/letsencrypt/live/ron1.cellact.nl",
-      "globalServiceConfigPath": "./globalserviceconfig.json"
-    }
-  }
-}