mediasfu-shared 1.2.7 → 1.3.1

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/disconnectSendTransportScreen.ts

@@ -1,5 +1,6 @@
 import type { Producer } from 'mediasoup-client/types';
 import { Socket } from "socket.io-client";
+import { disconnectSendTransportScreenAudio } from "./connectSendTransportScreenAudio";
 
 export interface DisconnectSendTransportScreenParameters {
     screenProducer: Producer | null;
@@ -94,6 +95,13 @@ export const disconnectSendTransportScreen = async ({ parameters }: DisconnectSe
     let { getUpdatedAllParams } = parameters;
     parameters = getUpdatedAllParams()
 
+    try {
+        // Screen audio stops with the screen share (the server closes its side on closeScreenProducer).
+        await disconnectSendTransportScreenAudio({ parameters: parameters as any });
+    } catch {
+        // nothing to close
+    }
+
     try {
         // Destructure parameters
         let {

package/src/consumers/getPipedProducersAlt.ts

@@ -1,5 +1,6 @@
 import { Socket } from "socket.io-client";
 import { SignalNewConsumerTransportParameters, SignalNewConsumerTransportType } from '../types/types';
+import { markScreenAudioProducer } from './screenAudio';
 
 interface TranslationMeta {
   speakerId: string;
@@ -12,6 +13,8 @@ interface TranslationMeta {
 interface ProducerInfo {
   id: string;
   translationMeta?: TranslationMeta | null;
+  /** "screen-audio" for audio shared with a screen share. */
+  mediaTag?: string;
 }
 
 export interface GetPipedProducersAltParameters extends Omit<SignalNewConsumerTransportParameters, 'getUpdatedAllParams'> {
@@ -151,6 +154,7 @@ export const getPipedProducersAlt = async ({
             } else {
               producerId = producer.id;
               translationMeta = producer.translationMeta || null;
+              markScreenAudioProducer(producerId, producer.mediaTag);
             }
 
             if (translationMeta) {

package/src/consumers/index.ts

@@ -13,6 +13,9 @@ export * from './connectRecvTransport';
 export * from './connectSendTransport';
 export * from './connectSendTransportAudio';
 export * from './connectSendTransportScreen';
+export * from './connectSendTransportScreenAudio';
+export * from './screenAudio';
+export * from './consumerBackupPreference';
 export * from './connectSendTransportVideo';
 export * from './consumerResume';
 export * from './controlMedia';

package/src/consumers/screenAudio.ts

@@ -0,0 +1,132 @@
+import type { Producer } from "mediasoup-client/types";
+import { Participant } from "../types/types";
+
+/**
+ * Screen audio: the audio of a shared tab, window or screen, published as its own producer tagged
+ * `appData.mediaTag === "screen-audio"`. It belongs to the screen share (starts, pauses, resumes and stops with it),
+ * never to the sharer's microphone, so it never marks the sharer as speaking.
+ *
+ * A client only publishes it when the media server says so in the join response (`supportsScreenAudio`), so new
+ * clients keep today's video-only screen share on older servers.
+ */
+export const SCREEN_AUDIO_MEDIA_TAG = "screen-audio";
+
+/** Opus settings for shared media (music, video soundtracks) rather than voice. */
+export const SCREEN_AUDIO_CODEC_OPTIONS = {
+  opusStereo: true,
+  opusDtx: false,
+  opusFec: true,
+  opusMaxAverageBitrate: 128000,
+};
+
+// Producer ids are globally unique, so one registry serves every room instance on the page.
+const screenAudioProducerIds = new Set<string>();
+
+/** Records a producer announced by the server as screen audio (`mediaTag: "screen-audio"`). */
+export const markScreenAudioProducer = (producerId?: string | null, mediaTag?: string | null): void => {
+  if (producerId && mediaTag === SCREEN_AUDIO_MEDIA_TAG) screenAudioProducerIds.add(producerId);
+};
+
+export const forgetScreenAudioProducer = (producerId?: string | null): void => {
+  if (producerId) screenAudioProducerIds.delete(producerId);
+};
+
+export interface IsScreenAudioProducerOptions {
+  producerId: string;
+  participants?: Participant[];
+  appData?: Record<string, unknown> | null;
+}
+
+/** True when the producer is screen audio, by server tag, consumer appData or the sharer's `ScreenAudioID`. */
+export const isScreenAudioProducer = ({ producerId, participants = [], appData }: IsScreenAudioProducerOptions): boolean => {
+  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);
+};
+
+/**
+ * How a screen share treats audio: `ask` (default) shows a choice before the browser's picker, `always` requests audio
+ * without asking, `never` shares video only.
+ */
+export type ScreenAudioMode = "ask" | "always" | "never";
+
+export interface ScreenAudioSettings {
+  supportsScreenAudio?: boolean;
+  screenAudioEnabled?: boolean;
+  screenAudioMode?: ScreenAudioMode;
+}
+
+/** Screen audio is requested only when the server supports it and the app has not turned it off. */
+export const shouldShareScreenAudio = ({ supportsScreenAudio, screenAudioEnabled, screenAudioMode }: ScreenAudioSettings): boolean =>
+  supportsScreenAudio === true && screenAudioEnabled !== false && screenAudioMode !== "never";
+
+/**
+ * Whether this browser can capture the audio of a shared tab or screen. Chromium desktop browsers (Chrome, Edge,
+ * Opera, Brave) can; Firefox, Safari and mobile browsers return video only.
+ */
+export const canCaptureDisplayAudio = (nav: Partial<Navigator> | undefined = typeof navigator !== "undefined" ? navigator : undefined): boolean => {
+  if (!nav) return false;
+  const ua = String(nav.userAgent || "");
+  if (/Mobi|Android|iPhone|iPad|iPod/i.test(ua)) return false;
+  const brands: string[] = ((nav as any).userAgentData?.brands || []).map((entry: { brand?: string }) => 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);
+};
+
+/** The user's answer to "share audio too?": `audio`, `video` (screen only) or `null` (cancelled). */
+export type ScreenAudioChoice = "audio" | "video" | null;
+
+/** Mutes or unmutes the sharer's screen audio without stopping the screen share. Returns the new paused state. */
+export const setScreenAudioPaused = (producer: Producer | null | undefined, paused: boolean): boolean => {
+  if (!producer || producer.closed) return false;
+  if (paused && !producer.paused) producer.pause();
+  if (!paused && producer.paused) producer.resume();
+  return producer.paused;
+};
+
+export interface DisplayMediaOptionsInput {
+  targetWidth: number;
+  targetHeight: number;
+  withAudio: boolean;
+}
+
+/**
+ * Options for `getDisplayMedia`. With audio, the browser's picker shows its own "share audio" choice, which is the
+ * user's consent; browsers that cannot capture display audio (Firefox, Safari) return a video-only stream.
+ */
+export const buildDisplayMediaOptions = ({ targetWidth, targetHeight, withAudio }: DisplayMediaOptionsInput) => {
+  const options: Record<string, unknown> = {
+    video: { width: targetWidth, height: targetHeight, frameRate: 30 },
+    audio: withAudio
+      ? { echoCancellation: false, noiseSuppression: false, autoGainControl: false }
+      : false,
+  };
+  if (withAudio) {
+    // Chromium hints; other browsers ignore unknown members.
+    options.systemAudio = "include";
+    options.suppressLocalAudioPlayback = false;
+  }
+  return options as DisplayMediaStreamOptions;
+};
+
+// Fallback holder for apps whose parameters have no `screenAudioProducer` state.
+const producersBySocket = new WeakMap<object, Producer>();
+
+export const rememberScreenAudioProducer = (socket: object | null | undefined, producer: Producer | null): void => {
+  if (!socket) return;
+  if (producer) producersBySocket.set(socket, producer);
+  else producersBySocket.delete(socket);
+};
+
+export const recallScreenAudioProducer = (socket: object | null | undefined): Producer | null =>
+  (socket && producersBySocket.get(socket)) || null;
+
+/** Sets the listening volume (0..1) of every screen-audio player on the page. */
+export const setScreenAudioVolume = (volume: number, root: ParentNode | null = typeof document !== "undefined" ? document : null): void => {
+  if (!root) return;
+  const value = Math.min(1, Math.max(0, Number.isFinite(volume) ? volume : 1));
+  root.querySelectorAll<HTMLAudioElement>('audio[data-screen-audio="true"]').forEach((element) => {
+    element.volume = value;
+  });
+};

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/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);
   }
 }