@voltkit-rtc/client 0.7.0 → 0.7.1

package/src/index.ts

@@ -436,6 +436,9 @@ const isLayer = (value: unknown): value is number => Number.isInteger(value) &&
  */
 const VIDEO_START_BITRATE_KBPS = 2000;
 
+/** Why a connect() gave up: close() ran while it was under way, and close wins. */
+const closedWhileConnecting = () => new RpcError('not-connected', 'the session was closed while connecting');
+
 /** Why a publish gave up: unpublish() ran while it was under way, and unpublish wins. */
 const unpublishedWhile = (what: string) => new RpcError('unpublished', `the ${what} was unpublished while it was being published`);
 
@@ -510,7 +513,15 @@ export class StreamClient {
    * the full picture.
    */
   private readonly preferredLayers = new Map<string, PreferredLayers>();
+  /** endRoom() calls waiting for their reply; a roomClosed that arrives first answers them. */
+  private readonly endRoomWaiters = new Set<() => void>();
   private closedByUs = false;
+  /**
+   * Bumped when the session ends for good: close(), or finish(). A connect()
+   * under way when it did -- the app's, or a reconnect's -- sees the change
+   * after its next await and stops, so a closed session never comes back.
+   */
+  private lifecycle = 0;
   private reconnecting = false;
   private reconnectAttempt = 0;
   /** Set once a connect() has joined and set up. Only such a session is reconnected. */
@@ -597,6 +608,7 @@ export class StreamClient {
   /** Over for good: the state, then the event that says why. */
   private finish(reason: ClosedReason): void {
     this.closedByUs = true;
+    this.lifecycle += 1;
     this.setState('closed');
     this.emit('closed', reason);
   }
@@ -624,6 +636,8 @@ export class StreamClient {
   // ------------------------------------------------------------- connection
 
   async connect(): Promise<JoinResult> {
+    const lifecycle = this.lifecycle;
+    const closed = () => lifecycle !== this.lifecycle;
     let result: JoinResult;
     if (this.state === 'idle' || this.state === 'closed') this.setState('connecting');
     try {
@@ -633,6 +647,9 @@ export class StreamClient {
 
       this.device = this.createDevice();
       await this.device.load({ routerRtpCapabilities: result.routerRtpCapabilities });
+      // close() ran while the Device loaded: going on would set the state
+      // back to connected, and emit joined, after closed.
+      if (closed()) throw closedWhileConnecting();
     } catch (err) {
       // A session that never got going: the app has the error. Left open,
       // the socket would be closed by the server's join deadline instead, and
@@ -657,6 +674,7 @@ export class StreamClient {
     // decides what may return; reconnecting never turns a blocked device on.
     if (result.role !== 'host' && result.role !== 'cohost' && (this.wasPublishing || this.screenPending)) {
       await this.unpublish();
+      if (closed()) throw closedWhileConnecting();
     }
     const own = result.participants.find((p) => p.identity === result.identity);
     if (own?.muted) this.applyLocalModeration('audio');
@@ -677,16 +695,19 @@ export class StreamClient {
     for (const producerId of this.remoteVideoLayers.keys()) if (!present.has(producerId)) this.remoteVideoLayers.delete(producerId);
 
     // Subscribe to everything already publishing before we announce readiness.
+    // A close() part-way stops it: what is left would only fail, after closed.
     for (const p of result.producers) {
-      await this.consume(p).catch((err) => this.emit('error', err as Error));
+      if (closed()) throw closedWhileConnecting();
+      await this.consume(p).catch((err) => { if (!closed()) this.emit('error', err as Error); });
     }
 
     // Restore our own broadcast. This is what makes an origin failover
     // survivable for the host: it reconnects onto the new origin and the
     // stream comes back on its own.
     if (this.wasPublishing && (result.role === 'host' || result.role === 'cohost')) {
-      await this.republish().catch((err) => this.emit('error', err as Error));
+      await this.republish().catch((err) => { if (!closed()) this.emit('error', err as Error); });
     }
+    if (closed()) throw closedWhileConnecting();
     this.syncNetworkWatch();
     return result;
   }
@@ -758,18 +779,29 @@ export class StreamClient {
     });
   }
 
-  private detachSocket(): void {
+  private detachSocket(reason = 'superseded'): void {
     const ws = this.ws;
     this.ws = null;
     if (ws && ws.readyState <= WebSocket.OPEN) {
       try {
-        ws.close(1000, 'superseded');
+        ws.close(1000, reason);
       } catch {
         /* already closing */
       }
     }
   }
 
+  /**
+   * A reconnect that ends the session lets go of its socket. A refused join
+   * leaves that socket open (connect() keeps it once a session has joined),
+   * and the session would otherwise report closed with it still attached and
+   * still sending.
+   */
+  private releaseSocket(): void {
+    this.detachSocket('gave up');
+    this.failAllPending(new RpcError('not-connected', 'the session has ended'));
+  }
+
   /**
    * Reconnection is mandatory, not optional: nodes get drained, relays die and
    * promotions move you to a different node. Always re-ask the orchestrator
@@ -786,6 +818,7 @@ export class StreamClient {
         this.reconnectAttempt += 1;
         if (this.reconnectAttempt > MAX_RECONNECT_ATTEMPTS) {
           this.emit('error', new RpcError('reconnect-gave-up', `gave up after ${MAX_RECONNECT_ATTEMPTS} reconnect attempts`));
+          this.releaseSocket();
           this.finish('gave-up');
           return;
         }
@@ -801,11 +834,15 @@ export class StreamClient {
           // for good, with no `closed`.
           if (this.ws) return;
         } catch (err) {
+          // Ended while this attempt was under way -- by close(), or by the
+          // server -- and that has been reported: nothing follows closed.
+          if (this.closedByUs) return;
           this.emit('error', err as Error);
           // Stop on failures a retry cannot resolve (the registry's terminal
           // codes). Hammering a room that has ended produces one error per
           // attempt forever and drowns out whatever actually went wrong.
           if (err instanceof RpcError && isTerminalError(err.code)) {
+            this.releaseSocket();
             this.finish('gave-up');
             return;
           }
@@ -822,6 +859,7 @@ export class StreamClient {
     // others have already reported themselves and set closedByUs.
     const wasOpen = !this.closedByUs;
     this.closedByUs = true;
+    this.lifecycle += 1;
     this.publishGeneration += 1;
     this.wasPublishing = false;
     this.teardownMedia();
@@ -841,6 +879,10 @@ export class StreamClient {
     const ws = this.ws;
     this.ws = null;
     ws?.close(1000, 'client closed');
+    // Detached first, so the socket's own close handler no longer fails what
+    // was waiting on it: done here, or a join or a request in flight would
+    // wait out its 15 s timeout.
+    this.failAllPending(new RpcError('not-connected', 'the session was closed'));
     this.setState('closed');
     if (wasOpen) this.emit('closed', 'left');
   }
@@ -1023,6 +1065,9 @@ export class StreamClient {
     } catch {
       return;
     }
+    // Valid JSON that is not a message object ("null" would throw below) is
+    // ignored like any other frame that is not a message.
+    if (typeof msg !== 'object' || msg === null) return;
 
     if (typeof msg.id === 'number') {
       const p = this.pending.get(msg.id);
@@ -1190,6 +1235,10 @@ export class StreamClient {
         this.closedByUs = true;
         this.emit('roomClosed', d as never);
         this.finish('room-closed');
+        // Before close() fails what is pending: an endRoom() this event
+        // answers succeeded.
+        for (const ended of this.endRoomWaiters) ended();
+        this.endRoomWaiters.clear();
         this.close();
         break;
       case 'kicked':
@@ -2424,7 +2473,20 @@ export class StreamClient {
   }
   promote(identity: string, role: Role): Promise<unknown> { return this.rpc('promote', { identity, role }); }
   kick(identity: string, reason?: string): Promise<unknown> { return this.rpc('kick', { identity, reason }); }
-  endRoom(): Promise<unknown> { return this.rpc('endRoom'); }
+  /**
+   * End the room for everyone. The server tells the room it has closed
+   * before it replies, and that roomClosed closes this session, so the reply
+   * may never be read: roomClosed is then the answer, and endRoom() resolves
+   * as the reply would have, with `{ ok: true }`. It still fails when the
+   * server refuses, or the connection drops with neither.
+   */
+  endRoom(): Promise<unknown> {
+    return new Promise((resolve, reject) => {
+      const ended = () => resolve({ ok: true });
+      this.endRoomWaiters.add(ended);
+      this.rpc('endRoom').then(resolve, reject).finally(() => this.endRoomWaiters.delete(ended));
+    });
+  }
   getRoomState(): Promise<unknown> { return this.rpc('getRoomState'); }
 
   // ------------------------------------------------------- slots and metadata