mediasfu-shared 1.2.7 → 1.3.1

package/dist/{updateParticipantAudioDecibels-DiJ_LFfH.js → updateParticipantAudioDecibels-xKKq7Zp5.js}

@@ -1,5 +1,5 @@
 import io from "socket.io-client";
-import { v as validateAlphanumeric, b as audioProcessingConstraints } from "./audioProcessing-0z5KlcmO.js";
+import { a as MediaSocketConnectError, b as currentOnlineState, n as normalizeRejectionReason, v as validateAlphanumeric, c as consumerBackupPreferDelay, i as isMediaSocketConnectError, k as audioProcessingConstraints } from "./audioProcessing-Ca5wm1nV.js";
 const createFrameworkConsumerContractError = (consumerName) => {
   return new Error(
     `${consumerName} is a render-coupled consumer helper and has no shared runtime implementation. Inject the framework-specific ${consumerName} implementation instead of calling the shared fallback export.`
@@ -506,6 +506,7 @@ const closeAndResize = async ({ producerId, kind, parameters }) => {
   parameters = getUpdatedAllParams();
   let {
     allAudioStreams,
+    audioOnlyStreams = [],
     allVideoStreams,
     activeNames,
     participants,
@@ -530,6 +531,7 @@ const closeAndResize = async ({ producerId, kind, parameters }) => {
     updateMainWindow,
     updateActiveNames,
     updateAllAudioStreams,
+    updateAudioOnlyStreams,
     updateAllVideoStreams,
     updateShareScreenStarted,
     updateUpdateMainWindow,
@@ -553,6 +555,11 @@ const closeAndResize = async ({ producerId, kind, parameters }) => {
       return audioStream.producerId !== producerId;
     });
     updateAllAudioStreams(allAudioStreams);
+    const playerProducerId = (element) => String(element?.props?.remoteProducerId ?? element?.inputs?.remoteProducerId ?? element?.key ?? "");
+    if (audioOnlyStreams.some((element) => playerProducerId(element) === producerId)) {
+      audioOnlyStreams = audioOnlyStreams.filter((element) => playerProducerId(element) !== producerId);
+      updateAudioOnlyStreams?.(audioOnlyStreams);
+    }
     if (recordingDisplayType == "video" && recordingVideoOptimized == true) ;
     else {
       participant = participants.find(
@@ -759,6 +766,24 @@ async function compareScreenStates({
     console.log("compareScreenStates error", error);
   }
 }
+function stopReconnectingWhenRefused(socket) {
+  const onRejected = (payload) => {
+    const refusal = new MediaSocketConnectError({
+      phase: "rejected",
+      reason: normalizeRejectionReason(payload?.reason),
+      stage: typeof payload?.stage === "string" ? payload.stage : void 0,
+      elapsedMs: 0
+    });
+    if (refusal.retryable) return;
+    socket.off("connection-rejected", onRejected);
+    console.warn(`MediaSFU media socket: reconnect refused (${refusal.reason}); not retrying.`);
+    try {
+      socket.disconnect();
+    } catch {
+    }
+  };
+  socket.on("connection-rejected", onRejected);
+}
 async function validateApiKeyToken(value) {
   if (!/^[a-z0-9]{64}$/i.test(value)) {
     throw new Error("Invalid API key or token.");
@@ -811,12 +836,26 @@ async function connectSocket({ apiUserName, apiKey, apiToken, link }) {
     }
     let settled = false;
     let timeoutHandle;
+    const startedAt = Date.now();
+    let transportOpened = false;
+    let rejection = null;
     const cleanupHandshake = () => {
       if (timeoutHandle) clearTimeout(timeoutHandle);
       socket.off("connection-success", handleConnectionSuccess);
       socket.off("connect_error", handleConnectError);
       socket.off("disconnect", handleDisconnectBeforeReady);
+      socket.off("connect", handleTransportOpen);
+      socket.off("connection-rejected", handleConnectionRejected);
     };
+    const failure = (phase, transportError) => new MediaSocketConnectError({
+      phase: rejection ? "rejected" : phase,
+      reason: rejection?.reason,
+      stage: rejection?.stage,
+      elapsedMs: Date.now() - startedAt,
+      online: currentOnlineState(),
+      transportError,
+      link
+    });
     const settle = (action) => {
       if (settled) return;
       settled = true;
@@ -832,33 +871,48 @@ async function connectSocket({ apiUserName, apiKey, apiToken, link }) {
       } catch {
       }
       console.log(`Connected to ${conn} socket with ID: ${socketId}`);
-      settle(() => resolve(socket));
+      settle(() => {
+        stopReconnectingWhenRefused(socket);
+        resolve(socket);
+      });
     };
     const handleConnectError = (error) => {
       settle(() => {
         socket.disconnect();
-        reject(new Error("Error connecting to media socket: " + error.message));
+        reject(failure(transportOpened ? "after-open" : "before-open", error?.message));
+      });
+    };
+    const handleTransportOpen = () => {
+      transportOpened = true;
+    };
+    const handleConnectionRejected = (payload) => {
+      rejection = {
+        reason: normalizeRejectionReason(payload?.reason),
+        stage: typeof payload?.stage === "string" ? payload.stage : void 0
+      };
+      settle(() => {
+        try {
+          socket.disconnect();
+        } catch {
+        }
+        reject(failure("rejected"));
       });
     };
     const handleDisconnectBeforeReady = (reason) => {
-      settle(
-        () => reject(
-          new Error(
-            "Media socket closed before the room was ready (" + reason + ")."
-          )
-        )
-      );
+      settle(() => reject(failure("after-open", reason)));
     };
     socket.on("connection-success", handleConnectionSuccess);
     socket.on("connect_error", handleConnectError);
     socket.on("disconnect", handleDisconnectBeforeReady);
+    socket.on("connect", handleTransportOpen);
+    socket.on("connection-rejected", handleConnectionRejected);
     timeoutHandle = setTimeout(() => {
       settle(() => {
         try {
           socket.disconnect();
         } catch {
         }
-        reject(new Error("Timed out connecting to media socket."));
+        reject(failure("timeout"));
       });
     }, CONNECT_TIMEOUT_MS);
   });
@@ -872,11 +926,24 @@ async function connectLocalSocket({ link }) {
     socket = io(`${link}/media`, {
       transports: ["websocket"]
     });
+    const startedAt = Date.now();
+    let transportOpened = false;
+    socket.on("connect", () => {
+      transportOpened = true;
+    });
     socket.on("connection-success", (data) => {
       resolve({ socket, data });
     });
     socket.on("connect_error", (error) => {
-      reject(new Error("Error connecting to media socket: " + error.message));
+      reject(
+        new MediaSocketConnectError({
+          phase: transportOpened ? "after-open" : "before-open",
+          elapsedMs: Date.now() - startedAt,
+          online: currentOnlineState(),
+          transportError: error?.message,
+          link
+        })
+      );
     });
   });
 }
@@ -1245,11 +1312,72 @@ const newPipeProducer = async ({
     updateFirst_round(updatedFirstRound);
   }
 };
+const SCREEN_AUDIO_MEDIA_TAG = "screen-audio";
+const SCREEN_AUDIO_CODEC_OPTIONS = {
+  opusStereo: true,
+  opusDtx: false,
+  opusFec: true,
+  opusMaxAverageBitrate: 128e3
+};
+const screenAudioProducerIds = /* @__PURE__ */ new Set();
+const markScreenAudioProducer = (producerId, mediaTag) => {
+  if (producerId && mediaTag === SCREEN_AUDIO_MEDIA_TAG) screenAudioProducerIds.add(producerId);
+};
+const forgetScreenAudioProducer = (producerId) => {
+  if (producerId) screenAudioProducerIds.delete(producerId);
+};
+const isScreenAudioProducer = ({ producerId, participants = [], appData }) => {
+  if (!producerId) return false;
+  if (screenAudioProducerIds.has(producerId)) return true;
+  if (appData?.mediaTag === SCREEN_AUDIO_MEDIA_TAG) return true;
+  return participants.some((participant) => participant?.ScreenAudioID === producerId);
+};
+const shouldShareScreenAudio = ({ supportsScreenAudio, screenAudioEnabled, screenAudioMode }) => supportsScreenAudio === true && screenAudioEnabled !== false && screenAudioMode !== "never";
+const canCaptureDisplayAudio = (nav = typeof navigator !== "undefined" ? navigator : void 0) => {
+  if (!nav) return false;
+  const ua = String(nav.userAgent || "");
+  if (/Mobi|Android|iPhone|iPad|iPod/i.test(ua)) return false;
+  const brands = (nav.userAgentData?.brands || []).map((entry) => String(entry?.brand || ""));
+  if (brands.some((brand) => /Chromium|Google Chrome|Microsoft Edge|Opera|Brave/i.test(brand))) return true;
+  return /(Chrome|Chromium|Edg)\//.test(ua) && !/Firefox|FxiOS|OPiOS/.test(ua);
+};
+const setScreenAudioPaused = (producer, paused) => {
+  if (!producer || producer.closed) return false;
+  if (paused && !producer.paused) producer.pause();
+  if (!paused && producer.paused) producer.resume();
+  return producer.paused;
+};
+const buildDisplayMediaOptions = ({ targetWidth, targetHeight, withAudio }) => {
+  const options = {
+    video: { width: targetWidth, height: targetHeight, frameRate: 30 },
+    audio: withAudio ? { echoCancellation: false, noiseSuppression: false, autoGainControl: false } : false
+  };
+  if (withAudio) {
+    options.systemAudio = "include";
+    options.suppressLocalAudioPlayback = false;
+  }
+  return options;
+};
+const producersBySocket = /* @__PURE__ */ new WeakMap();
+const rememberScreenAudioProducer = (socket, producer) => {
+  if (!socket) return;
+  if (producer) producersBySocket.set(socket, producer);
+  else producersBySocket.delete(socket);
+};
+const recallScreenAudioProducer = (socket) => socket && producersBySocket.get(socket) || null;
+const setScreenAudioVolume = (volume, root = typeof document !== "undefined" ? document : null) => {
+  if (!root) return;
+  const value = Math.min(1, Math.max(0, Number.isFinite(volume) ? volume : 1));
+  root.querySelectorAll('audio[data-screen-audio="true"]').forEach((element) => {
+    element.volume = value;
+  });
+};
 const producerClosed = async ({
   remoteProducerId,
   parameters
 }) => {
   let { consumerTransports, closeAndResize: closeAndResize2, screenId, updateConsumerTransports } = parameters;
+  forgetScreenAudioProducer(remoteProducerId);
   const activeTranslationProducerIds = parameters.activeTranslationProducerIds;
   const isTranslationProducer = activeTranslationProducerIds?.has?.(remoteProducerId);
   if (isTranslationProducer) {
@@ -1400,6 +1528,20 @@ const joinConsumeRoom = async ({
 };
 const pendingConsumeConnections = /* @__PURE__ */ new WeakMap();
 const normalizeConsumeEndpoint = (ip) => ip.trim().toLowerCase().replace(/\.$/, "");
+const CONSUME_REJECTION_COOLDOWN_MS = 6e4;
+const rejectedConsumeEndpoints = /* @__PURE__ */ new WeakMap();
+const consumeEndpointRecentlyRejected = (owner, endpoint) => {
+  const at = rejectedConsumeEndpoints.get(owner)?.get(endpoint);
+  return at !== void 0 && Date.now() - at < CONSUME_REJECTION_COOLDOWN_MS;
+};
+const rememberConsumeEndpointRejection = (owner, endpoint) => {
+  let byEndpoint = rejectedConsumeEndpoints.get(owner);
+  if (!byEndpoint) {
+    byEndpoint = /* @__PURE__ */ new Map();
+    rejectedConsumeEndpoints.set(owner, byEndpoint);
+  }
+  byEndpoint.set(endpoint, Date.now());
+};
 const hasConsumeEndpoint = (consumeSockets, endpoint) => {
   for (let index = consumeSockets.length - 1; index >= 0; index -= 1) {
     const socketObj = consumeSockets[index];
@@ -1467,7 +1609,9 @@ const connectIps = async ({
       });
       return [consume_sockets, roomRecvIPs];
     }
+    const rejectionOwner = parameters?.socket || consume_sockets;
     for (const ip of remIP) {
+      if (consumeEndpointRecentlyRejected(rejectionOwner, normalizeConsumeEndpoint(ip))) continue;
       const releaseReservation = await reserveConsumeEndpoint(
         consume_sockets,
         ip,
@@ -1479,11 +1623,25 @@ const connectIps = async ({
       try {
         remote_sock = await connectSocket({ apiUserName, apiKey, apiToken, link: `https://${ip}.mediasfu.com` });
         if (remote_sock.id) {
+          let consumeRoomReady = false;
+          const pendingProducers = [];
           if (!roomRecvIPs.includes(ip)) {
             roomRecvIPs.push(ip);
             updateRoomRecvIPs(roomRecvIPs);
           }
-          remote_sock.on("new-pipe-producer", async ({ producerId, islevel, isTranslation, translationMeta }) => {
+          const consumeProducer = async ({ producerId, islevel, isTranslation, translationMeta, mediaTag }) => {
+            markScreenAudioProducer(producerId, mediaTag);
+            if (!consumeRoomReady) {
+              pendingProducers.push({ producerId, islevel, isTranslation, translationMeta });
+              return;
+            }
+            const preferDelay = isTranslation ? 0 : consumerBackupPreferDelay(
+              ip,
+              parameters.getUpdatedAllParams?.()?.consume_sockets
+            );
+            if (preferDelay > 0) {
+              await new Promise((resolve) => setTimeout(resolve, preferDelay));
+            }
             if (newProducerMethod) {
               await newProducerMethod({
                 producerId,
@@ -1494,7 +1652,8 @@ const connectIps = async ({
                 translationMeta
               });
             }
-          });
+          };
+          remote_sock.on("new-pipe-producer", consumeProducer);
           remote_sock.on("producer-closed", async ({ remoteProducerId }) => {
             if (closedProducerMethod) {
               await closedProducerMethod({ remoteProducerId, parameters });
@@ -1511,6 +1670,11 @@ const connectIps = async ({
               throw new Error(`Consume room ${ip} did not return RTP capabilities.`);
             }
           }
+          const queuedProducers = pendingProducers.splice(0);
+          consumeRoomReady = true;
+          for (const producer of queuedProducers) {
+            await consumeProducer(producer);
+          }
           consume_sockets.push({ [ip]: remote_sock });
           updateConsume_sockets(consume_sockets);
           connected = true;
@@ -1532,7 +1696,12 @@ const connectIps = async ({
           });
         }
       } catch (error) {
-        console.log("connectIps error", error);
+        if (isMediaSocketConnectError(error) && !error.retryable) {
+          rememberConsumeEndpointRejection(rejectionOwner, normalizeConsumeEndpoint(ip));
+          console.warn(`connectIps: ${ip} refused this room (${error.reason}); not retrying for ${CONSUME_REJECTION_COOLDOWN_MS / 1e3} s.`, error.message);
+        } else {
+          console.log("connectIps error", error);
+        }
       } finally {
         if (!connected && remote_sock) {
           remote_sock.removeAllListeners?.();
@@ -1766,6 +1935,36 @@ const connectSendTransport = async ({ option, targetOption = "all", parameters }
     console.log("connectSendTransport error", error);
   }
 };
+const pendingCreations = /* @__PURE__ */ new WeakMap();
+const pendingSendTransportCreation = (socket) => socket ? pendingCreations.get(socket) : void 0;
+const trackSendTransportCreation = (socket, create) => {
+  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;
+};
+const isOpen = (item) => Boolean(item && !item.closed);
+const pendingProduces = /* @__PURE__ */ new WeakMap();
+const produceOnce$1 = async (transport, key, produce) => {
+  let byKey = pendingProduces.get(transport);
+  if (!byKey) {
+    byKey = /* @__PURE__ */ new Map();
+    pendingProduces.set(transport, byKey);
+  }
+  const inFlight = byKey.get(key);
+  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);
+  }
+};
 const connectLocalSendTransportAudio = async ({
   parameters,
   audioParams
@@ -1778,7 +1977,7 @@ const connectLocalSendTransportAudio = async ({
       updateLocalProducerTransport
     } = parameters;
     if (localProducerTransport) {
-      localAudioProducer = await localProducerTransport.produce(audioParams);
+      localAudioProducer = (await produceOnce$1(localProducerTransport, "audio", () => localProducerTransport.produce(audioParams))).producer;
       updateLocalAudioProducer?.(localAudioProducer);
       updateLocalProducerTransport?.(localProducerTransport);
     }
@@ -1816,8 +2015,9 @@ const connectSendTransportAudio = async ({
       updateProducerTransport
     } = parameters;
     if (targetOption === "all" || targetOption === "remote") {
-      audioProducer = await producerTransport.produce(audioParams);
-      updateMicLevel(audioProducer, parameters.updateAudioLevel);
+      const produced = await produceOnce$1(producerTransport, "audio", () => producerTransport.produce(audioParams));
+      audioProducer = produced.producer;
+      if (!produced.joined) updateMicLevel(audioProducer, parameters.updateAudioLevel);
       updateAudioProducer(audioProducer);
       updateProducerTransport(producerTransport);
     }
@@ -1855,11 +2055,11 @@ const connectLocalSendTransportScreen = async ({
       (codec2) => codec2.mimeType.toLowerCase() === "video/vp9"
     );
     if (localProducerTransport) {
-      localScreenProducer = await localProducerTransport.produce({
+      localScreenProducer = (await produceOnce$1(localProducerTransport, "screen", () => localProducerTransport.produce({
         track: stream.getVideoTracks()[0],
         codec,
         appData: { mediaTag: "screen-video" }
-      });
+      }))).producer;
       updateLocalScreenProducer?.(localScreenProducer);
       updateLocalProducerTransport?.(localProducerTransport);
     }
@@ -1889,12 +2089,12 @@ const connectSendTransportScreen = async ({
       (codec2) => codec2.mimeType.toLowerCase() === "video/vp9"
     );
     if (targetOption === "remote" || targetOption === "all") {
-      screenProducer = await producerTransport.produce({
+      screenProducer = (await produceOnce$1(producerTransport, "screen", () => producerTransport.produce({
         track: stream.getVideoTracks()[0],
         ...params,
         codec,
         appData: { mediaTag: "screen-video" }
-      });
+      }))).producer;
       updateScreenProducer(screenProducer);
       updateProducerTransport(producerTransport);
     }
@@ -1922,7 +2122,7 @@ const connectLocalSendTransportVideo = async ({
       updateLocalProducerTransport
     } = parameters;
     if (localProducerTransport) {
-      localVideoProducer = await localProducerTransport.produce(videoParams);
+      localVideoProducer = (await produceOnce$1(localProducerTransport, "video", () => localProducerTransport.produce(videoParams))).producer;
       updateLocalVideoProducer?.(localVideoProducer);
       updateLocalProducerTransport?.(localProducerTransport);
     }
@@ -1947,7 +2147,7 @@ const connectSendTransportVideo = async ({
       updateUpdateMainWindow
     } = parameters;
     if (targetOption === "all" || targetOption === "remote") {
-      videoProducer = await producerTransport.produce(videoParams);
+      videoProducer = (await produceOnce$1(producerTransport, "video", () => producerTransport.produce(videoParams))).producer;
       if (islevel === "2") {
         updateMainWindow = true;
       }
@@ -2067,7 +2267,7 @@ const createLocalSendTransport = async ({
     console.error("Error creating local send transport:", error);
   }
 };
-const createSendTransport = async ({
+const createSendTransportNow = async ({
   option,
   parameters
 }) => {
@@ -2097,67 +2297,109 @@ const createSendTransport = async ({
     } catch (error) {
       console.log("Error creating local send transport:", error);
     }
-    socket.emit(
+    await new Promise((resolve, reject) => socket.emit(
       "createWebRtcTransport",
       { consumer: false, islevel },
       async ({ params }) => {
-        if (params && params.error) {
-          console.error("Error in createWebRtcTransport:", params.error);
-          return;
-        }
-        const resolvedDevice = parameters.getCurrentParams ? parameters.getCurrentParams().device : device ?? null;
-        if (!resolvedDevice) {
-          return;
-        }
-        const createdProducerTransport = await resolvedDevice.createSendTransport(params);
-        updateProducerTransport(createdProducerTransport);
-        createdProducerTransport.on(
-          "connect",
-          async ({ dtlsParameters }, callback, errback) => {
-            try {
-              socket.emit("transport-connect", { dtlsParameters });
-              callback();
-            } catch (error) {
-              errback(error);
-            }
-          }
-        );
-        createdProducerTransport.on(
-          "produce",
-          async (parameters2, callback, errback) => {
-            try {
-              socket.emit(
-                "transport-produce",
-                {
-                  kind: parameters2.kind,
-                  rtpParameters: parameters2.rtpParameters,
-                  appData: parameters2.appData,
-                  islevel,
-                  name: member
-                },
-                async ({ id }) => {
-                  callback({ id });
-                }
-              );
-            } catch (error) {
-              errback(error);
-            }
+        try {
+          if (params && params.error) {
+            console.error("Error in createWebRtcTransport:", params.error);
+            reject(new Error(String(params.error)));
+            return;
           }
-        );
-        attachTransportRecovery(createdProducerTransport, socket, () => clearFailedSendState(parameters, createdProducerTransport));
-        transportCreated = true;
-        parameters = parameters.getCurrentParams?.() ?? parameters;
-        await connectSendTransport2({
-          targetOption: "remote",
-          option,
-          parameters: {
-            ...parameters,
-            producerTransport: createdProducerTransport
+          const resolvedDevice = parameters.getCurrentParams ? parameters.getCurrentParams().device : device ?? null;
+          if (!resolvedDevice) {
+            resolve();
+            return;
           }
-        });
-        updateTransportCreated(transportCreated);
+          const createdProducerTransport = await resolvedDevice.createSendTransport(params);
+          updateProducerTransport(createdProducerTransport);
+          createdProducerTransport.on(
+            "connect",
+            async ({ dtlsParameters }, callback, errback) => {
+              try {
+                socket.emit("transport-connect", { dtlsParameters });
+                callback();
+              } catch (error) {
+                errback(error);
+              }
+            }
+          );
+          createdProducerTransport.on(
+            "produce",
+            async (parameters2, callback, errback) => {
+              try {
+                socket.emit(
+                  "transport-produce",
+                  {
+                    kind: parameters2.kind,
+                    rtpParameters: parameters2.rtpParameters,
+                    appData: parameters2.appData,
+                    islevel,
+                    name: member
+                  },
+                  async ({ id }) => {
+                    callback({ id });
+                  }
+                );
+              } catch (error) {
+                errback(error);
+              }
+            }
+          );
+          attachTransportRecovery(createdProducerTransport, socket, () => clearFailedSendState(parameters, createdProducerTransport));
+          transportCreated = true;
+          parameters = parameters.getCurrentParams?.() ?? parameters;
+          await connectSendTransport2({
+            targetOption: "remote",
+            option,
+            parameters: {
+              ...parameters,
+              producerTransport: createdProducerTransport
+            }
+          });
+          updateTransportCreated(transportCreated);
+          resolve();
+        } catch (error) {
+          reject(error);
+        }
       }
-    );
+    ));
+  } catch (error) {
+    console.log("Error creating send transport:", error);
+  }
+};
+const producerFor = (params, option) => {
+  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);
+};
+const createSendTransport = async ({
+  option,
+  parameters
+}) => {
+  try {
+    const current = parameters.getCurrentParams?.() ?? parameters.getUpdatedAllParams?.() ?? parameters;
+    const socket = current.socket;
+    const pending = pendingSendTransportCreation(socket);
+    if (!pending && !(current.transportCreated && isOpen(current.producerTransport))) {
+      await trackSendTransportCreation(socket, () => createSendTransportNow({ option, parameters }));
+      return;
+    }
+    if (pending) await pending.catch(() => void 0);
+    const latest = parameters.getCurrentParams?.() ?? parameters.getUpdatedAllParams?.() ?? parameters;
+    if (!isOpen(latest.producerTransport)) {
+      await createSendTransport({ option, parameters });
+      return;
+    }
+    if (producerFor(latest, option)) return;
+    const connectSendTransport2 = latest.connectSendTransport ?? parameters.connectSendTransport;
+    await connectSendTransport2({
+      targetOption: "all",
+      option,
+      parameters: { ...latest, producerTransport: latest.producerTransport }
+    });
   } catch (error) {
     console.log("Error creating send transport:", error);
   }
@@ -2231,6 +2473,99 @@ const disconnectSendTransportAudio = async ({
     console.log("Error disconnecting primary audio send transport:", error);
   }
 };
+const currentScreenAudioProducer = (parameters) => parameters.screenAudioProducer || recallScreenAudioProducer(parameters.socket);
+const storeScreenAudioProducer = (parameters, producer) => {
+  rememberScreenAudioProducer(parameters.socket, producer);
+  parameters.updateScreenAudioProducer?.(producer);
+};
+const disconnectSendTransportScreenAudio = async ({
+  parameters,
+  notifyServer = false
+}) => {
+  const params = parameters.getUpdatedAllParams ? parameters.getUpdatedAllParams() : parameters;
+  const producer = currentScreenAudioProducer(params);
+  if (!producer) return;
+  try {
+    if (!producer.closed) producer.close();
+  } catch {
+  }
+  storeScreenAudioProducer(params, null);
+  if (notifyServer) {
+    try {
+      params.socket?.emit("closeScreenAudioProducer");
+    } catch {
+    }
+  }
+};
+const toggleScreenAudio = ({ parameters, paused }) => {
+  const params = parameters.getUpdatedAllParams ? parameters.getUpdatedAllParams() : parameters;
+  const producer = currentScreenAudioProducer(params);
+  if (!producer || producer.closed) return null;
+  const next = paused ?? !producer.paused;
+  if (next && !producer.paused) producer.pause();
+  if (!next && producer.paused) producer.resume();
+  params.updateScreenAudioProducer?.(producer);
+  return producer.paused;
+};
+const produceOnce = async (transport, track) => {
+  const producer = await transport.produce({
+    track,
+    codecOptions: SCREEN_AUDIO_CODEC_OPTIONS,
+    appData: { mediaTag: SCREEN_AUDIO_MEDIA_TAG },
+    // The track belongs to the screen share stream, which stops it with the share.
+    stopTracks: false
+  });
+  if (!producer?.id) {
+    try {
+      producer?.close();
+    } catch {
+    }
+    return null;
+  }
+  return producer;
+};
+const connectSendTransportScreenAudio = async ({
+  stream,
+  parameters,
+  retryDelayMs = 600
+}) => {
+  const params = parameters.getUpdatedAllParams ? parameters.getUpdatedAllParams() : parameters;
+  const track = stream?.getAudioTracks?.()[0];
+  if (!track || track.readyState === "ended") return null;
+  if (!shouldShareScreenAudio(params)) return null;
+  const transport = params.producerTransport;
+  if (!transport || transport.closed) return null;
+  const existing = currentScreenAudioProducer(params);
+  if (existing && !existing.closed) return existing;
+  try {
+    let producer = await produceOnce(transport, track);
+    const trackEnded = () => track.readyState === "ended";
+    if (!producer && retryDelayMs > 0 && !trackEnded()) {
+      await new Promise((resolve) => setTimeout(resolve, retryDelayMs));
+      producer = await produceOnce(transport, track);
+    }
+    if (!producer) return null;
+    storeScreenAudioProducer(params, producer);
+    const screenProducer = params.screenProducer;
+    if (screenProducer?.paused) producer.pause();
+    screenProducer?.observer?.on("pause", () => {
+      if (!producer.closed) producer.pause();
+    });
+    screenProducer?.observer?.on("resume", () => {
+      if (!producer.closed) producer.resume();
+    });
+    screenProducer?.observer?.on("close", () => {
+      void disconnectSendTransportScreenAudio({ parameters: params });
+    });
+    track.addEventListener("ended", () => {
+      void disconnectSendTransportScreenAudio({ parameters: params, notifyServer: true });
+    });
+    return producer;
+  } catch (error) {
+    console.log("connectSendTransportScreenAudio error", error);
+    return null;
+  }
+};
 const disconnectLocalSendTransportScreen = async ({ parameters }) => {
   try {
     let {
@@ -2252,6 +2587,10 @@ const disconnectLocalSendTransportScreen = async ({ parameters }) => {
 const disconnectSendTransportScreen = async ({ parameters }) => {
   let { getUpdatedAllParams } = parameters;
   parameters = getUpdatedAllParams();
+  try {
+    await disconnectSendTransportScreenAudio({ parameters });
+  } catch {
+  }
   try {
     let {
       screenProducer,
@@ -3653,6 +3992,11 @@ async function startShareScreen({ parameters }) {
     onWeb,
     targetWidth = 1280,
     targetHeight = 720,
+    supportsScreenAudio,
+    screenAudioEnabled,
+    screenAudioMode = "ask",
+    screenAudioPrompt,
+    displayAudioCapable,
     streamSuccessScreen: streamSuccessScreen2
   } = parameters;
   try {
@@ -3665,15 +4009,23 @@ async function startShareScreen({ parameters }) {
       return;
     }
     if (mediaDevices && mediaDevices.getDisplayMedia) {
+      let withAudio = shouldShareScreenAudio({ supportsScreenAudio, screenAudioEnabled, screenAudioMode }) && (displayAudioCapable ?? canCaptureDisplayAudio());
+      if (withAudio && screenAudioMode === "ask" && screenAudioPrompt) {
+        const choice = await screenAudioPrompt();
+        if (choice === null) {
+          updateShared(false);
+          return;
+        }
+        withAudio = choice === "audio";
+      }
       shared = true;
-      await mediaDevices.getDisplayMedia({
-        video: {
-          width: targetWidth,
-          height: targetHeight,
-          frameRate: 30
-        },
-        audio: false
-      }).then(async (stream) => {
+      await mediaDevices.getDisplayMedia(
+        buildDisplayMediaOptions({
+          targetWidth,
+          targetHeight,
+          withAudio
+        })
+      ).then(async (stream) => {
         await streamSuccessScreen2({ stream, parameters });
       }).catch(async () => {
         shared = false;
@@ -4101,6 +4453,14 @@ const streamSuccessScreen = async ({
       });
     }
     socket.emit("startScreenShare");
+    try {
+      await connectSendTransportScreenAudio({
+        stream: localStreamScreen,
+        parameters: getUpdatedAllParams()
+      });
+    } catch (error) {
+      console.log("Screen audio not shared:", error);
+    }
   } catch (error) {
     showAlert?.({
       message: error.message,
@@ -5372,6 +5732,7 @@ const getPipedProducersAlt = async ({
             } else {
               producerId = producer.id;
               translationMeta = producer.translationMeta || null;
+              markScreenAudioProducer(producerId, producer.mediaTag);
             }
             if (translationMeta) {
               const shouldConsume = shouldConsumeTranslationProducer(
@@ -5591,47 +5952,64 @@ function updateParticipantAudioDecibels({
   updateAudioDecibels(audioDecibels);
 }
 export {
-  checkPermission as $,
+  checkGrid as $,
   receiveAllPipedTransports as A,
   reorderStreams as B,
-  rePort as C,
-  requestScreenShare as D,
-  resumePauseAudioStreams as E,
-  resumePauseStreams as F,
-  reUpdateInter as G,
-  signalNewConsumerTransport as H,
-  startShareScreen as I,
-  stopShareScreen as J,
-  streamSuccessAudio as K,
-  streamSuccessAudioSwitch as L,
-  streamSuccessScreen as M,
-  selectVideoProducerCodec as N,
-  streamSuccessVideo as O,
-  switchUserAudio as P,
-  switchUserVideo as Q,
-  switchUserVideoAlt as R,
-  trigger as S,
-  joinConsumeRoom as T,
-  newPipeProducer as U,
-  producerClosed as V,
-  clickVideo as W,
-  joinConRoom as X,
-  autoAdjust as Y,
-  calculateRowsAndColumns as Z,
-  checkGrid as _,
+  CONSUME_REJECTION_COOLDOWN_MS as C,
+  rePort as D,
+  requestScreenShare as E,
+  resumePauseAudioStreams as F,
+  resumePauseStreams as G,
+  reUpdateInter as H,
+  signalNewConsumerTransport as I,
+  startShareScreen as J,
+  stopShareScreen as K,
+  streamSuccessAudio as L,
+  streamSuccessAudioSwitch as M,
+  streamSuccessScreen as N,
+  selectVideoProducerCodec as O,
+  streamSuccessVideo as P,
+  switchUserAudio as Q,
+  switchUserVideo as R,
+  switchUserVideoAlt as S,
+  trigger as T,
+  joinConsumeRoom as U,
+  newPipeProducer as V,
+  producerClosed as W,
+  clickVideo as X,
+  joinConRoom as Y,
+  autoAdjust as Z,
+  calculateRowsAndColumns as _,
   changeVids as a,
-  controlMedia as a0,
-  getEstimate as a1,
-  getPipedProducersAlt as a2,
-  getProducersPiped as a3,
-  receiveRoomMessages as a4,
-  resumeSendTransportAudio as a5,
-  updateMiniCardsGrid as a6,
-  updateParticipantAudioDecibels as a7,
-  connectSocket as a8,
-  disconnectSocket as a9,
-  connectLocalSocket as aa,
-  createFrameworkConsumerContractError as ab,
+  checkPermission as a0,
+  controlMedia as a1,
+  getEstimate as a2,
+  getPipedProducersAlt as a3,
+  getProducersPiped as a4,
+  receiveRoomMessages as a5,
+  resumeSendTransportAudio as a6,
+  updateMiniCardsGrid as a7,
+  updateParticipantAudioDecibels as a8,
+  disconnectSendTransportScreenAudio as a9,
+  toggleScreenAudio as aa,
+  connectSendTransportScreenAudio as ab,
+  SCREEN_AUDIO_MEDIA_TAG as ac,
+  SCREEN_AUDIO_CODEC_OPTIONS as ad,
+  markScreenAudioProducer as ae,
+  forgetScreenAudioProducer as af,
+  isScreenAudioProducer as ag,
+  shouldShareScreenAudio as ah,
+  canCaptureDisplayAudio as ai,
+  setScreenAudioPaused as aj,
+  buildDisplayMediaOptions as ak,
+  rememberScreenAudioProducer as al,
+  recallScreenAudioProducer as am,
+  setScreenAudioVolume as an,
+  stopReconnectingWhenRefused as ao,
+  connectSocket as ap,
+  disconnectSocket as aq,
+  connectLocalSocket as ar,
+  createFrameworkConsumerContractError as as,
   checkScreenShare as b,
   consumerResume as c,
   closeAndResize as d,
@@ -5658,4 +6036,4 @@ export {
   processConsumerTransportsAudio as y,
   readjust as z
 };
-//# sourceMappingURL=updateParticipantAudioDecibels-DiJ_LFfH.js.map
+//# sourceMappingURL=updateParticipantAudioDecibels-xKKq7Zp5.js.map