@voltkit-rtc/client 0.7.2 → 0.7.3

package/src/index.ts

@@ -446,6 +446,16 @@ const VIDEO_START_BITRATE_KBPS = 2000;
 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. */
+/**
+ * The constraints that capture again what two publishes captured: each kind
+ * as the later publish asked for it, or as the earlier one did if the later
+ * one did not ask for it.
+ */
+function mergeConstraints(earlier: MediaStreamConstraints | null, later: MediaStreamConstraints): MediaStreamConstraints {
+  if (!earlier) return later;
+  return { ...earlier, ...later, audio: later.audio || earlier.audio, video: later.video || earlier.video };
+}
+
 const unpublishedWhile = (what: string) => new RpcError('unpublished', `the ${what} was unpublished while it was being published`);
 
 /**
@@ -492,6 +502,15 @@ export class StreamClient {
   // broadcaster that reconnects rejoins silently, which is worse than being
   // disconnected: the room looks healthy and shows nothing.
   private wasPublishing = false;
+  /** The deadline of the socket being opened (openSocket). */
+  private openDeadline: ReturnType<typeof setTimeout> | undefined;
+  /**
+   * This client's own moderation per kind: whether a moderator holds it off,
+   * and a revision every decision bumps. A switch-on that was waiting for the
+   * server when a decision arrived does not act on its reply (V072-06).
+   */
+  private forcedOff = { audio: false, video: false };
+  private moderationRevision = { audio: 0, video: 0 };
   private publishConstraints: MediaStreamConstraints | null = null;
   private publishOptions: PublishOptions = {};
   /** In-app music being published, kept across reconnects so it can be published again. */
