openrtc-netcode 3.0.1 → 3.0.2

package/dist/voice.js

@@ -11,6 +11,8 @@ export class NetcodeVoiceController {
         this.localMediaStream = null;
         this.options = {};
         this.active = false;
+        this.generation = 0;
+        this.starting = null;
         this.muted = false;
     }
     get enabled() {
@@ -30,41 +32,61 @@ export class NetcodeVoiceController {
         }));
     }
     async start(options = {}) {
+        if (this.starting)
+            return this.starting;
         if (this.active && this.localMediaStream)
             return this.localMediaStream;
-        this.options = options;
-        const localStream = options.mediaStream ?? await this.captureAudio(options);
-        this.localMediaStream = localStream;
-        this.active = true;
-        this.applyMuteState();
-        this.emitter.emit('local:stream', localStream);
-        const localPeerId = this.localPeerId();
-        if (localPeerId) {
+        const generation = ++this.generation;
+        const opening = (async () => {
+            const localStream = options.mediaStream ?? await this.captureAudio(options);
+            if (generation !== this.generation) {
+                if (!options.mediaStream || options.stopTracksOnStop !== false) {
+                    for (const track of localStream.getTracks())
+                        track.stop();
+                }
+                throw new Error('Voice start was superseded by stop.');
+            }
+            this.options = options;
+            this.localMediaStream = localStream;
+            this.active = true;
+            this.applyMuteState();
+            this.emitter.emit('local:stream', localStream);
             try {
-                await Promise.all(this.peers()
-                    .filter((peer) => peer.connected)
-                    .map((peer) => this.startPeerSession(peer.id)));
+                if (this.localPeerId())
+                    await Promise.all(this.peers()
+                        .filter((peer) => peer.connected).map((peer) => this.startPeerSession(peer.id)));
             }
             catch (error) {
-                await this.stop();
+                if (generation === this.generation)
+                    await this.stop();
                 throw error;
             }
-        }
-        if (!this.active || this.localMediaStream !== localStream) {
-            throw new Error('Voice start was superseded by stop.');
-        }
-        return localStream;
+            if (generation !== this.generation)
+                throw new Error('Voice start was superseded by stop.');
+            return localStream;
+        })().finally(() => { if (this.starting === opening)
+            this.starting = null; });
+        this.starting = opening;
+        return opening;
     }
     async stop() {
+        this.generation++;
+        this.starting = null;
         this.active = false;
+        const localStream = this.localMediaStream;
+        const stopTracks = this.options.stopTracksOnStop !== false;
+        this.localMediaStream = null;
+        const generation = this.generation;
         const current = [...this.sessions.keys()].map((peerId) => this.closePeerSession(peerId));
         await Promise.allSettled([...current, ...this.closingSessions]);
-        if (this.options.stopTracksOnStop !== false) {
-            for (const track of this.localMediaStream?.getTracks() ?? [])
-                track.stop();
-        }
-        this.localMediaStream = null;
-        this.emitter.emit('peers', []);
+        const retainedTracks = new Set(this.localStream?.getTracks() ?? []);
+        if (stopTracks)
+            for (const track of localStream?.getTracks() ?? []) {
+                if (!retainedTracks.has(track))
+                    track.stop();
+            }
+        if (generation === this.generation)
+            this.emitter.emit('peers', []);
     }
     setMuted(muted) {
         this.muted = muted;
@@ -79,18 +101,24 @@ export class NetcodeVoiceController {
             await this.startPeerSession(peerId);
     }
     handlePeerDisconnected(peerId) {
-        this.trackClosing(this.closePeerSession(peerId));
+        void this.closePeerSession(peerId);
     }
     async startPeerSession(peerId) {
         const connection = this.connectionForPeer(peerId);
         const localStream = this.localMediaStream;
-        if (!connection || !localStream)
+        if (!connection || !localStream || !this.active || Boolean(connection.isClosed))
             return;
-        const existing = this.sessions.get(peerId);
-        if (existing?.connection === connection)
-            return;
-        if (existing)
+        while (true) {
+            if (!this.active || this.localMediaStream !== localStream || this.connectionForPeer(peerId) !== connection || Boolean(connection.isClosed))
+                return;
+            const existing = this.sessions.get(peerId);
+            if (existing?.connection === connection)
+                return;
+            if (!existing)
+                break;
             await this.closePeerSession(peerId, false);
+            // Another notification may have installed its session while removal awaited.
+        }
         const session = {
             peerId,
             connection,
@@ -98,20 +126,30 @@ export class NetcodeVoiceController {
             remoteStream: null,
             stopListening: () => undefined,
         };
+        this.sessions.set(peerId, session);
         session.stopListening = connection.media.onTrack((event) => {
-            session.remoteStream = event.streams[0] ?? null;
+            if (!this.active || this.sessions.get(peerId) !== session || event.track.kind !== 'audio')
+                return;
+            session.remoteStream = event.streams[0] ?? (typeof MediaStream !== 'undefined' ? new MediaStream([event.track]) : null);
             if (session.remoteStream) {
                 this.emitter.emit('peer:stream', { peerId, stream: session.remoteStream });
             }
             this.emitter.emit('peers', this.listPeers());
         });
-        this.sessions.set(peerId, session);
+        // Publication can precede local microphone enable. Subscribe first, then
+        // project the media owner's existing receivers rather than losing that track.
+        const tracks = [...new Set(connection.media.receivers?.().map((receiver) => receiver.track)
+                .filter((track) => track.kind === 'audio' && track.readyState === 'live') ?? [])];
+        if (!session.remoteStream && tracks.length && typeof MediaStream !== 'undefined') {
+            session.remoteStream = new MediaStream(tracks);
+            this.emitter.emit('peer:stream', { peerId, stream: session.remoteStream });
+        }
         this.emitter.emit('peers', this.listPeers());
         try {
             await Promise.resolve();
             for (const track of localStream.getAudioTracks()) {
                 const sender = await connection.media.addTrack(track, { streams: [localStream] });
-                if (this.sessions.get(peerId) !== session || !this.active || connection.isClosed === true) {
+                if (this.sessions.get(peerId) !== session || !this.active || Boolean(connection.isClosed)) {
                     await connection.media.removeTrack(sender);
                     return;
                 }
@@ -128,17 +166,21 @@ export class NetcodeVoiceController {
             throw error;
         }
     }
-    async closePeerSession(peerId, emit = true) {
+    closePeerSession(peerId, emit = true) {
         const session = this.sessions.get(peerId);
         if (!session)
-            return;
+            return Promise.resolve();
         this.sessions.delete(peerId);
         session.stopListening();
-        await Promise.allSettled(session.senders.map((sender) => session.connection.media.removeTrack(sender)));
-        if (emit) {
-            this.emitter.emit('peer:left', { peerId });
-            this.emitter.emit('peers', this.listPeers());
-        }
+        const closing = Promise.allSettled(session.senders.map((sender) => session.connection.media.removeTrack(sender))).then(() => {
+            if (emit) {
+                if (!this.sessions.has(peerId))
+                    this.emitter.emit('peer:left', { peerId });
+                this.emitter.emit('peers', this.listPeers());
+            }
+        });
+        this.trackClosing(closing);
+        return closing;
     }
     trackClosing(operation) {
         this.closingSessions.add(operation);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openrtc-netcode",
-  "version": "3.0.1",
+  "version": "3.0.2",
   "private": false,
   "type": "module",
   "sideEffects": false,
@@ -42,7 +42,7 @@
     "test:watch": "vitest"
   },
   "dependencies": {
-    "openrtc": "^3.0.1"
+    "openrtc": "^3.0.2"
   },
   "devDependencies": {
     "@types/node": "^24.10.1",