mediasfu-shared 1.2.7 → 1.3.0

package/src/consumers/socketReceiveMethods/producerClosed.ts

@@ -1,4 +1,5 @@
 import { Transport, CloseAndResizeParameters, CloseAndResizeType } from '../../types/types';
+import { forgetScreenAudioProducer } from '../screenAudio';
 
 export interface ProducerClosedParameters extends CloseAndResizeParameters {
   consumerTransports: Transport[];
@@ -63,6 +64,8 @@ export const producerClosed = async ({
 }: ProducerClosedOptions): Promise<void> => {
   let { consumerTransports, closeAndResize, screenId, updateConsumerTransports } = parameters;
 
+  forgetScreenAudioProducer(remoteProducerId);
+
   const activeTranslationProducerIds = parameters.activeTranslationProducerIds;
   const isTranslationProducer = activeTranslationProducerIds?.has?.(remoteProducerId);
 

package/src/consumers/startShareScreen.ts

@@ -1,5 +1,12 @@
 
 import { StreamSuccessScreenType, StreamSuccessScreenParameters, ShowAlert } from "../types/types";
+import {
+  buildDisplayMediaOptions,
+  canCaptureDisplayAudio,
+  shouldShareScreenAudio,
+  ScreenAudioChoice,
+  ScreenAudioMode,
+} from "./screenAudio";
 export interface StartShareScreenParameters extends StreamSuccessScreenParameters {
   shared: boolean;
   showAlert?: ShowAlert;
@@ -8,6 +15,19 @@ export interface StartShareScreenParameters extends StreamSuccessScreenParameter
   onWeb: boolean;
   targetWidth?: number;
   targetHeight?: number;
+  /** Set from the join response: the media server accepts screen audio. */
+  supportsScreenAudio?: boolean;
+  /** Ask the browser for the screen's audio too (default true; the browser's picker still lets the user decide). */
+  screenAudioEnabled?: boolean;
+  /** `ask` (default): offer "Screen + audio" / "Screen only" first; `always`: request audio; `never`: video only. */
+  screenAudioMode?: ScreenAudioMode;
+  /**
+   * The "share audio too?" dialog: resolve `audio`, `video` or `null` (cancel). Each UI SDK supplies its own. Without
+   * one, `ask` requests audio and leaves the choice to the browser picker's own "share audio" checkbox.
+   */
+  screenAudioPrompt?: () => Promise<ScreenAudioChoice>;
+  /** Override browser detection of display-audio capture (Chromium desktop by default). */
+  displayAudioCapable?: boolean;
 
   // mediasfu functions
   streamSuccessScreen: StreamSuccessScreenType;
@@ -71,6 +91,11 @@ export async function startShareScreen({ parameters }: StartShareScreenOptions):
     onWeb,
     targetWidth = 1280,
     targetHeight = 720,
+    supportsScreenAudio,
+    screenAudioEnabled,
+    screenAudioMode = "ask",
+    screenAudioPrompt,
+    displayAudioCapable,
 
     streamSuccessScreen,
   } = parameters;
@@ -86,16 +111,27 @@ export async function startShareScreen({ parameters }: StartShareScreenOptions):
     }
 
     if (mediaDevices && mediaDevices.getDisplayMedia) {
+      // Screen audio needs a server that accepts it and a browser that can capture it (Chromium desktop).
+      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,
-        })
+        .getDisplayMedia(
+          buildDisplayMediaOptions({
+            targetWidth,
+            targetHeight,
+            withAudio,
+          })
+        )
         .then(async (stream: MediaStream) => {
           await streamSuccessScreen({ stream, parameters });
         })

package/src/consumers/streamSuccessScreen.ts

@@ -1,6 +1,7 @@
  
 
 import { Socket } from "socket.io-client";
