@voltkit-rtc/client 0.7.1 → 0.7.3

package/src/broadcast.ts

@@ -66,6 +66,9 @@ const ICE_GATHER_TIMEOUT_MS = 3_000;
 /** Helper formats that ride along with a codec. Not codecs in their own right. */
 const HELPER_FORMATS = new Set(['video/rtx', 'video/red', 'video/ulpfec', 'video/flexfec-03']);
 
+/** Why a start() gave up: stop() ran while it was under way, and stop wins. */
+const stoppedWhileStarting = () => new DOMException('the broadcast was stopped while it was starting', 'AbortError');
+
 /**
  * Send an SDP offer to a WHIP endpoint and return the answer, plus the session
  * resource the server names for ending it.
@@ -149,6 +152,16 @@ export class BroadcastPublisher {
   private micOn = true;
   private current: BroadcastState = 'idle';
   private readonly listeners = new Map<string, Set<Handler>>();
+  /**
+   * Bumped by every start() and stop(). A start compares it after each wait:
+   * once stop() has run, that start is over, and what it was waiting for
+   * (a camera, the media server's answer) arrives to be released, never
+   * adopted -- otherwise a stopped broadcast went on air anyway, or tore
+   * down the one started after it.
+   */
+  private operation = 0;
+  /** The start() under way, by its operation; a second one is refused meanwhile. */
+  private starting: number | null = null;
 
   constructor(private readonly whipUrl: string) {}
 
@@ -187,15 +200,27 @@ export class BroadcastPublisher {
     this.emit('state', state);
   }
 
