mediasfu-shared 1.3.0 → 1.3.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mediasfu-shared",
-  "version": "1.3.0",
+  "version": "1.3.1",
   "description": "mediasfu-shared – framework-agnostic WebRTC runtime for MediaSFU. Room helpers, mediasoup signaling, socket management, media state, and TypeScript types for React, Vue, Angular, Svelte, and plain TS.",
   "main": "dist/index.cjs",
   "module": "dist/index.js",

package/src/consumers/connectSendTransportAudio.ts

@@ -1,4 +1,5 @@
 import type { Transport, Producer, ProducerOptions } from 'mediasoup-client/types';
+import { produceOnce } from "./sendTransportGuard";
 
 export interface ConnectSendTransportAudioParameters {
   audioProducer: Producer | null;
@@ -39,7 +40,7 @@ const connectLocalSendTransportAudio = async ({
     } = parameters;
 
     if (localProducerTransport) {
-      localAudioProducer = await localProducerTransport.produce(audioParams);
+      localAudioProducer = (await produceOnce(localProducerTransport, "audio", () => localProducerTransport!.produce(audioParams))).producer;
 
       updateLocalAudioProducer?.(localAudioProducer);
       updateLocalProducerTransport?.(localProducerTransport);
@@ -127,10 +128,12 @@ export const connectSendTransportAudio: ConnectSendTransportAudioType = async ({
 
     // Attempt to connect the primary send transport
     if (targetOption === "all" || targetOption === "remote") {
-      audioProducer = await producerTransport!.produce(audioParams);
+      // A concurrent call for the same transport shares the producer instead of creating a second one.
+      const produced = await produceOnce(producerTransport!, "audio", () => producerTransport!.produce(audioParams));
+      audioProducer = produced.producer;
 
-      // Update the audio level
-      updateMicLevel(audioProducer, parameters.updateAudioLevel);
+      // Update the audio level (once per producer)
+      if (!produced.joined) updateMicLevel(audioProducer, parameters.updateAudioLevel);
 
       // Update state with the new producer and transport
       updateAudioProducer(audioProducer);

package/src/consumers/connectSendTransportScreen.ts

@@ -1,4 +1,5 @@
 import type { Transport, Producer, Device, ProducerOptions } from 'mediasoup-client/types';
+import { produceOnce } from "./sendTransportGuard";
 
 export interface ConnectSendTransportScreenParameters {
   screenProducer: Producer | null;
@@ -48,11 +49,11 @@ const connectLocalSendTransportScreen = async ({
 
     // Produce local screen share data
     if (localProducerTransport) {
-      localScreenProducer = await localProducerTransport.produce({
+      localScreenProducer = (await produceOnce(localProducerTransport, "screen", () => localProducerTransport!.produce({
         track: stream.getVideoTracks()[0],
         codec,
         appData: { mediaTag: "screen-video" },
-      });
+      }))).producer;
 
       // Update the local producer and transport objects
       updateLocalScreenProducer?.(localScreenProducer);
@@ -144,12 +145,13 @@ export const connectSendTransportScreen: ConnectSendTransportScreenType = async
 
     // Produce screen share data using the producer transport
     if (targetOption === "remote" || targetOption === "all") {
-      screenProducer = await producerTransport!.produce({
+      // A concurrent call for the same transport shares the producer instead of creating a second one.
+      screenProducer = (await produceOnce(producerTransport!, "screen", () => producerTransport!.produce({
         track: stream.getVideoTracks()[0],
         ...params,
         codec,
         appData: { mediaTag: "screen-video" },
-      });
+      }))).producer;
 
       // Update the screen producer and producer transport objects
       updateScreenProducer(screenProducer);

package/src/consumers/connectSendTransportVideo.ts

@@ -1,4 +1,5 @@
 import type { Device, Producer, ProducerOptions, Transport } from 'mediasoup-client/types';
+import { produceOnce } from "./sendTransportGuard";
 
 export interface ConnectSendTransportVideoParameters {
   videoProducer: Producer | null;
@@ -39,7 +40,7 @@ const connectLocalSendTransportVideo = async ({
 
     // Produce local video data if transport exists
     if (localProducerTransport) {
-      localVideoProducer = await localProducerTransport.produce(videoParams);
+      localVideoProducer = (await produceOnce(localProducerTransport, "video", () => localProducerTransport!.produce(videoParams))).producer;
 
       // Update local producer and transport
       updateLocalVideoProducer?.(localVideoProducer);
@@ -121,7 +122,8 @@ export const connectSendTransportVideo: ConnectSendTransportVideoType = async ({
 
     // Produce video data using the primary transport
     if (targetOption === "all" || targetOption === "remote"){
-      videoProducer = await producerTransport!.produce(videoParams);
+      // A concurrent call for the same transport shares the producer instead of creating a second one.
+      videoProducer = (await produceOnce(producerTransport!, "video", () => producerTransport!.produce(videoParams))).producer;
 
       // Update main window state based on the video connection level
       if (islevel === "2") {

package/src/consumers/createSendTransport.ts

@@ -1,5 +1,6 @@
 import type { Device, Transport, DtlsParameters } from 'mediasoup-client/types';
 import { attachTransportRecovery, clearFailedSendState } from './transportRecovery';
+import { isOpen, pendingSendTransportCreation, trackSendTransportCreation } from './sendTransportGuard';
 import { Socket } from "socket.io-client";
 import {
   ConnectSendTransportParameters,
@@ -224,7 +225,7 @@ const createLocalSendTransport = async ({
  *   .catch((error) => console.error('Error creating send transport:', error));
  */
 
-export const createSendTransport: CreateSendTransportType = async ({
+const createSendTransportNow = async ({
   option,
   parameters,
 }: CreateSendTransportOptions): Promise<void> => {
@@ -262,14 +263,17 @@ export const createSendTransport: CreateSendTransportType = async ({
       console.log("Error creating local send transport:", error);
     }
 
-    // Emit createWebRtcTransport event to the server
-    socket.emit(
+    // Wait for the acknowledgement and the first producer before resolving, so a second media action never sees a
+    // half-created transport (transportCreated true while producerTransport is still null).
+    await new Promise<void>((resolve, reject) => socket.emit(
       "createWebRtcTransport",
       { consumer: false, islevel: islevel },
       async ({ params }: { params: any }) => {
+       try {
         // Check if there is an error in the response
         if (params && params.error) {
           console.error("Error in createWebRtcTransport:", params.error);
+          reject(new Error(String(params.error)));
           return;
         }
 
@@ -278,6 +282,7 @@ export const createSendTransport: CreateSendTransportType = async ({
           : (device ?? null);
         if (!resolvedDevice) {
           // Late acknowledgement after teardown; no transport should survive it.
+          resolve();
           return;
         }
 
@@ -342,9 +347,62 @@ export const createSendTransport: CreateSendTransportType = async ({
           },
         });
         updateTransportCreated(transportCreated);
+        resolve();
+       } catch (error) {
+        reject(error);
+       }
       }
-    );
+    ));
+
+  } catch (error) {
+    console.log("Error creating send transport:", error);
+  }
+};
+
+const producerFor = (params: any, option: CreateSendTransportOptions["option"]): boolean => {
+  if (option === "audio") return isOpen(params.audioProducer);
+  if (option === "video") return isOpen(params.videoProducer);
+  if (option === "screen") return isOpen(params.screenProducer);
+  return isOpen(params.audioProducer) && isOpen(params.videoProducer);
+};
 
+/**
+ * Creates the send transport for this socket, or reuses the one that exists or is being created.
+ *
+ * The server keeps a single producer transport per socket, so a second creation while one is in flight (microphone
+ * and camera started together, a rejoin during a toggle) would replace the first on the server and silence the
+ * client's uplink. Later callers wait for the creation in flight and then produce their own media on that transport.
+ */
+export const createSendTransport: CreateSendTransportType = async ({
+  option,
+  parameters,
+}: CreateSendTransportOptions): Promise<void> => {
+  try {
+    const current = (parameters.getCurrentParams?.() ?? parameters.getUpdatedAllParams?.() ?? parameters);
+    const socket = current.socket;
+    const pending = pendingSendTransportCreation(socket);
+
+    // Checked and claimed synchronously, so two callers in the same tick cannot both create.
+    if (!pending && !(current.transportCreated && isOpen(current.producerTransport))) {
+      await trackSendTransportCreation(socket, () => createSendTransportNow({ option, parameters }));
+      return;
+    }
+
+    if (pending) await pending.catch(() => undefined);
+    const latest = (parameters.getCurrentParams?.() ?? parameters.getUpdatedAllParams?.() ?? parameters);
+    if (!isOpen(latest.producerTransport)) {
+      // The creation this caller waited for failed or the transport has closed: start again (still one at a time).
+      await createSendTransport({ option, parameters });
+      return;
+    }
+    if (producerFor(latest, option)) return; // that media is already being sent
+
+    const connectSendTransport = latest.connectSendTransport ?? parameters.connectSendTransport;
+    await connectSendTransport({
+      targetOption: "all",
+      option,
+      parameters: { ...latest, producerTransport: latest.producerTransport },
+    });
   } catch (error) {
     console.log("Error creating send transport:", error);
   }

package/src/consumers/sendTransportGuard.ts

@@ -0,0 +1,65 @@
+/**
+ * Send-side serialisation.
+ *
+ * The media server keeps one producer transport per socket. When two media actions (microphone and camera turned on
+ * together, a rejoin while a toggle is in flight) each ask for a send transport, the second `createWebRtcTransport`
+ * replaces the first on the server: both client transports then send `transport-connect` to the same server
+ * transport, the second fails ("connect() already called") and the client's uplink goes silent. Likewise two
+ * concurrent produces of the same kind create two producers where the server accepts one.
+ *
+ * These helpers make later callers wait for the creation (or produce) already in flight and reuse its result.
+ */
+
+// Keyed by the socket object: one creation per socket, released as soon as it settles.
+const pendingCreations = new WeakMap<object, Promise<void>>();
+
+/** The send-transport creation in flight for this socket, if any. */
+export const pendingSendTransportCreation = (socket: object | null | undefined): Promise<void> | undefined =>
+  (socket ? pendingCreations.get(socket) : undefined);
+
+/** Runs `create` as the only send-transport creation for this socket until it settles. */
+export const trackSendTransportCreation = (socket: object | null | undefined, create: () => Promise<void>): Promise<void> => {
+  if (!socket) return create();
+  const running = create();
+  pendingCreations.set(socket, running);
+  const release = () => {
+    if (pendingCreations.get(socket) === running) pendingCreations.delete(socket);
+  };
+  running.then(release, release);
+  return running;
+};
+
+interface ClosableLike {
+  closed?: boolean;
+}
+
+/** True for an existing, open transport or producer. */
+export const isOpen = (item: ClosableLike | null | undefined): boolean => Boolean(item && !item.closed);
+
+// Keyed by transport, then by what is produced (audio, video, screen).
+const pendingProduces = new WeakMap<object, Map<string, Promise<unknown>>>();
+
+/**
+ * Produces once per transport and key at a time. A caller that arrives while the same produce is in flight gets that
+ * producer (`joined: true`) instead of creating a second one.
+ */
+export const produceOnce = async <T>(
+  transport: object,
+  key: string,
+  produce: () => Promise<T>,
+): Promise<{ producer: T; joined: boolean }> => {
+  let byKey = pendingProduces.get(transport);
+  if (!byKey) {
+    byKey = new Map();
+    pendingProduces.set(transport, byKey);
+  }
+  const inFlight = byKey.get(key) as Promise<T> | undefined;
+  if (inFlight) return { producer: await inFlight, joined: true };
+  const running = produce();
+  byKey.set(key, running);
+  try {
+    return { producer: await running, joined: false };
+  } finally {
+    if (byKey.get(key) === running) byKey.delete(key);
+  }
+};

package/src/sockets/SocketManager.ts

@@ -10,6 +10,33 @@ import {
   normalizeRejectionReason,
 } from './mediaSocketErrors';
 
+/**
+ * After the handshake, Socket.IO reconnects this socket on its own whenever the transport drops. A media node that
+ * refuses such a reconnect for good (the room ended, the credentials were replaced by a newer join, no meeting
+ * minutes) would be retried for as long as the page stays open, so a permanent refusal closes the socket instead.
+ * Transient refusals (`api-check-failed`) keep today's behaviour.
+ */
+export function stopReconnectingWhenRefused(socket: Socket): void {
+  const onRejected = (payload?: { reason?: string; stage?: string }) => {
+    const refusal = new MediaSocketConnectError({
+      phase: 'rejected',
+      reason: normalizeRejectionReason(payload?.reason),
+      stage: typeof payload?.stage === 'string' ? payload.stage : undefined,
+      elapsedMs: 0,
+    });
+    if (refusal.retryable) return;
+    socket.off('connection-rejected', onRejected);
+    console.warn(`MediaSFU media socket: reconnect refused (${refusal.reason}); not retrying.`);
+    try {
+      // With no active socket left on its manager, Socket.IO stops reconnecting.
+      socket.disconnect();
+    } catch {
+      // Already closed.
+    }
+  };
+  socket.on('connection-rejected', onRejected);
+}
+
 /**
  * Validates the provided API key or token.
  * @param {string} value - The API key or token to validate.
@@ -192,7 +219,10 @@ async function connectSocket(
       }
 
       console.log(`Connected to ${conn} socket with ID: ${socketId}`);
-      settle(() => resolve(socket));
+      settle(() => {
+        stopReconnectingWhenRefused(socket);
+        resolve(socket);
+      });
     };
 
     const handleConnectError = (error: Error) => {