+import { connectSendTransportScreenAudio } from "./connectSendTransportScreenAudio";
 import {
   SleepType, CreateSendTransportType, ConnectSendTransportScreenType, DisconnectSendTransportScreenType, StopShareScreenType, ReorderStreamsType, PrepopulateUserMediaType, RePortType,
   ShowAlert, CreateSendTransportParameters, ConnectSendTransportScreenParameters, DisconnectSendTransportScreenParameters, StopShareScreenParameters, ReorderStreamsParameters, PrepopulateUserMediaParameters, RePortParameters,
@@ -179,6 +180,16 @@ export const streamSuccessScreen = async ({
 
     // Alert the socket that you are sharing the screen
     socket.emit("startScreenShare");
+
+    // Share the screen's audio too, when the browser captured it and the server supports it.
+    try {
+      await connectSendTransportScreenAudio({
+        stream: localStreamScreen,
+        parameters: getUpdatedAllParams() as any,
+      });
+    } catch (error) {
+      console.log("Screen audio not shared:", error);
+    }
   } catch (error: any) {
     showAlert?.({
       message: error.message,

package/src/index.native.ts

@@ -17,6 +17,9 @@ export * from './consumers/connectSendTransport';
 export * from './consumers/connectSendTransportAudio';
 export * from './consumers/consumerResume';
 export * from './consumers/connectSendTransportScreen';
+export * from './consumers/connectSendTransportScreenAudio';
+export * from './consumers/screenAudio';
+export * from './consumers/consumerBackupPreference';
 export * from './consumers/connectSendTransportVideo';
 export * from './consumers/controlMedia';
 export * from './consumers/createSendTransport';
@@ -217,6 +220,7 @@ export * from './producers/producerEmits/joinLocalRoom';
 export * from './producers/producerEmits/joinRoom';
 
 export * from './sockets/SocketManager';
+export * from './sockets/mediaSocketErrors';
 
 export * from './methods/stream/clickVideo';
 

package/src/index.ts

@@ -20,6 +20,9 @@ export * from './consumers/connectSendTransport';
 export * from './consumers/connectSendTransportAudio';
 export * from './consumers/consumerResume';
 export * from './consumers/connectSendTransportScreen';
+export * from './consumers/connectSendTransportScreenAudio';
+export * from './consumers/screenAudio';
+export * from './consumers/consumerBackupPreference';
 export * from './consumers/connectSendTransportVideo';
 export * from './consumers/controlMedia';
 export * from './consumers/createSendTransport';
@@ -222,6 +225,7 @@ export * from './producers/producerEmits/joinLocalRoom';
 export * from './producers/producerEmits/joinRoom';
 // Socket exports
 export * from './sockets/SocketManager';
+export * from './sockets/mediaSocketErrors';
 // Stream method exports (clickVideo)
 export * from './methods/stream/clickVideo';
 

package/src/methods/socketReceive/getDomains.ts

@@ -3,6 +3,7 @@ import type {
   AltDomains,
   ConsumeSocket,
 } from '../../types/types';
+import { rememberConsumerBackups } from "../../consumers/consumerBackupPreference";
 
 export interface ConnectIpsLikeOptions<
   TParameters = unknown,
@@ -88,6 +89,9 @@ export const getDomains = async <
   let { roomRecvIPs, consume_sockets, connectIps } = parameters;
   const ipsToConnect: string[] = [];
 
+  // Busy node -> backup map: new streams are preferred from the backup (consumer-backup-v1).
+  rememberConsumerBackups(alt_domains);
+
   try {
     consume_sockets = parameters.getUpdatedAllParams().consume_sockets;
 

package/src/methods/utils/checkLimitsAndMakeRequest.ts

@@ -1,4 +1,9 @@
 import { PreJoinPageParameters } from "../../types/types";
+import {
+  describeMediaSocketError,
+  isMediaSocketConnectError,
+  isNetworkOnlyMediaSocketError,
+} from "../../sockets/mediaSocketErrors";
 import type { Socket } from "socket.io-client";
 import Cookies from "universal-cookie";
 
@@ -148,15 +153,19 @@ export const checkLimitsAndMakeRequestWithStorage: CheckLimitsAndMakeRequestWith
   } catch (error) {
     console.error('Error connecting to socket:', error);
     parameters.showAlert?.({
-      message: 'Unable to connect. Check your credentials and try again.',
+      message: describeMediaSocketError(error),
       type: 'danger',
-      duration: 3000,
+      duration: isMediaSocketConnectError(error) ? 6000 : 3000,
     });
 
-    let unsuccessfulAttempts = await readStoredNumber(storageAdapter, 'unsuccessfulAttempts');
-    unsuccessfulAttempts += 1;
-    await writeStoredNumber(storageAdapter, 'unsuccessfulAttempts', unsuccessfulAttempts);
-    await writeStoredNumber(storageAdapter, 'lastRequestTimestamp', Date.now());
+    // Only a refusal or an unknown failure counts toward the attempt limit; a device/network problem is not a
+    // credential guess.
+    if (!isNetworkOnlyMediaSocketError(error)) {
+      let unsuccessfulAttempts = await readStoredNumber(storageAdapter, 'unsuccessfulAttempts');
+      unsuccessfulAttempts += 1;
+      await writeStoredNumber(storageAdapter, 'unsuccessfulAttempts', unsuccessfulAttempts);
+      await writeStoredNumber(storageAdapter, 'lastRequestTimestamp', Date.now());
+    }
     parameters.updateIsLoadingModalVisible(false);
   }
 };
@@ -244,14 +253,18 @@ export const checkLimitsAndMakeRequest = async ({
           duration: 3000,
         });
       }
-    } catch {
+    } catch (error) {
       parameters.showAlert?.({
-        message: "Unable to connect. Check your credentials and try again.",
+        message: describeMediaSocketError(error),
         type: "danger",
-        duration: 3000,
+        duration: isMediaSocketConnectError(error) ? 6000 : 3000,
       });
-      unsuccessfulAttempts += 1;
-      cookies.set("unsuccessfulAttempts", unsuccessfulAttempts.toString());
+      // Only a refusal or an unknown failure counts toward the attempt limit; a device/network problem is not a
+      // credential guess.
+      if (!isNetworkOnlyMediaSocketError(error)) {
+        unsuccessfulAttempts += 1;
+        cookies.set("unsuccessfulAttempts", unsuccessfulAttempts.toString());
+      }
       parameters.updateIsLoadingModalVisible(false);
     }
   };

package/src/methods/welcome/handleWelcomeRequest.ts

@@ -1,4 +1,9 @@
 import type { Socket } from 'socket.io-client';
+import {
+  describeMediaSocketError,
+  isMediaSocketConnectError,
+  isNetworkOnlyMediaSocketError,
+} from '../../sockets/mediaSocketErrors';
 import Cookies from 'universal-cookie';
 import type { PreJoinPageParameters } from '../../types/types';
 
@@ -183,16 +188,20 @@ export async function handleWelcomeRequest({
         });
       }
     }
