ulai-js-sdk 0.1.4 → 0.1.5

package/dist/room.d.ts

@@ -12,6 +12,7 @@ export declare class Room extends EventEmitter<RoomEvent> {
     participantId: string | null;
     private readonly isPolite;
     private makingOffer;
+    private negotiationOwed;
     private candidateQueue;
     private signalQueue;
     constructor(cpBase: string);
@@ -20,6 +21,8 @@ export declare class Room extends EventEmitter<RoomEvent> {
     private setupSignaling;
     private handleSignal;
     private safeNegotiate;
+    /** Makes an offer that was skipped earlier, once nothing else is being negotiated. */
+    private settleOwedNegotiation;
     private handleIncomingCandidate;
     private drainCandidateQueue;
     /**

package/dist/room.js

@@ -20,6 +20,10 @@ class Room extends eventemitter3_1.default {
     // Perfect Negotiation State (Client is the polite peer)
     isPolite = true;
     makingOffer = false;
+    // An offer we still owe the bridge: a negotiationneeded we had to skip, or an offer of ours that a
+    // colliding bridge offer rolled back. The browser fires negotiationneeded only when its flag turns
+    // on, so it won't reliably come again for either: we have to remember to make the offer ourselves.
+    negotiationOwed = false;
     candidateQueue = [];
     // Signaling messages are handled one at a time, in arrival order. Handled concurrently, a bridge
     // offer could be processed in the middle of our own offer and dropped.
@@ -149,6 +153,9 @@ class Room extends eventemitter3_1.default {
                 }
                 if (offerCollision) {
                     console.log('[Room] Polite collision: rolling back local offer to accept server offer');
+                    // Whatever our offer carried (the mic, typically) is lost with it, and the browser doesn't
+                    // reliably fire negotiationneeded again, so offer it again once this exchange is done.
+                    this.negotiationOwed = true;
                 }
                 // On a collision this implicitly rolls back our own offer, even one still being made. An
                 // explicit rollback throws if we're stable by the time it runs, which is what happens when
@@ -162,6 +169,7 @@ class Room extends eventemitter3_1.default {
                     type: 'answer',
                     sdp: pc.localDescription?.sdp,
                 });
+                this.settleOwedNegotiation();
             }
             else if (msg.type === 'answer') {
                 if (!msg.sdp)
@@ -173,6 +181,7 @@ class Room extends eventemitter3_1.default {
                 }
                 await pc.setRemoteDescription({ type: 'answer', sdp: msg.sdp });
                 await this.drainCandidateQueue();
+                this.settleOwedNegotiation();
             }
             else if (msg.type === 'candidate' && msg.candidate) {
                 const candidateInit = JSON.parse(msg.candidate);
@@ -185,22 +194,28 @@ class Room extends eventemitter3_1.default {
         }
     }
     async safeNegotiate() {
-        if (!this.peerConnection || this.makingOffer)
+        const pc = this.peerConnection;
+        if (!pc)
             return;
-        // Mid-negotiation, setLocalDescription() would make an answer, not an offer. negotiationneeded
-        // fires again once the current exchange completes.
-        if (this.peerConnection.signalingState !== 'stable')
+        // Mid-negotiation we can't offer: setLocalDescription() would make an answer, or race our own
+        // offer. Remember it instead; settleOwedNegotiation() makes the offer once we're stable again.
+        if (this.makingOffer || pc.signalingState !== 'stable') {
+            this.negotiationOwed = true;
             return;
+        }
+        this.negotiationOwed = false;
         try {
             this.makingOffer = true;
             // Without an argument the offer is created when it's applied, so it can't go stale against
             // an offer from the bridge that arrives meanwhile.
-            await this.peerConnection.setLocalDescription();
-            if (this.peerConnection.pendingLocalDescription?.type !== 'offer')
-                return; // rolled back
+            await pc.setLocalDescription();
+            if (pc.pendingLocalDescription?.type !== 'offer') {
+                this.negotiationOwed = true; // rolled back by a bridge offer; make it again afterwards
+                return;
+            }
             this.signaling?.send({
                 type: 'offer',
-                sdp: this.peerConnection.localDescription?.sdp,
+                sdp: pc.localDescription?.sdp,
             });
         }
         catch (err) {
@@ -208,6 +223,13 @@ class Room extends eventemitter3_1.default {
         }
         finally {
             this.makingOffer = false;
+            this.settleOwedNegotiation();
+        }
+    }
+    /** Makes an offer that was skipped earlier, once nothing else is being negotiated. */
+    settleOwedNegotiation() {
+        if (this.negotiationOwed && !this.makingOffer && this.peerConnection?.signalingState === 'stable') {
+            void this.safeNegotiate();
         }
     }
     async handleIncomingCandidate(candidate) {
@@ -270,7 +292,10 @@ class Room extends eventemitter3_1.default {
                         this.peerConnection.addTrack(audioTrack, this.localStream);
                     }
                 }
-                // The direction change (or addTrack) fires negotiationneeded, which sends the offer.
+                // Offer the mic ourselves rather than waiting for negotiationneeded: when this runs while an
+                // exchange is in progress (e.g. the bridge offering us someone already talking), the browser
+                // may never fire it. If something is being negotiated, this is made as soon as it's done.
+                void this.safeNegotiate();
             }
             return this.localStream;
         }
@@ -326,6 +351,7 @@ class Room extends eventemitter3_1.default {
         }
         this.audioTransceiver = null;
         this.candidateQueue = [];
+        this.negotiationOwed = false;
         this.remoteStreams.clear();
         if (this.signaling) {
             this.signaling.close();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ulai-js-sdk",
-  "version": "0.1.4",
+  "version": "0.1.5",
   "description": "Ulai Cloud JS/TS Client SDK for WebRTC Sessions",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",