ulai-js-sdk 0.1.1 → 0.1.2

package/dist/room.d.ts

@@ -13,10 +13,12 @@ export declare class Room extends EventEmitter<RoomEvent> {
     private readonly isPolite;
     private makingOffer;
     private candidateQueue;
+    private signalQueue;
     constructor(cpBase: string);
     connect(options: JoinRoomOptions): Promise<void>;
     private setupEventsClient;
     private setupSignaling;
+    private handleSignal;
     private safeNegotiate;
     private handleIncomingCandidate;
     private drainCandidateQueue;

package/dist/room.js

@@ -21,6 +21,9 @@ class Room extends eventemitter3_1.default {
     isPolite = true;
     makingOffer = 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.
+    signalQueue = Promise.resolve();
     constructor(cpBase) {
         super();
         this.cpBase = cpBase;
@@ -45,6 +48,12 @@ class Room extends eventemitter3_1.default {
                 ? options.iceServers
                 : defaultIceServers;
             this.peerConnection = new RTCPeerConnection({ iceServers });
+            // Every local change that needs an offer (the initial transceiver, publishing the mic, an
+            // offer rolled back by a collision) fires this. Offers sent before signaling opens wait in
+            // its outbox.
+            this.peerConnection.onnegotiationneeded = () => {
+                void this.safeNegotiate();
+            };
             // Pre-allocate audio transceiver as recvonly so the initial offer immediately
             // negotiates audio codec capabilities (m=audio) and is ready for agent downlink.
             try {
@@ -112,73 +121,83 @@ class Room extends eventemitter3_1.default {
     setupSignaling() {
         if (!this.signaling)
             return;
-        this.signaling.on('connected', async () => {
-            // Initiate negotiation when signaling is ready
-            await this.safeNegotiate();
-        });
+        // The initial offer comes from onnegotiationneeded and is flushed from the outbox on connect.
         this.signaling.on('reconnected', async () => {
             this.emit('reconnected');
             await this.safeNegotiate();
         });
-        this.signaling.on('message', async (msg) => {
-            if (!this.peerConnection)
-                return;
-            try {
-                if (msg.type === 'offer' || msg.type === 'restart-offer') {
-                    // Perfect negotiation: detect collision (SDP Glare)
-                    const offerCollision = this.makingOffer || this.peerConnection.signalingState !== 'stable';
-                    if (offerCollision && !this.isPolite) {
-                        console.warn('[Room] Impolite collision: ignoring incoming offer');
-                        return;
-                    }
-                    if (offerCollision && this.isPolite) {
-                        // Polite peer: rollback local offer to accept the incoming server offer
-                        console.log('[Room] Polite collision: rolling back local offer to accept server offer');
-                        await this.peerConnection.setLocalDescription({ type: 'rollback' });
-                    }
-                    if (msg.sdp) {
-                        await this.peerConnection.setRemoteDescription(new RTCSessionDescription({ type: 'offer', sdp: msg.sdp }));
-                        await this.drainCandidateQueue();
-                        const answer = await this.peerConnection.createAnswer();
-                        await this.peerConnection.setLocalDescription(answer);
-                        this.signaling.send({
-                            type: 'answer',
-                            sdp: this.peerConnection.localDescription?.sdp,
-                        });
-                    }
+        this.signaling.on('message', (msg) => {
+            this.signalQueue = this.signalQueue.then(() => this.handleSignal(msg));
+        });
+        this.signaling.on('disconnected', () => {
+            this.emit('disconnected');
+        });
+    }
+    async handleSignal(msg) {
+        const pc = this.peerConnection;
+        if (!pc)
+            return;
+        try {
+            if (msg.type === 'offer' || msg.type === 'restart-offer') {
+                if (!msg.sdp)
+                    return;
+                // Perfect negotiation: detect collision (SDP Glare)
+                const offerCollision = this.makingOffer || pc.signalingState !== 'stable';
+                if (offerCollision && !this.isPolite) {
+                    console.warn('[Room] Impolite collision: ignoring incoming offer');
+                    return;
                 }
-                else if (msg.type === 'answer') {
-                    if (msg.sdp) {
-                        await this.peerConnection.setRemoteDescription(new RTCSessionDescription({ type: 'answer', sdp: msg.sdp }));
-                        await this.drainCandidateQueue();
-                    }
+                if (offerCollision) {
+                    console.log('[Room] Polite collision: rolling back local offer to accept server offer');
                 }
-                else if (msg.type === 'candidate' && msg.candidate) {
-                    const candidateInit = JSON.parse(msg.candidate);
-                    await this.handleIncomingCandidate(candidateInit);
+                // 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
+                // the bridge sends its answer and then its own offer right away (someone already talking),
+                // and the bridge's offer was dropped. Whatever our offer carried is offered again via
+                // negotiationneeded once we're back to stable.
+                await pc.setRemoteDescription({ type: 'offer', sdp: msg.sdp });
+                await this.drainCandidateQueue();
+                await pc.setLocalDescription();
+                this.signaling?.send({
+                    type: 'answer',
+                    sdp: pc.localDescription?.sdp,
+                });
+            }
+            else if (msg.type === 'answer') {
+                if (!msg.sdp)
+                    return;
+                // An answer to an offer we've since rolled back has nothing to apply to.
+                if (pc.signalingState !== 'have-local-offer') {
+                    console.warn('[Room] Ignoring answer in signalingState', pc.signalingState);
+                    return;
                 }
+                await pc.setRemoteDescription({ type: 'answer', sdp: msg.sdp });
+                await this.drainCandidateQueue();
             }
-            catch (err) {
-                console.error('[Room] Error handling signaling message:', err);
-                this.emit('error', err);
+            else if (msg.type === 'candidate' && msg.candidate) {
+                const candidateInit = JSON.parse(msg.candidate);
+                await this.handleIncomingCandidate(candidateInit);
             }
-        });
-        this.signaling.on('disconnected', () => {
-            this.emit('disconnected');
-        });
+        }
+        catch (err) {
+            console.error('[Room] Error handling signaling message:', err);
+            this.emit('error', err);
+        }
     }
     async safeNegotiate() {
         if (!this.peerConnection || this.makingOffer)
             return;
+        // Mid-negotiation, setLocalDescription() would make an answer, not an offer. negotiationneeded
+        // fires again once the current exchange completes.
+        if (this.peerConnection.signalingState !== 'stable')
+            return;
         try {
             this.makingOffer = true;
-            const offer = await this.peerConnection.createOffer();
-            // Only set local description if signalingState is stable
-            if (this.peerConnection.signalingState !== 'stable') {
-                console.warn('[Room] Skip makeOffer: signalingState is', this.peerConnection.signalingState);
-                return;
-            }
-            await this.peerConnection.setLocalDescription(offer);
+            // 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
             this.signaling?.send({
                 type: 'offer',
                 sdp: this.peerConnection.localDescription?.sdp,
@@ -251,8 +270,7 @@ class Room extends eventemitter3_1.default {
                         this.peerConnection.addTrack(audioTrack, this.localStream);
                     }
                 }
-                // Trigger safe renegotiation
-                await this.safeNegotiate();
+                // The direction change (or addTrack) fires negotiationneeded, which sends the offer.
             }
             return this.localStream;
         }

package/package.json

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