-  } catch {
+  } catch (error) {
     showAlert?.({
-      message: 'Unable to connect. Check your credentials and try again.',
+      message: describeMediaSocketError(error),
       type: 'danger',
-      duration: 3000,
+      duration: isMediaSocketConnectError(error) ? 6000 : 3000,
     });
 
-    unsuccessfulAttempts += 1;
-    cookies.set('unsuccessfulAttempts', unsuccessfulAttempts.toString());
-    cookies.set('lastRequestTimestamp', Date.now().toString());
+    // Only a refusal or an unknown failure counts toward the attempt limit; a device/network problem is not a
+    // credential guess.
+    if (!isNetworkOnlyMediaSocketError(error)) {
+      unsuccessfulAttempts += 1;
+      cookies.set('unsuccessfulAttempts', unsuccessfulAttempts.toString());
+      cookies.set('lastRequestTimestamp', Date.now().toString());
+    }
     updateIsLoadingModalVisible(false);
   }
 }

package/src/sockets/SocketManager.ts

@@ -2,6 +2,13 @@
 // Socket manager for media socket.
 import { MeetingRoomParams, RecordingParams } from '../types/types';
 import io, { Socket } from 'socket.io-client'; // Importing socket type
+import {
+  MediaSocketConnectError,
+  MediaSocketConnectPhase,
+  MediaConnectionRejectionReason,
+  currentOnlineState,
+  normalizeRejectionReason,
+} from './mediaSocketErrors';
 
 /**
  * Validates the provided API key or token.
@@ -62,6 +69,10 @@ export type ConnectLocalSocketType = (options: ConnectLocalSocketOptions) => Pro
  * @param {string} options.link - The socket link.
  *
  * @returns {Promise<Socket>} A promise that resolves to the connected socket.
+ * @throws {MediaSocketConnectError} When the connection fails. `phase` says where (`before-open`, `after-open`,
+ *   `rejected`, `timeout`), `reason`/`stage` carry the server's `connection-rejected` verdict, `elapsedMs` and `online`
+ *   help tell a device/network problem from a refusal, and `retryable` is false for rejections that cannot succeed
+ *   with the same credentials. `describeMediaSocketError(error)` turns it into a user-facing sentence.
  *
  * @example
  * ```typescript
@@ -135,16 +146,32 @@ async function connectSocket(
       });
     }
 
-    // Dispose failed handshakes immediately. Otherwise Socket.IO continues
-    // reconnecting a client that was never handed to the room lifecycle.
+    // Every path below runs at most once, clears handshake listeners/timers,
+    // and closes failed clients so Socket.IO cannot keep reconnecting an
+    // orphan that the room lifecycle never received.
     let settled = false;
     let timeoutHandle: ReturnType<typeof setTimeout> | undefined;
+    const startedAt = Date.now();
+    let transportOpened = false;
+    let rejection: { reason: MediaConnectionRejectionReason; stage?: string } | null = 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: MediaSocketConnectPhase, transportError?: string) =>
+      new MediaSocketConnectError({
+        phase: rejection ? 'rejected' : phase,
+        reason: rejection?.reason,
+        stage: rejection?.stage,
+        elapsedMs: Date.now() - startedAt,
+        online: currentOnlineState(),
+        transportError,
+        link,
+      });
     const settle = (action: () => void) => {
       if (settled) return;
       settled = true;
@@ -152,6 +179,7 @@ async function connectSocket(
       action();
     };
 
+    // Handle socket connection events
     const handleConnectionSuccess = ({ socketId }: { socketId: string }) => {
       //check if link contains mediasfu.com and contains more than one c
       let conn = 'media';
@@ -170,24 +198,47 @@ async function connectSocket(
     const handleConnectError = (error: 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;
+    };
+
+    // Media admission v2: the node says why before it closes the handshake. Socket.IO's own reconnection never
+    // retries a server-side close, and settling here stops this attempt from being retried as a network error.
+    const handleConnectionRejected = (payload?: { reason?: string; stage?: string }) => {
+      rejection = {
+        reason: normalizeRejectionReason(payload?.reason),
+        stage: typeof payload?.stage === 'string' ? payload.stage : undefined,
+      };
+      settle(() => {
+        try {
+          socket.disconnect();
+        } catch {
+          // Already closing.
+        }
+        reject(failure('rejected'));
+      });
+    };
+
+    // The transport can connect and then be dropped by the server before it
+    // ever sends `connection-success` — a rejected room, an expired token, a
+    // bad handshake. Without this the promise stayed pending forever, so the
+    // caller's loading modal never came down and no error was ever surfaced.
     const handleDisconnectBeforeReady = (reason: string) => {
-      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);
 
+    // Last resort, for the case where the socket neither connects, errors nor
+    // disconnects. Nothing above guarantees a settle on its own.
     timeoutHandle = setTimeout(() => {
       settle(() => {
         try {
@@ -195,7 +246,7 @@ async function connectSocket(
         } catch {
           // Nothing useful to do here.
         }
-        reject(new Error('Timed out connecting to media socket.'));
+        reject(failure('timeout'));
       });
     }, CONNECT_TIMEOUT_MS);
   });
@@ -237,6 +288,11 @@ async function connectLocalSocket({ link }: ConnectLocalSocketOptions): Promise<
     socket = io(`${link}/media`, {
       transports: ['websocket'],
     });
+    const startedAt = Date.now();
+    let transportOpened = false;
+    socket.on('connect', () => {
+      transportOpened = true;
+    });
 
 
     // Handle socket connection events
@@ -245,7 +301,15 @@ async function connectLocalSocket({ link }: ConnectLocalSocketOptions): Promise<
     });
 
     socket.on('connect_error', (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,
+        })
+      );
     });
   });
 }

package/src/sockets/mediaSocketErrors.ts

@@ -0,0 +1,156 @@
+/**
+ * Media socket connection errors.
+ *
+ * A media node that refuses a handshake emits `connection-rejected { reason, stage }` just before it closes the socket
+ * (media admission v2). `connectSocket` turns that, and every other way a connection can fail, into a
+ * `MediaSocketConnectError` that says what happened, when and whether trying again can help.
+ */
+
+/** Reasons a media node sends with `connection-rejected`. */
+export type MediaConnectionRejectionReason =
+  | 'invalid-credentials'
+  | 'meeting-minutes-unavailable'
+  | 'api-check-failed'
+  | 'invalid-request'
+  | 'rejected-before-connection-success';
+
+/**
+ * Where the attempt stopped:
+ * - `before-open`: the transport never opened (offline, DNS, TLS, firewall, server down);
+ * - `after-open`: the transport opened but closed or errored before `connection-success`;
+ * - `rejected`: the server refused the handshake and said why (`reason`);
+ * - `timeout`: nothing settled in time.
+ */
+export type MediaSocketConnectPhase = 'before-open' | 'after-open' | 'rejected' | 'timeout';
+
+export const MEDIA_CONNECTION_REJECTION_REASONS: readonly MediaConnectionRejectionReason[] = [
+  'invalid-credentials',
+  'meeting-minutes-unavailable',
+  'api-check-failed',
+  'invalid-request',
+  'rejected-before-connection-success',
+];
+
+/** Rejections that will fail the same way if retried with the same credentials. */
+const PERMANENT_REJECTIONS = new Set<string>(['invalid-credentials', 'meeting-minutes-unavailable', 'invalid-request']);
+
+export interface MediaSocketConnectErrorDetails {
+  phase: MediaSocketConnectPhase;
+  /** Rejection reason from the server (phase `rejected`), else undefined. */
+  reason?: MediaConnectionRejectionReason;
+  /** Server-side admission stage from `connection-rejected`, e.g. `api-check-rejected`. */
+  stage?: string;
+  /** Milliseconds from the start of the attempt to the failure. */
+  elapsedMs: number;
+  /** `navigator.onLine` when available. `false` points at the device's network, not the server. */
+  online?: boolean;
+  /** Underlying transport error or disconnect reason, e.g. `websocket error`, `io server disconnect`. */
+  transportError?: string;
+  /** Socket link the attempt targeted. */
+  link?: string;
+}
+
+export class MediaSocketConnectError extends Error implements MediaSocketConnectErrorDetails {
+  readonly phase: MediaSocketConnectPhase;
+  readonly reason?: MediaConnectionRejectionReason;
+  readonly stage?: string;
+  readonly elapsedMs: number;
+  readonly online?: boolean;
+  readonly transportError?: string;
+  readonly link?: string;
+  /** False when retrying with the same credentials cannot succeed (bad credentials, no minutes, bad request). */
+  readonly retryable: boolean;
+
+  constructor(details: MediaSocketConnectErrorDetails) {
+    super(formatMediaSocketError(details));
+    Object.setPrototypeOf(this, MediaSocketConnectError.prototype);
+    this.name = 'MediaSocketConnectError';
+    this.phase = details.phase;
+    this.reason = details.reason;
+    this.stage = details.stage;
+    this.elapsedMs = details.elapsedMs;
+    this.online = details.online;
+    this.transportError = details.transportError;
+    this.link = details.link;
+    this.retryable = !(details.phase === 'rejected' && details.reason && PERMANENT_REJECTIONS.has(details.reason));
+  }
+}
+
+/** Maps any reason string from the server onto a known reason (unknown values become `rejected-before-connection-success`). */
+export const normalizeRejectionReason = (reason: unknown): MediaConnectionRejectionReason =>
+  (MEDIA_CONNECTION_REJECTION_REASONS as readonly string[]).includes(String(reason))
+    ? (reason as MediaConnectionRejectionReason)
+    : 'rejected-before-connection-success';
+
+/** `navigator.onLine` where it exists (browsers, some React Native runtimes), else undefined. */
+export const currentOnlineState = (): boolean | undefined => {
+  try {
+    const nav = (globalThis as { navigator?: { onLine?: unknown } }).navigator;
+    return typeof nav?.onLine === 'boolean' ? nav.onLine : undefined;
+  } catch {
+    return undefined;
+  }
+};
+
+/** Technical one-liner for logs; keeps the historic "Error connecting to media socket:" prefix for transport failures. */
+export function formatMediaSocketError(details: MediaSocketConnectErrorDetails): string {
+  const facts = [`phase: ${details.phase}`, `after ${Math.max(0, Math.round(details.elapsedMs))} ms`];
+  if (details.online !== undefined) facts.push(`online: ${details.online}`);
+  if (details.stage) facts.push(`stage: ${details.stage}`);
+  const tail = ` (${facts.join(', ')})`;
+  switch (details.phase) {
+    case 'rejected':
+      return `Media server rejected the connection: ${details.reason || 'rejected-before-connection-success'}${tail}`;
+    case 'timeout':
+      return `Timed out connecting to media socket${tail}`;
+    case 'after-open':
+      return `Media socket closed before the room was ready: ${details.transportError || 'unknown'}${tail}`;
+    default:
+      return `Error connecting to media socket: ${details.transportError || 'unknown'}${tail}`;
+  }
+}
+
+export const isMediaSocketConnectError = (error: unknown): error is MediaSocketConnectError =>
+  error instanceof MediaSocketConnectError ||
+  (typeof error === 'object' && error !== null && (error as { name?: unknown }).name === 'MediaSocketConnectError');
+
+/**
+ * True when the attempt failed because of the device's network (offline, or the transport never opened) rather than
+ * a server refusal. Join pages do not count these toward the attempt limit: they are not credential guesses.
+ */
+export const isNetworkOnlyMediaSocketError = (error: unknown): boolean =>
+  isMediaSocketConnectError(error) &&
+  error.phase !== 'rejected' &&
+  (error.online === false || error.phase === 'before-open');
+
+/** False only for rejections that cannot succeed on retry with the same credentials. */
+export const isRetryableMediaSocketError = (error: unknown): boolean =>
+  !isMediaSocketConnectError(error) || error.retryable;
+
+/** A sentence suitable for an end user (alert/toast). Falls back to `fallback` for unknown errors. */
+export function describeMediaSocketError(
+  error: unknown,
+  fallback = 'Unable to connect. Check your credentials and try again.',
+): string {
+  if (!isMediaSocketConnectError(error)) return fallback;
+  if (error.phase === 'rejected') {
+    switch (error.reason) {
+      case 'invalid-credentials':
+        return 'The room did not accept these credentials. Check the room ID and your access, or rejoin the room.';
+      case 'meeting-minutes-unavailable':
+        return 'This room cannot start because its account has no meeting minutes left. Contact the room host.';
+      case 'invalid-request':
+        return 'The connection request was incomplete or invalid. Check the room details and try again.';
+      case 'api-check-failed':
+        return 'The media server could not verify this room right now. Please try again shortly.';
+      default:
+        return 'The media server closed the connection before the room was ready. Please try again.';
+    }
+  }
+  if (error.online === false) return 'You appear to be offline. Check your internet connection and try again.';
+  if (error.phase === 'before-open') {
+    return 'Could not reach the media server. Check your network or firewall and try again.';
+  }
+  if (error.phase === 'timeout') return 'Connecting to the media server timed out. Please try again.';
+  return 'The media server closed the connection before the room was ready. Please try again.';
+}

