mediasfu-shared 1.2.0 → 1.2.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mediasfu-shared",
-  "version": "1.2.0",
+  "version": "1.2.2",
   "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",
@@ -37,6 +37,7 @@
     "src",
     "README.md",
     "HEADLESS_GUIDE.md",
+    "CHANGELOG.md",
     "LICENSE"
   ],
   "scripts": {

package/src/consumers/connectIps.ts

@@ -36,6 +36,63 @@ export interface ConnectIpsOptions {
 // Export the type definition for the function
 export type ConnectIpsType = (options: ConnectIpsOptions) => Promise<[Record<string, any>[], string[]]>;
 
+// Keep the reservation local to one room engine's socket collection. Separate
+// rooms may legitimately consume from the same endpoint and must not share a
+// socket, while overlapping updates for one room must serialize that endpoint.
+const pendingConsumeConnections = new WeakMap<
+  object,
+  Map<string, Promise<boolean>>
+>();
+
+const normalizeConsumeEndpoint = (ip: string): string =>
+  ip.trim().toLowerCase().replace(/\.$/, "");
+
+const hasConsumeEndpoint = (
+  consumeSockets: ConsumeSocket[],
+  endpoint: string
+): boolean => consumeSockets.some((socketObj) => {
+  const ip = Object.keys(socketObj)[0];
+  return Boolean(ip) && normalizeConsumeEndpoint(ip) === endpoint;
+});
+
+async function reserveConsumeEndpoint(
+  consumeSockets: ConsumeSocket[],
+  ip: string,
+  reservationOwner: object = consumeSockets
+): Promise<((connected?: boolean) => void) | null> {
+  const endpoint = normalizeConsumeEndpoint(ip);
+  if (!endpoint || endpoint === "none") return null;
+
+  let pendingForSockets = pendingConsumeConnections.get(reservationOwner);
+  if (!pendingForSockets) {
+    pendingForSockets = new Map<string, Promise<boolean>>();
+    pendingConsumeConnections.set(reservationOwner, pendingForSockets);
+  }
+
+  while (true) {
+    if (hasConsumeEndpoint(consumeSockets, endpoint)) return null;
+
+    const pending = pendingForSockets.get(endpoint);
+    if (pending) {
+      if (await pending) return null;
+      continue;
+    }
+
+    let resolvePending!: (connected: boolean) => void;
+    const reservation = new Promise<boolean>((resolve) => {
+      resolvePending = resolve;
+    });
+    pendingForSockets.set(endpoint, reservation);
+
+    return (didConnect = false) => {
+      if (pendingForSockets?.get(endpoint) === reservation) {
+        pendingForSockets.delete(endpoint);
+      }
+      resolvePending(didConnect === true);
+    };
+  }
+}
+
 /**
  * Connects to remote IPs and manages socket connections.
  *
@@ -105,15 +162,15 @@ export const connectIps = async ({
     }
 
     for (const ip of remIP) {
-      try {
-        // Check if the IP is already connected
-        const matching = consume_sockets.find((socketObj) => Object.keys(socketObj)[0] === ip);
-
-        if (matching || !ip) {
-          // Skip if the IP is already connected or invalid
-          continue;
-        }
+      const releaseReservation = await reserveConsumeEndpoint(
+        consume_sockets,
+        ip,
+        parameters?.socket || consume_sockets
+      );
+      if (!releaseReservation) continue;
 
+      let connected = false;
+      try {
         // Connect to the remote socket using socket.io-client
         const remote_sock = await connectSocket({ apiUserName, apiKey, apiToken, link: `https://${ip}.mediasfu.com` });
 
@@ -161,10 +218,13 @@ export const connectIps = async ({
           // Add the remote socket to the consume_sockets array
           consume_sockets.push({ [ip]: remote_sock });
           updateConsume_sockets(consume_sockets);
+          connected = true;
         }
       } catch (error) {
         // Handle the error
         console.log("connectIps error", error);
+      } finally {
+        releaseReservation(connected);
       }
     }
 

package/src/methods/recording/startRecording.ts

@@ -222,7 +222,13 @@ export const startRecording: StartRecordingType = async ({
           updateRecordPaused(recordPaused)
 
           if (action === 'startRecord') {
-            await rePort({ parameters: parameters.getUpdatedAllParams() })
+            // restart: force an immediate updateScreenClient. Without it,
+            // rePort only emits when activeNames or screenStates differ from
+            // their previous values — and nothing has changed at the moment a
+            // recording starts, so the recorder got no layout until something
+            // later did (a speaker change, a join, a share). Resume already
+            // forced it; start now matches.
+            await rePort({ restart: true, parameters: parameters.getUpdatedAllParams() })
             await recordStartTimer({ parameters })
           } else {
             updateRecordResumed(true)