@@ -701,7 +720,10 @@ export class StreamClient {
       // the socket would be closed by the server's join deadline instead, and
       // that close would start reconnecting a session that never began.
       const superseded = this.ws !== null && this.ws !== socket;
-      if (!this.joinedOnce && !superseded) {
+      // A reconnect attempt that failed (its join timed out, say) lets its
+      // socket go now too, so nothing it says later reaches the session while
+      // the next attempt waits its backoff (V072-05).
+      if ((!this.joinedOnce || this.reconnecting) && !superseded) {
         this.detachSocket();
         if (this.state === 'connecting') this.setState('idle');
       }
@@ -724,6 +746,8 @@ export class StreamClient {
       if (closed()) throw closedWhileConnecting();
     }
     const own = result.participants.find((p) => p.identity === result.identity);
+    this.moderate('audio', Boolean(own?.muted), true);
+    this.moderate('video', Boolean(own?.videoBlocked), true);
     if (own?.muted) this.applyLocalModeration('audio');
     if (own?.videoBlocked) this.applyLocalModeration('video');
     this.emit('joined', result);
@@ -779,11 +803,22 @@ export class StreamClient {
       const ws = new WebSocket(socketUrl(this.wsUrl, this.token));
       this.ws = ws;
 
+      // Bounded like every request (V072-05): a socket that does not open in
+      // time fails the attempt with `timeout` and is closed, instead of
+      // holding connect() -- or a reconnect attempt -- indefinitely.
+      this.openDeadline = setTimeout(() => {
+        reject(new RpcError('timeout', `the connection did not open in ${RPC_TIMEOUT_MS / 1000} s`));
+        if (this.ws === ws) this.detachSocket('open timed out', 'the connection did not open in time');
+      }, RPC_TIMEOUT_MS);
       const onOpen = () => {
+        clearTimeout(this.openDeadline);
         this.emit('connected');
         resolve();
       };
-      const onError = () => reject(new RpcError('connect-failed', 'websocket failed to open'));
+      const onError = () => {
+        clearTimeout(this.openDeadline);
+        reject(new RpcError('connect-failed', 'websocket failed to open'));
+      };
 
       ws.addEventListener('open', onOpen, { once: true });
       ws.addEventListener('error', onError, { once: true });
@@ -826,6 +861,7 @@ export class StreamClient {
   }
 
   private detachSocket(reason = 'superseded', why = 'the connection was replaced'): void {
+    clearTimeout(this.openDeadline);
     const ws = this.ws;
     this.ws = null;
     if (!ws) return;
@@ -1203,6 +1239,7 @@ export class StreamClient {
       case 'participantMuted': {
         const wire = data as { identity: string; kind?: 'audio' | 'video' | ''; muted?: boolean; paused?: boolean };
         const e = { identity: wire.identity, kind: wire.kind, paused: wire.paused ?? wire.muted ?? false };
+        if (e.identity && e.identity === this.joinResult?.identity) this.moderate(e.kind, e.paused, true);
         this.updateRoster((list) => list.map((p) =>
           p.identity !== e.identity ? p : { ...p,
             ...(!e.kind || e.kind === 'audio' ? { muted: e.paused } : {}),
@@ -1249,6 +1286,7 @@ export class StreamClient {
         // in-app music: it travels as audio). Reflect it locally; a release
         // changes nothing here -- switching back on is the user's choice.
         const e = data as { by: string; kind?: 'audio' | 'video' | ''; paused: boolean };
+        this.moderate(e.kind, Boolean(e.paused));
         if (e.paused) {
           this.applyLocalModeration(e.kind);
           this.emitLocalMedia();
@@ -1453,9 +1491,26 @@ export class StreamClient {
     // unpublish() ran first: this publish is over before it began, and must
     // leave nothing behind that a reconnect would publish again.
     if (generation !== this.publishGeneration) throw unpublishedWhile('stream');
-    this.localStream = stream;
+    // A second publish adds to the first (the microphone, then the camera):
+    // one local stream carries every live track, so unpublish() and close()
+    // stop them all and a reconnect publishes each again. Replacing it
+    // orphaned the first stream's tracks, still capturing (V072-01).
+    const previous = this.localStream;
+    const merged = previous !== null && previous !== stream && previous.getTracks().some((t) => t.readyState === 'live');
+    if (merged) {
+      const ids = new Set(stream.getTracks().map((t) => t.id));
+      // The new stream's tracks first: of one kind, the newer track is the one
+      // published (as before), and the older one is still stopped with it.
+      this.localStream = new MediaStream([
+        ...stream.getTracks(),
+        ...previous.getTracks().filter((t) => t.readyState === 'live' && !ids.has(t.id)),
+      ]);
+      this.emit('localStreamChanged', this.localStream);
+    } else {
+      this.localStream = stream;
+    }
     this.wasPublishing = true;
-    if (constraints) this.publishConstraints = constraints;
+    if (constraints) this.publishConstraints = merged ? mergeConstraints(this.publishConstraints, constraints) : constraints;
     if (options) {
       this.publishOptions = { ...options };
       this.frameRateFallback = false;
@@ -2544,16 +2599,47 @@ export class StreamClient {
   }
 
   private async setKindEnabled(kind: 'audio' | 'video', enabled: boolean): Promise<void> {
-    for (const producer of this.producers.values()) {
-      // The music has its own switch. Muting the microphone must not stop the song.
-      if (producer.kind !== kind || producer.appData.source !== defaultSource(kind)) continue;
+    const generation = this.publishGeneration;
+    // Unpublished or closed while waiting: nothing is left to switch, and the
+    // call resolves, as it does with nothing published (V072-03).
+    const ended = () => generation !== this.publishGeneration || this.closedByUs;
+    // The music has its own switch. Muting the microphone must not stop the song.
+    const targets = [...this.producers.values()].filter((p) => p.kind === kind && p.appData.source === defaultSource(kind));
+    for (const producer of targets) {
+      if (ended()) return;
+      if (this.producers.get(producer.id) !== producer || producer.closed) continue;
+      const revision = this.moderationRevision[kind];
       if (!enabled) producer.pause();
-      await this.rpc('pauseProducer', { producerId: producer.id, paused: !enabled });
-      if (enabled) producer.resume();
+      try {
+        await this.rpc('pauseProducer', { producerId: producer.id, paused: !enabled });
+      } catch (err) {
+        if (ended()) return;
+        throw err;
+      }
+      if (ended()) return;
+      if (!enabled || this.producers.get(producer.id) !== producer || producer.closed) continue;
+      if (revision !== this.moderationRevision[kind] || this.forcedOff[kind]) {
+        // A moderator decided while this waited: the older request does not
+        // undo it. It stays off here, and the server is told so too, since
+        // which of the two it applied last cannot be known from here.
+        void this.rpc('pauseProducer', { producerId: producer.id, paused: true }).catch(() => undefined);
+        this.emitLocalMedia();
+        throw new RpcError('force-muted', `a moderator changed your ${kind} while this request waited; it stays off`);
+      }
+      producer.resume();
     }
     this.emitLocalMedia();
   }
 
+  /** Record a moderation decision ('' = both kinds). A roster snapshot counts only where it changes what is known. */
+  private moderate(kind: 'audio' | 'video' | '' | undefined, paused: boolean, snapshot = false): void {
+    for (const k of kind ? [kind] : (['audio', 'video'] as const)) {
+      if (snapshot && this.forcedOff[k] === paused) continue;
+      this.forcedOff[k] = paused;
+      this.moderationRevision[k] += 1;
+    }
+  }
+
   /** Stop publishing entirely and release the local devices. */
   async unpublish(): Promise<void> {
     void this.stopRecording().catch(error => this.emit('error', error as Error));

package/src/recording.ts

@@ -53,25 +53,26 @@ export class RecordingError extends Error {
 }
 const delay = (ms: number) =>
   new Promise<void>((resolve) => setTimeout(resolve, ms));
+/** One POST to the recording API. */
+function recordingFetch(base: string, path: string, body: unknown, token?: string): Promise<Response> {
+  return fetch(`${base.replace(/\/$/, "")}/recording/upload${path}`, {
+    method: "POST",
+    credentials: "omit",
+    headers: {
+      "Content-Type": "application/json",
+      ...(token ? { Authorization: `Bearer ${token}` } : {}),
+    },
+    body: JSON.stringify(body),
+    signal: AbortSignal.timeout(path.endsWith("/complete") ? 180000 : 15000),
+  });
+}
 export async function recordingRequest<T>(
   base: string,
   path: string,
   body: unknown,
   token?: string,
 ): Promise<T> {
-  const response = await fetch(
-    `${base.replace(/\/$/, "")}/recording/upload${path}`,
-    {
-      method: "POST",
-      credentials: "omit",
-      headers: {
-        "Content-Type": "application/json",
-        ...(token ? { Authorization: `Bearer ${token}` } : {}),
-      },
-      body: JSON.stringify(body),
-      signal: AbortSignal.timeout(path.endsWith("/complete") ? 180000 : 15000),
-    },
-  );
+  const response = await recordingFetch(base, path, body, token);
   const result = (await response.json()) as {
     success: boolean;
     data?: T;
@@ -304,16 +305,53 @@ export class RecordingUploader {
     }
     this.sealed = true;
   }
+  /**
+   * How long complete() waits before asking `/complete` again when the
+   * answer was lost or unclear: one wait per extra attempt. Exposed for tests.
+   * @internal
+   */
+  static completeRetryDelaysMs = [1000, 3000];
+
+  /**
+   * Finalise. An accepted `/complete` whose reply cannot be read rejects
+   * saying the recording completed. A lost or unclear answer (no reply, an
+   * unreadable one, a 5xx, 408/409/425/429) is asked again -- the service's
+   * completion is idempotent -- and if it is still unclear, rejects saying the
+   * recording may already be saved. Neither is aborted; only a readable
+   * refusal is final (V072-04).
+   */
   async complete(): Promise<RecordingFile> {
     await this.seal();
-    const file = await recordingRequest<RecordingFile>(
-      this.options.apiUrl,
-      `/sessions/${this.session.recording.id}/complete`,
-      {},
-      this.session.token,
-    );
-    this.emit("ready");
-    return file;
+    const path = `/sessions/${this.session.recording.id}/complete`;
+    for (let attempt = 0; ; attempt++) {
+      type Reply = { success?: unknown; data?: unknown; error?: { message?: string } };
+      let status = 0;
+      let body: Reply | null = null;
+      try {
+        const response = await recordingFetch(this.options.apiUrl, path, {}, this.session.token);
+        status = response.status;
+        const parsed: unknown = await response.json();
+        if (parsed && typeof parsed === "object") body = parsed as Reply;
+      } catch {
+        // Lost, cut short or unreadable: the service may have saved it.
+      }
+      if (body && status > 0 && status < 400 && body.success === true) {
+        const file = body.data as RecordingFile | null | undefined;
+        if (!file || typeof file !== "object" || typeof file.id !== "string") {
+          throw new RecordingError("The recording was completed but its reply could not be read", status);
+        }
+        this.emit("ready");
+        return file;
+      }
+      if (body && status > 0 && status < 500 && ![408, 409, 425, 429].includes(status)) {
+        throw new RecordingError(body.error?.message ?? "Recording request failed", status);
+      }
+      const delays = RecordingUploader.completeRetryDelaysMs;
+      if (attempt >= delays.length) {
+        throw new RecordingError("The service did not confirm the recording, which may already be saved; it was not aborted", status);
+      }
+      await delay(delays[attempt]);
+    }
   }
   async abort(): Promise<void> {
     this.canceled = true;