package/src/types/shared-base-types.ts

@@ -8,6 +8,8 @@ export interface Participant {
   videoID: string;
   ScreenID?: string;
   ScreenOn?: boolean;
+  /** The participant's screen-audio producer id while they share screen audio ("" or absent otherwise). */
+  ScreenAudioID?: string;
   islevel?: string;
   isAdmin?: boolean;
   isHost?: boolean;
@@ -405,6 +407,8 @@ export interface ResponseJoinRoom {
   banned?: boolean;
   suspended?: boolean;
   noAdmin?: boolean;
+  /** The media server accepts audio shared with a screen share ("screen-audio" producers). */
+  supportsScreenAudio?: boolean;
 }
 
 export interface AllMembersData {

package/dist/audioProcessing-0z5KlcmO.js

@@ -1,35 +0,0 @@
-const validateAlphanumeric = async ({ str }) => {
-  let code, i, len;
-  for (i = 0, len = str.length; i < len; i++) {
-    code = str.charCodeAt(i);
-    if (!(code > 47 && code < 58) && // numeric (0-9)
-    !(code > 64 && code < 91) && // upper alpha (A-Z)
-    !(code > 96 && code < 123)) {
-      return false;
-    }
-  }
-  return true;
-};
-function audioProcessingConstraints(options) {
-  const result = {};
-  if (options === void 0) return result;
-  if (!options || typeof options !== "object" || Array.isArray(options)) throw new TypeError("Invalid audioProcessing");
-  for (const key of Object.keys(options)) {
-    if (!["echoCancellation", "noiseSuppression", "autoGainControl"].includes(key)) throw new TypeError("Unsupported audioProcessing option");
-    const value = options[key];
-    if (value !== void 0 && typeof value !== "boolean") throw new TypeError("Audio processing options must be boolean");
-    if (value !== void 0) result[key] = value;
-  }
-  return result;
-}
-async function applyAudioProcessing(track, options) {
-  const selected = audioProcessingConstraints(options);
-  if (!Object.keys(selected).length) return;
-  await track.applyConstraints({ ...track.getConstraints(), ...selected });
-}
-export {
-  applyAudioProcessing as a,
-  audioProcessingConstraints as b,
-  validateAlphanumeric as v
-};
-//# sourceMappingURL=audioProcessing-0z5KlcmO.js.map

package/dist/audioProcessing-0z5KlcmO.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"audioProcessing-0z5KlcmO.js","sources":["../src/methods/utils/validateAlphanumeric.ts","../src/consumers/audioProcessing.ts"],"sourcesContent":["\nexport interface ValidateAlphanumericOptions {\n  str: string;\n}\n\n// Export the type definition for the function\nexport type ValidateAlphanumericType = (options: ValidateAlphanumericOptions) => Promise<boolean>;\n\n/**\n * Validates if the given string contains only alphanumeric characters.\n *\n * @param {ValidateAlphanumericOptions} options - The options containing the string to validate.\n * @param {string} options.str - The string to be validated.\n * @returns {Promise<boolean>} - A promise that resolves to `true` if the string is alphanumeric, otherwise `false`.\n * \n * @example\n * ```typescript \n * const isValid = await validateAlphanumeric({ str: \"abc123\" });\n * console.log(isValid);\n * // Output: true\n * ```\n */\n\n\nconst validateAlphanumeric = async ({ str }: ValidateAlphanumericOptions): Promise<boolean> => {\n  let code: number, i: number, len: number;\n\n  for (i = 0, len = str.length; i < len; i++) {\n    code = str.charCodeAt(i);\n    if (\n      !(code > 47 && code < 58) && // numeric (0-9)\n      !(code > 64 && code < 91) && // upper alpha (A-Z)\n      !(code > 96 && code < 123)   // lower alpha (a-z)\n    ) {\n      return false;\n    }\n  }\n  return true;\n};\n\nexport { validateAlphanumeric };\n","export type AudioProcessingOptions = {\n  echoCancellation?: boolean;\n  noiseSuppression?: boolean;\n  autoGainControl?: boolean;\n};\n\nexport function audioProcessingConstraints(options?: AudioProcessingOptions): MediaTrackConstraints {\n  const result: MediaTrackConstraints = {};\n  if (options === undefined) return result;\n  if (!options || typeof options !== 'object' || Array.isArray(options)) throw new TypeError('Invalid audioProcessing');\n  for (const key of Object.keys(options)) {\n    if (!['echoCancellation', 'noiseSuppression', 'autoGainControl'].includes(key)) throw new TypeError('Unsupported audioProcessing option');\n    const value = options[key as keyof AudioProcessingOptions];\n    if (value !== undefined && typeof value !== 'boolean') throw new TypeError('Audio processing options must be boolean');\n    if (value !== undefined) result[key as keyof AudioProcessingOptions] = value;\n  }\n  return result;\n}\n\n// applyConstraints replaces the constraint set: merge to retain device and\n// capture choices unrelated to the three processing preferences.\nexport async function applyAudioProcessing(track: MediaStreamTrack, options?: AudioProcessingOptions): Promise<void> {\n  const selected = audioProcessingConstraints(options);\n  if (!Object.keys(selected).length) return;\n  await track.applyConstraints({ ...track.getConstraints(), ...selected });\n}\n"],"names":[],"mappings":"AAwBA,MAAM,uBAAuB,OAAO,EAAE,UAAyD;AAC7F,MAAI,MAAc,GAAW;AAE7B,OAAK,IAAI,GAAG,MAAM,IAAI,QAAQ,IAAI,KAAK,KAAK;AAC1C,WAAO,IAAI,WAAW,CAAC;AACvB,QACE,EAAE,OAAO,MAAM,OAAO;AAAA,IACtB,EAAE,OAAO,MAAM,OAAO;AAAA,IACtB,EAAE,OAAO,MAAM,OAAO,MACtB;AACA,aAAO;AAAA,IACT;AAAA,EACF;AACA,SAAO;AACT;AChCO,SAAS,2BAA2B,SAAyD;AAClG,QAAM,SAAgC,CAAA;AACtC,MAAI,YAAY,OAAW,QAAO;AAClC,MAAI,CAAC,WAAW,OAAO,YAAY,YAAY,MAAM,QAAQ,OAAO,EAAG,OAAM,IAAI,UAAU,yBAAyB;AACpH,aAAW,OAAO,OAAO,KAAK,OAAO,GAAG;AACtC,QAAI,CAAC,CAAC,oBAAoB,oBAAoB,iBAAiB,EAAE,SAAS,GAAG,EAAG,OAAM,IAAI,UAAU,oCAAoC;AACxI,UAAM,QAAQ,QAAQ,GAAmC;AACzD,QAAI,UAAU,UAAa,OAAO,UAAU,UAAW,OAAM,IAAI,UAAU,0CAA0C;AACrH,QAAI,UAAU,OAAW,QAAO,GAAmC,IAAI;AAAA,EACzE;AACA,SAAO;AACT;AAIA,eAAsB,qBAAqB,OAAyB,SAAiD;AACnH,QAAM,WAAW,2BAA2B,OAAO;AACnD,MAAI,CAAC,OAAO,KAAK,QAAQ,EAAE,OAAQ;AACnC,QAAM,MAAM,iBAAiB,EAAE,GAAG,MAAM,eAAA,GAAkB,GAAG,UAAU;AACzE;"}