-  /** Go on air. Resolves once the media server has accepted the stream. */
+  /**
+   * Go on air. Resolves once the media server has accepted the stream.
+   * Rejects with an `AbortError` when `stop()` runs first: a camera captured
+   * for it afterwards is released, and a session the server opened for it is
+   * ended.
+   */
   async start(options: BroadcastStartOptions = {}): Promise<MediaStream> {
-    if (this.pc) throw new Error('already publishing; call stop() first');
+    if (this.pc || this.starting !== null) throw new Error('already publishing; call stop() first');
+    const operation = ++this.operation;
+    this.starting = operation;
+    const stopped = () => operation !== this.operation;
+    const owns = !options.stream;
+    let captured: MediaStream | null = null;
     this.set('connecting');
     try {
-      this.ownsMedia = !options.stream;
       const media = options.stream ?? await navigator.mediaDevices.getUserMedia(
         options.constraints ?? { audio: true, video: { width: 1280, height: 720 } },
       );
+      captured = media;
+      if (stopped()) throw stoppedWhileStarting();
+      this.ownsMedia = owns;
       this.media = media;
 
       const pc = new RTCPeerConnection();
@@ -225,17 +250,34 @@ export class BroadcastPublisher {
 
       await pc.setLocalDescription(await pc.createOffer());
       await iceGathered(pc);
+      if (stopped()) throw stoppedWhileStarting();
       const offerSdp = pc.localDescription?.sdp;
       if (!offerSdp) throw new WhipError(0, 'could not create an offer in this browser');
 
       const answer = await whipOffer(this.whipUrl, offerSdp);
+      if (stopped()) {
+        // The server opened a session for a start that is over: end it, as
+        // stop() would have, had it known of it.
+        if (answer.resource) void whipEnd(answer.resource);
+        throw stoppedWhileStarting();
+      }
       this.resource = answer.resource;
       await pc.setRemoteDescription({ type: 'answer', sdp: answer.answerSdp });
+      if (stopped()) throw stoppedWhileStarting();
       return media;
     } catch (err) {
+      if (stopped()) {
+        // stop() released what this start had handed over, and a newer
+        // start() may be on air now: only what arrived after stop() is ours
+        // to release here.
+        if (owns && captured) for (const t of captured.getTracks()) t.stop();
+        throw stoppedWhileStarting();
+      }
       this.teardown();
       this.set('failed');
       throw err;
+    } finally {
+      if (this.starting === operation) this.starting = null;
     }
   }
 
@@ -317,8 +359,14 @@ export class BroadcastPublisher {
     for (const t of this.media?.getVideoTracks() ?? []) t.enabled = enabled;
   }
 
-  /** Go off air and release the camera and microphone. Idempotent. */
+  /**
+   * Go off air and release the camera and microphone. Idempotent. A start()
+   * still under way is over: it rejects with an `AbortError`, and you can
+   * start again at once.
+   */
   async stop(): Promise<void> {
+    this.operation += 1;
+    this.starting = null;
     const resource = this.resource;
     this.teardown();
     if (resource) await whipEnd(resource);

package/src/chat.ts

@@ -93,6 +93,8 @@ interface Pending {
   resolve: (v: unknown) => void;
   reject: (e: Error) => void;
   timer: ReturnType<typeof setTimeout>;
+  /** The socket it was sent on: only that socket can answer it. */
+  ws: WebSocket;
 }
 
 const RPC_TIMEOUT_MS = 15_000;
@@ -154,15 +156,21 @@ export class ChatClient {
   async connect(): Promise<ChatJoinResult> {
     const lifecycle = this.lifecycle;
     let result: ChatJoinResult;
+    // The socket this call opens. A later connect() replaces it, and this
+    // call's failure must then leave the newer socket alone.
+    let socket: WebSocket | null = null;
     try {
-      await this.openSocket();
+      const opening = this.openSocket();
+      socket = this.ws;
+      await opening;
       result = (await this.rpc('join', { token: this.token })) as ChatJoinResult;
       if (lifecycle !== this.lifecycle) throw new Error('the chat was closed while connecting');
     } catch (err) {
       // Never joined: the app has the error. Left open, the socket would be
       // closed by the server's join deadline, and that would start
       // reconnecting a session that never began.
-      if (!this.joinedOnce) this.detachSocket();
+      const superseded = this.ws !== null && this.ws !== socket;
+      if (!this.joinedOnce && !superseded) this.detachSocket();
       throw err;
     }
     // Joined: the next drop gets every reconnect attempt again. Not when the
@@ -210,16 +218,20 @@ export class ChatClient {
     });
   }
 
-  private detachSocket(reason = 'superseded'): void {
+  private detachSocket(reason = 'superseded', why = 'the connection was replaced'): void {
     const ws = this.ws;
     this.ws = null;
-    if (ws && ws.readyState <= WebSocket.OPEN) {
+    if (!ws) return;
+    if (ws.readyState <= WebSocket.OPEN) {
       try {
         ws.close(1000, reason);
       } catch {
         /* already closing */
       }
     }
+    // Its replies are no longer read: what waits on it fails now instead of
+    // waiting out its timeout. Never replayed.
+    this.failPending(ws, new Error(why));
   }
 
   /**
@@ -228,7 +240,7 @@ export class ChatClient {
    * closed.
    */
   private releaseSocket(): void {
-    this.detachSocket('gave up');
+    this.detachSocket('gave up', 'the chat has ended');
     this.failAllPending(new Error('the chat has ended'));
   }
 
@@ -301,11 +313,21 @@ export class ChatClient {
         this.pending.delete(id);
         reject(new Error(`${method} timed out`));
       }, RPC_TIMEOUT_MS);
-      this.pending.set(id, { resolve, reject, timer });
+      this.pending.set(id, { resolve, reject, timer, ws: this.ws });
       this.ws.send(JSON.stringify({ id, method, params }));
     });
   }
 
+  /** Fail what was sent on `ws` and is still waiting. */
+  private failPending(ws: WebSocket, err: Error): void {
+    for (const [id, p] of this.pending) {
+      if (p.ws !== ws) continue;
+      clearTimeout(p.timer);
+      this.pending.delete(id);
+      p.reject(err);
+    }
+  }
+
   private failAllPending(err: Error): void {
     for (const p of this.pending.values()) {
       clearTimeout(p.timer);