@signalwire/js 4.0.0-rc.2 → 4.0.0-rc.3

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { $ as DEFAULT_DEGRADATION_BITRATE_THRESHOLD_KBPS, $t as VAD_HOLD_MS, A as SerializationError, At as DEFAULT_STATS_POLLING_INTERVAL_MS, B as VertoInviteHandlerError, Bt as DEVICE_TOKEN_ENDPOINT, C as MessageParseError, Ct as DEFAULT_REINVITE_MAX_ATTEMPTS, D as RecoveryError, Dt as DEFAULT_STATS_JITTER_SPIKE_MULTIPLIER, E as RPCTimeoutError, Et as DEFAULT_STATS_HISTORY_SIZE, F as TransportConnectionError, Ft as DEVICE_REFRESH_ENDPOINT, G as CREDENTIAL_ACTIVATE_TIMEOUT_MS, Gt as INVITE_VERSION, H as WebSocketConnectionError, Ht as DEVICE_TOKEN_REFRESH_MAX_RETRIES, I as UnexpectedError, It as DEVICE_STORAGE_KEY_AUDIO_INPUT, J as CREDENTIAL_REFRESH_MAX_RETRIES, Jt as PREFERENCES_STORAGE_KEY, K as CREDENTIAL_REFRESH_BUFFER_MS, Kt as PEER_CONNECTION_RECOVERY_POLL_MS, L as UnimplementedError, Lt as DEVICE_STORAGE_KEY_AUDIO_OUTPUT, M as StorageReadError, Mt as DEFAULT_STEREO_AUDIO, N as StorageWriteError, Nt as DEFAULT_STEREO_MAX_AVERAGE_BITRATE, O as RequestError, Ot as DEFAULT_STATS_NO_PACKET_THRESHOLD_MS, P as TokenRefreshError, Pt as DEFAULT_SYNC_DEVICES_TO_ACTIVE_CALLS, Q as DEFAULT_CONNECTION_TIMEOUT_MS, Qt as SAT_REFRESH_SCOPE, R as ValidationError, Rt as DEVICE_STORAGE_KEY_VIDEO_INPUT, S as MediaTrackError, St as DEFAULT_REINVITE_DEBOUNCE_TIME_MS, T as PreflightError, Tt as DEFAULT_STATS_BASELINE_SAMPLES, U as WebSocketTimeoutError, Ut as DEVICE_TOKEN_REFRESH_RETRY_BASE_MS, V as VertoPongError, Vt as DEVICE_TOKEN_REFRESH_BUFFER_MS, W as AUDIO_LEVEL_POLL_INTERVAL_MS, Wt as ICE_GATHERING_COMPLETE_TIMEOUT_MS, X as DEFAULT_AUTO_MUTE_VIDEO_ON_HIDDEN, Xt as RPC_ERROR_INVALID_PARAMS, Y as CREDENTIAL_REFRESH_RETRY_BASE_MS, Yt as RPC_ERROR_AUTHENTICATION_FAILED, Z as DEFAULT_CHECK_CONNECTION_ON_VISIBLE, Zt as RPC_ERROR_REQUESTER_VALIDATION_FAILED, _ as DeviceTokenError, _t as DEFAULT_RECONNECT_DELAY_MAX_MS, a as filterNull, at as DEFAULT_ENABLE_RELAY_FALLBACK, b as JSONRPCError, bt as DEFAULT_RECOVERY_DEBOUNCE_TIME_MS, c as setLogLevel, ct as DEFAULT_ICE_DISCONNECTED_GRACE_PERIOD_MS, d as CallCreateError, dt as DEFAULT_KEYFRAME_BURST_WINDOW_MS$1, en as VAD_THRESHOLD, et as DEFAULT_DEGRADATION_RECOVERY_THRESHOLD_KBPS, f as CollectionFetchError, ft as DEFAULT_KEYFRAME_COOLDOWN_MS$1, g as DeserializationError, gt as DEFAULT_RECONNECT_CALLS_TIMEOUT_MS, h as DependencyError, ht as DEFAULT_PERSIST_DEVICE_SELECTION, i as getValueFrom, it as DEFAULT_ENABLE_NETWORK_CHANGE_DETECTION, j as StorageNotAvailableError, jt as DEFAULT_STATS_RTT_SPIKE_MULTIPLIER, k as RequestTimeoutError, kt as DEFAULT_STATS_PACKET_LOSS_THRESHOLD, l as setLogger, lt as DEFAULT_ICE_GATHERING_TIMEOUT_MS, m as DPoPInitError, mt as DEFAULT_MAX_RECOVERY_ATTEMPTS, n as filterAs, nt as DEFAULT_DEVICE_POLLING_INTERVAL_MS, o as getLogger, ot as DEFAULT_ENABLE_SERVER_HANGUP_INTERCEPTION, p as ConversationError, pt as DEFAULT_KEYFRAME_MAX_BURST$1, q as CREDENTIAL_REFRESH_MAX_DELAY_MS, qt as PEER_CONNECTION_RECOVERY_WAIT_MS, rt as DEFAULT_ENABLE_AUTO_DEGRADATION, s as setDebugOptions, st as DEFAULT_ICE_CANDIDATE_TIMEOUT_MS, t as throwOnRPCError, tt as DEFAULT_DEVICE_DEBOUNCE_TIME_MS, u as AuthStateHandlerError, ut as DEFAULT_ICE_RESTART_TIMEOUT_MS$1, v as InvalidCredentialsError, vt as DEFAULT_RECONNECT_DELAY_MIN_MS, w as OverconstrainedFallbackError, wt as DEFAULT_REINVITE_TIMEOUT_MS, x as MediaAccessError, xt as DEFAULT_REFRESH_DEVICES_ON_VISIBLE, y as InvalidParams, yt as DEFAULT_RECOVERY_COOLDOWN_MS, z as VertoAttachHandlerError, zt as DEVICE_TOKEN_DEFAULT_EXPIRE_IN } from "./operators-BlUtq-t0.mjs";
+import { $ as CREDENTIAL_REFRESH_BUFFER_MS, $t as ICE_GATHERING_COMPLETE_TIMEOUT_MS, A as RPCTimeoutError, At as DEFAULT_REFRESH_DEVICES_ON_VISIBLE, B as TransportConnectionError, Bt as DEFAULT_STATS_RTT_SPIKE_MULTIPLIER, C as JSONRPCError, Ct as DEFAULT_MAX_RECOVERY_ATTEMPTS, D as OverconstrainedFallbackError, Dt as DEFAULT_RECONNECT_DELAY_MIN_MS, E as MessageParseError, Et as DEFAULT_RECONNECT_DELAY_MAX_MS, F as SerializationError, Ft as DEFAULT_STATS_HISTORY_SIZE, G as VertoInviteHandlerError, Gt as DEVICE_STORAGE_KEY_AUDIO_INPUT, H as UnimplementedError, Ht as DEFAULT_STEREO_MAX_AVERAGE_BITRATE, I as StorageNotAvailableError, It as DEFAULT_STATS_JITTER_SPIKE_MULTIPLIER, J as WebSocketTimeoutError, Jt as DEVICE_TOKEN_DEFAULT_EXPIRE_IN, K as VertoPongError, Kt as DEVICE_STORAGE_KEY_AUDIO_OUTPUT, L as StorageReadError, Lt as DEFAULT_STATS_NO_PACKET_THRESHOLD_MS, M as RequestError, Mt as DEFAULT_REINVITE_MAX_ATTEMPTS, N as RequestTimeoutError, Nt as DEFAULT_REINVITE_TIMEOUT_MS, O as ParticipantNotReadyError, Ot as DEFAULT_RECOVERY_COOLDOWN_MS, P as ScreenShareAlreadyActiveError, Pt as DEFAULT_STATS_BASELINE_SAMPLES, Q as CREDENTIAL_EXPIRY_SKEW_MS, Qt as DEVICE_TOKEN_REFRESH_RETRY_BASE_MS, R as StorageWriteError, Rt as DEFAULT_STATS_PACKET_LOSS_THRESHOLD, S as InvalidParams, St as DEFAULT_KEYFRAME_MAX_BURST$1, T as MediaTrackError, Tt as DEFAULT_RECONNECT_CALLS_TIMEOUT_MS, U as ValidationError, Ut as DEFAULT_SYNC_DEVICES_TO_ACTIVE_CALLS, V as UnexpectedError, Vt as DEFAULT_STEREO_AUDIO, W as VertoAttachHandlerError, Wt as DEVICE_REFRESH_ENDPOINT, X as AUDIO_LEVEL_POLL_INTERVAL_MS, Xt as DEVICE_TOKEN_REFRESH_BUFFER_MS, Y as isMediaDeviceInUse, Yt as DEVICE_TOKEN_ENDPOINT, Z as CREDENTIAL_ACTIVATE_TIMEOUT_MS, Zt as DEVICE_TOKEN_REFRESH_MAX_RETRIES, _ as DPoPInitError, _t as DEFAULT_ICE_DISCONNECTED_GRACE_PERIOD_MS, a as filterNull, an as RPC_ERROR_INVALID_PARAMS, at as DEFAULT_CALL_SIGNALING_TIMEOUT_MS, b as DeviceTokenError, bt as DEFAULT_KEYFRAME_BURST_WINDOW_MS$1, c as setLogLevel, cn as VAD_HOLD_MS, ct as DEFAULT_DEGRADATION_BITRATE_THRESHOLD_KBPS, d as AuxiliaryLegCancelledError, dt as DEFAULT_DEVICE_POLLING_INTERVAL_MS, en as INVITE_VERSION, et as CREDENTIAL_REFRESH_MAX_DELAY_MS, f as AuxiliaryLegTimeoutError, ft as DEFAULT_ENABLE_AUTO_DEGRADATION, g as ConversationError, gt as DEFAULT_ICE_CANDIDATE_TIMEOUT_MS, h as CollectionFetchError, ht as DEFAULT_ENABLE_SERVER_HANGUP_INTERCEPTION, i as getValueFrom, in as RPC_ERROR_AUTHENTICATION_FAILED, it as DEFAULT_AUX_LEG_CONNECT_TIMEOUT_MS, j as RecoveryError, jt as DEFAULT_REINVITE_DEBOUNCE_TIME_MS, k as PreflightError, kt as DEFAULT_RECOVERY_DEBOUNCE_TIME_MS, l as setLogger, ln as VAD_THRESHOLD, lt as DEFAULT_DEGRADATION_RECOVERY_THRESHOLD_KBPS, m as CallNotReadyError, mt as DEFAULT_ENABLE_RELAY_FALLBACK, n as filterAs, nn as PEER_CONNECTION_RECOVERY_WAIT_MS, nt as CREDENTIAL_REFRESH_RETRY_BASE_MS, o as getLogger, on as RPC_ERROR_REQUESTER_VALIDATION_FAILED, ot as DEFAULT_CHECK_CONNECTION_ON_VISIBLE, p as CallCreateError, pt as DEFAULT_ENABLE_NETWORK_CHANGE_DETECTION, q as WebSocketConnectionError, qt as DEVICE_STORAGE_KEY_VIDEO_INPUT, rn as PREFERENCES_STORAGE_KEY, rt as DEFAULT_AUTO_MUTE_VIDEO_ON_HIDDEN, s as setDebugOptions, sn as SAT_REFRESH_SCOPE, st as DEFAULT_CONNECTION_TIMEOUT_MS, t as throwOnRPCError, tn as PEER_CONNECTION_RECOVERY_POLL_MS, tt as CREDENTIAL_REFRESH_MAX_RETRIES, u as AuthStateHandlerError, ut as DEFAULT_DEVICE_DEBOUNCE_TIME_MS, v as DependencyError, vt as DEFAULT_ICE_GATHERING_TIMEOUT_MS, w as MediaAccessError, wt as DEFAULT_PERSIST_DEVICE_SELECTION, x as InvalidCredentialsError, xt as DEFAULT_KEYFRAME_COOLDOWN_MS$1, y as DeserializationError, yt as DEFAULT_ICE_RESTART_TIMEOUT_MS$1, z as TokenRefreshError, zt as DEFAULT_STATS_POLLING_INTERVAL_MS } from "./operators-BVxi3KpN.mjs";
 import { jwtDecode } from "jwt-decode";
 import { BehaviorSubject, EMPTY, EmptyError, NEVER, Observable, ReplaySubject, Subject, TimeoutError, animationFrameScheduler, asapScheduler, auditTime, catchError, combineLatest, debounceTime, defer, distinctUntilChanged, exhaustMap, filter, first, firstValueFrom, from, interval, lastValueFrom, map, merge, mergeMap, observeOn, of, pipe, race, scan, share, shareReplay, skip, skipWhile, startWith, switchMap, take, takeUntil, tap, throwError, timeout, timer, toArray, withLatestFrom } from "rxjs";
 import { v4 } from "uuid";
@@ -131,7 +131,7 @@ const asyncRetry = async ({ asyncCallable, maxRetries: retries = DEFAULT_MAX_RET
 
 //#endregion
 //#region src/controllers/HTTPRequestController.ts
-const logger$31 = getLogger();
+const logger$32 = getLogger();
 const GET_PARAMS = {
 	method: "GET",
 	headers: { Accept: "application/json" }
@@ -195,7 +195,7 @@ var HTTPRequestController = class HTTPRequestController extends Destroyable {
 			this._responses$.next(response);
 			return response;
 		} catch (error) {
-			logger$31.error("[HTTPRequestController] Request error:", error);
+			logger$32.error("[HTTPRequestController] Request error:", error);
 			this._status$.next("error");
 			const err = error instanceof Error ? error : new Error("HTTP request failed", { cause: error });
 			this._errors$.next(err);
@@ -222,7 +222,7 @@ var HTTPRequestController = class HTTPRequestController extends Destroyable {
 		const url = this.buildURL(request.url);
 		const headers = this.buildHeaders(request.headers);
 		const timeout$1 = request.timeout ?? this.requestTimeout;
-		logger$31.debug("[HTTPRequestController] Executing request:", {
+		logger$32.debug("[HTTPRequestController] Executing request:", {
 			method: request.method,
 			url,
 			headers: Object.keys(headers).reduce((acc, key) => {
@@ -242,7 +242,7 @@ var HTTPRequestController = class HTTPRequestController extends Destroyable {
 			});
 			clearTimeout(timeoutId);
 			const httpResponse = await this.convertResponse(response);
-			logger$31.debug("[HTTPRequestController] Response received:", {
+			logger$32.debug("[HTTPRequestController] Response received:", {
 				status: response.status,
 				statusText: response.statusText,
 				headers: [...response.headers.entries()],
@@ -252,7 +252,7 @@ var HTTPRequestController = class HTTPRequestController extends Destroyable {
 		} catch (error) {
 			clearTimeout(timeoutId);
 			if (error instanceof Error && error.name === "AbortError") throw new RequestTimeoutError(`Request timeout after ${timeout$1}ms`, { cause: error });
-			logger$31.error("[HTTPRequestController] Request failed:", error);
+			logger$32.error("[HTTPRequestController] Request failed:", error);
 			throw error;
 		}
 	}
@@ -266,8 +266,8 @@ var HTTPRequestController = class HTTPRequestController extends Destroyable {
 		const credential = this.getCredential();
 		if (credential.token) {
 			headers.Authorization = `Bearer ${credential.token}`;
-			logger$31.debug("[HTTPRequestController] Using Bearer token auth, token length:", credential.token.length);
-		} else logger$31.warn("[HTTPRequestController] No credentials available for authentication");
+			logger$32.debug("[HTTPRequestController] Using Bearer token auth, token length:", credential.token.length);
+		} else logger$32.warn("[HTTPRequestController] No credentials available for authentication");
 		return headers;
 	}
 	/**
@@ -415,7 +415,7 @@ function fromMsToSec(milliseconds) {
 
 //#endregion
 //#region src/containers/PreferencesContainer.ts
-const logger$30 = getLogger();
+const logger$31 = getLogger();
 var PreferencesContainer = class PreferencesContainer {
 	static get instance() {
 		this._instance ??= new PreferencesContainer();
@@ -1077,7 +1077,7 @@ var ClientPreferences = class {
 		if (!this._storage) return;
 		const data = collectStoredPreferences();
 		this._storage.setItem(PREFERENCES_STORAGE_KEY, data, "local").catch((error) => {
-			logger$30.error(`[ClientPreferences] Failed to save preferences: ${String(error)}`);
+			logger$31.error(`[ClientPreferences] Failed to save preferences: ${String(error)}`);
 		});
 	}
 	/** Loads preferences from storage and applies them to the container. */
@@ -1086,7 +1086,7 @@ var ClientPreferences = class {
 		this._storage.getItem(PREFERENCES_STORAGE_KEY, "local").then((stored) => {
 			if (stored) applyStoredPreferences(stored);
 		}).catch((error) => {
-			logger$30.error(`[ClientPreferences] Failed to load preferences: ${String(error)}`);
+			logger$31.error(`[ClientPreferences] Failed to load preferences: ${String(error)}`);
 		});
 	}
 };
@@ -1107,7 +1107,7 @@ function toError(value) {
 
 //#endregion
 //#region src/controllers/NavigatorDeviceController.ts
-const logger$29 = getLogger();
+const logger$30 = getLogger();
 /** Maps a device kind to its storage key. */
 const DEVICE_STORAGE_KEYS = {
 	audioinput: DEVICE_STORAGE_KEY_AUDIO_INPUT,
@@ -1129,7 +1129,7 @@ var NavigatorDeviceController = class extends Destroyable {
 		super();
 		this.webRTCApiProvider = webRTCApiProvider;
 		this.deviceChangeHandler = () => {
-			logger$29.debug("[DeviceController] Device change detected");
+			logger$30.debug("[DeviceController] Device change detected");
 			this.enumerateDevices();
 		};
 		this._devicesState$ = this.createBehaviorSubject(initialDevicesState);
@@ -1194,13 +1194,13 @@ var NavigatorDeviceController = class extends Destroyable {
 		return this.cachedObservable("videoInputDevices$", () => this._devicesState$.pipe(map((state) => state.videoinput), distinctUntilChanged(), takeUntil(this.destroyed$)));
 	}
 	get selectedAudioInputDevice$() {
-		return this.cachedObservable("selectedAudioInputDevice$", () => this._selectedDevicesState$.asObservable().pipe(map((state) => state.audioinput), distinctUntilChanged(), takeUntil(this.destroyed$), tap((info) => logger$29.debug("[DeviceController] Selected audio input device changed:", info))));
+		return this.cachedObservable("selectedAudioInputDevice$", () => this._selectedDevicesState$.asObservable().pipe(map((state) => state.audioinput), distinctUntilChanged(), takeUntil(this.destroyed$), tap((info) => logger$30.debug("[DeviceController] Selected audio input device changed:", info))));
 	}
 	get selectedAudioOutputDevice$() {
-		return this.cachedObservable("selectedAudioOutputDevice$", () => this._selectedDevicesState$.asObservable().pipe(map((state) => state.audiooutput), distinctUntilChanged(), takeUntil(this.destroyed$), tap((info) => logger$29.debug("[DeviceController] Selected audio output device changed:", info))));
+		return this.cachedObservable("selectedAudioOutputDevice$", () => this._selectedDevicesState$.asObservable().pipe(map((state) => state.audiooutput), distinctUntilChanged(), takeUntil(this.destroyed$), tap((info) => logger$30.debug("[DeviceController] Selected audio output device changed:", info))));
 	}
 	get selectedVideoInputDevice$() {
-		return this.cachedObservable("selectedVideoInputDevice$", () => this._selectedDevicesState$.asObservable().pipe(map((state) => state.videoinput), distinctUntilChanged(), takeUntil(this.destroyed$), tap((info) => logger$29.debug("[DeviceController] Selected video input device changed:", info))));
+		return this.cachedObservable("selectedVideoInputDevice$", () => this._selectedDevicesState$.asObservable().pipe(map((state) => state.videoinput), distinctUntilChanged(), takeUntil(this.destroyed$), tap((info) => logger$30.debug("[DeviceController] Selected video input device changed:", info))));
 	}
 	get selectedAudioInputDevice() {
 		if (this._audioInputDisabled$.value) return null;
@@ -1275,7 +1275,7 @@ var NavigatorDeviceController = class extends Destroyable {
 		if (device) this.persistDeviceSelection("audioinput", device);
 	}
 	selectVideoInputDevice(device) {
-		logger$29.debug("[DeviceController] Setting selected video input device:", device);
+		logger$30.debug("[DeviceController] Setting selected video input device:", device);
 		if (this._videoInputDisabled$.value && device) this._videoInputDisabled$.next(false);
 		const previous = this._selectedDevicesState$.value.videoinput;
 		if (previous && previous.deviceId !== device?.deviceId) this._deviceHistory.push("videoinput", previous);
@@ -1332,7 +1332,7 @@ var NavigatorDeviceController = class extends Destroyable {
 			}
 			const fromHistory = this._deviceHistory.findInHistory(kind, devices);
 			if (fromHistory) {
-				logger$29.debug(`[DeviceController] Device disappeared, falling back to history: ${fromHistory.label}`);
+				logger$30.debug(`[DeviceController] Device disappeared, falling back to history: ${fromHistory.label}`);
 				this.emitDeviceRecovered(kind, selected, fromHistory, "device_disconnected");
 				return fromHistory;
 			}
@@ -1385,7 +1385,7 @@ var NavigatorDeviceController = class extends Destroyable {
 		try {
 			await this._storageManager.setItem(DEVICE_STORAGE_KEYS[kind], stored, "local");
 		} catch (error) {
-			logger$29.error(`[DeviceController] Failed to persist device selection for ${kind}:`, error);
+			logger$30.error(`[DeviceController] Failed to persist device selection for ${kind}:`, error);
 		}
 	}
 	async loadPersistedDevices() {
@@ -1401,7 +1401,7 @@ var NavigatorDeviceController = class extends Destroyable {
 				[kind]: stored
 			};
 		} catch (error) {
-			logger$29.error(`[DeviceController] Failed to load persisted device for ${kind}:`, error);
+			logger$30.error(`[DeviceController] Failed to load persisted device for ${kind}:`, error);
 		}
 	}
 	/** Clears device history, persisted selections, and re-enumerates devices. */
@@ -1419,7 +1419,7 @@ var NavigatorDeviceController = class extends Destroyable {
 		this.disableDeviceMonitoring();
 		this.webRTCApiProvider.mediaDevices.addEventListener("devicechange", this.deviceChangeHandler);
 		if (PreferencesContainer.instance.devicePollingInterval > 0) this._devicesPoolingSubscription = interval(PreferencesContainer.instance.devicePollingInterval).subscribe(() => {
-			logger$29.debug("[DeviceController] Polling devices due to interval");
+			logger$30.debug("[DeviceController] Polling devices due to interval");
 			this.enumerateDevices();
 		});
 		this.enumerateDevices();
@@ -1445,13 +1445,13 @@ var NavigatorDeviceController = class extends Destroyable {
 				videoinput: []
 			});
 			this._devicesState$.next(devicesByKind);
-			logger$29.debug("[DeviceController] Devices enumerated:", {
+			logger$30.debug("[DeviceController] Devices enumerated:", {
 				audioInputs: devicesByKind.audioinput.length,
 				audioOutputs: devicesByKind.audiooutput.length,
 				videoInputs: devicesByKind.videoinput.length
 			});
 		} catch (error) {
-			logger$29.error("[DeviceController] Failed to enumerate devices:", error);
+			logger$30.error("[DeviceController] Failed to enumerate devices:", error);
 			this._errors$.next(toError(error));
 		}
 	}
@@ -1467,7 +1467,7 @@ var NavigatorDeviceController = class extends Destroyable {
 			stream.getTracks().forEach((t) => t.stop());
 			return capabilities;
 		} catch (error) {
-			logger$29.error("[DeviceController] Failed to get device capabilities:", error);
+			logger$30.error("[DeviceController] Failed to get device capabilities:", error);
 			this._errors$.next(toError(error));
 			throw error;
 		}
@@ -1718,7 +1718,7 @@ var DependencyContainer = class {
 
 //#endregion
 //#region src/controllers/CryptoController.ts
-const logger$28 = getLogger();
+const logger$29 = getLogger();
 const DPOP_DB_NAME = "sw-dpop";
 const DPOP_DB_VERSION = 1;
 const DPOP_STORE_NAME = "keys";
@@ -1777,7 +1777,7 @@ async function loadKeyPairFromDB() {
 			tx.oncomplete = () => db.close();
 		});
 	} catch (error) {
-		logger$28.warn("[DPoP] Failed to load key pair from IndexedDB:", error);
+		logger$29.warn("[DPoP] Failed to load key pair from IndexedDB:", error);
 		return null;
 	}
 }
@@ -1797,7 +1797,7 @@ async function saveKeyPairToDB(keyPair) {
 			};
 		});
 	} catch (error) {
-		logger$28.warn("[DPoP] Failed to save key pair to IndexedDB:", error);
+		logger$29.warn("[DPoP] Failed to save key pair to IndexedDB:", error);
 	}
 }
 async function deleteKeyPairFromDB() {
@@ -1816,7 +1816,7 @@ async function deleteKeyPairFromDB() {
 			};
 		});
 	} catch (error) {
-		logger$28.warn("[DPoP] Failed to delete key pair from IndexedDB:", error);
+		logger$29.warn("[DPoP] Failed to delete key pair from IndexedDB:", error);
 	}
 }
 /**
@@ -1876,13 +1876,13 @@ var CryptoController = class {
 			this._publicJwk = await crypto.subtle.exportKey("jwk", stored.publicKey);
 			this._fingerprint = await computeJwkThumbprint(this._publicJwk);
 			this._initialized = true;
-			logger$28.debug("[DPoP] Key pair restored from IndexedDB, fingerprint:", this._fingerprint);
+			logger$29.debug("[DPoP] Key pair restored from IndexedDB, fingerprint:", this._fingerprint);
 			return this._fingerprint;
 		} catch (error) {
-			logger$28.warn("[DPoP] Stored key pair unusable, generating new one:", error);
+			logger$29.warn("[DPoP] Stored key pair unusable, generating new one:", error);
 			await deleteKeyPairFromDB();
 		}
-		logger$28.debug("[DPoP] Generating RSA key pair");
+		logger$29.debug("[DPoP] Generating RSA key pair");
 		this._keyPair = await crypto.subtle.generateKey({
 			name: "RSASSA-PKCS1-v1_5",
 			modulusLength: 2048,
@@ -1897,7 +1897,7 @@ var CryptoController = class {
 		this._fingerprint = await computeJwkThumbprint(this._publicJwk);
 		this._initialized = true;
 		await saveKeyPairToDB(this._keyPair);
-		logger$28.debug("[DPoP] Key pair generated and persisted, fingerprint:", this._fingerprint);
+		logger$29.debug("[DPoP] Key pair generated and persisted, fingerprint:", this._fingerprint);
 		return this._fingerprint;
 	}
 	/**
@@ -1963,7 +1963,7 @@ var CryptoController = class {
 		this._fingerprint = null;
 		this._initialized = false;
 		deleteKeyPairFromDB();
-		logger$28.debug("[DPoP] Controller destroyed");
+		logger$29.debug("[DPoP] Controller destroyed");
 	}
 	get publicJwk() {
 		if (!this._publicJwk) throw new DPoPInitError("CryptoController not initialized. Call init() first.");
@@ -1986,7 +1986,7 @@ var CryptoController = class {
 
 //#endregion
 //#region src/controllers/NetworkMonitor.ts
-const logger$27 = getLogger();
+const logger$28 = getLogger();
 /**
 * Safely check whether we are running in a browser environment
 * with `window` and the relevant event targets.
@@ -2043,7 +2043,7 @@ var NetworkMonitor = class extends Destroyable {
 	}
 	attachListeners() {
 		if (!hasBrowserNetworkEvents()) {
-			logger$27.debug("NetworkMonitor: no browser environment detected, skipping event listeners");
+			logger$28.debug("NetworkMonitor: no browser environment detected, skipping event listeners");
 			return;
 		}
 		window.addEventListener("online", this._onOnline);
@@ -2051,7 +2051,7 @@ var NetworkMonitor = class extends Destroyable {
 		const connection = getNetworkConnection();
 		if (connection) connection.addEventListener("change", this._onConnectionChange);
 		this._listenersAttached = true;
-		logger$27.debug("NetworkMonitor: event listeners attached");
+		logger$28.debug("NetworkMonitor: event listeners attached");
 	}
 	removeListeners() {
 		if (!this._listenersAttached) return;
@@ -2062,10 +2062,10 @@ var NetworkMonitor = class extends Destroyable {
 			if (connection) connection.removeEventListener("change", this._onConnectionChange);
 		}
 		this._listenersAttached = false;
-		logger$27.debug("NetworkMonitor: event listeners removed");
+		logger$28.debug("NetworkMonitor: event listeners removed");
 	}
 	handleOnline() {
-		logger$27.info("NetworkMonitor: browser went online");
+		logger$28.info("NetworkMonitor: browser went online");
 		this._isOnline$.next(true);
 		this._networkChange$.next({
 			type: "online",
@@ -2074,7 +2074,7 @@ var NetworkMonitor = class extends Destroyable {
 		});
 	}
 	handleOffline() {
-		logger$27.info("NetworkMonitor: browser went offline");
+		logger$28.info("NetworkMonitor: browser went offline");
 		this._isOnline$.next(false);
 		this._networkChange$.next({
 			type: "offline",
@@ -2083,7 +2083,7 @@ var NetworkMonitor = class extends Destroyable {
 	}
 	handleConnectionChange() {
 		const networkType = getNetworkType();
-		logger$27.info(`NetworkMonitor: connection changed — effectiveType=${networkType ?? "unknown"}`);
+		logger$28.info(`NetworkMonitor: connection changed — effectiveType=${networkType ?? "unknown"}`);
 		this._networkChange$.next({
 			type: "connection_change",
 			timestamp: Date.now(),
@@ -2198,7 +2198,7 @@ function getNavigatorMediaDevices() {
 
 //#endregion
 //#region src/controllers/PreflightRunner.ts
-const logger$26 = getLogger();
+const logger$27 = getLogger();
 const DEFAULT_MEDIA_TEST_DURATION_S = 10;
 const ICE_GATHERING_TIMEOUT_MS = 1e4;
 const SIGNALING_RTT_TIMEOUT_MS = 5e3;
@@ -2247,7 +2247,7 @@ var PreflightRunner = class extends Destroyable {
 			if (!this._options.skipMediaTest) try {
 				bandwidth = await this.testMediaBandwidth(destination);
 			} catch (error) {
-				logger$26.warn("[PreflightRunner] Media bandwidth test failed:", error);
+				logger$27.warn("[PreflightRunner] Media bandwidth test failed:", error);
 				warnings.push("Media bandwidth test failed");
 			}
 			return {
@@ -2259,7 +2259,7 @@ var PreflightRunner = class extends Destroyable {
 				warnings
 			};
 		} catch (error) {
-			logger$26.error("[PreflightRunner] Preflight test failed:", error);
+			logger$27.error("[PreflightRunner] Preflight test failed:", error);
 			throw new PreflightError("preflight", error instanceof Error ? error : new Error(String(error)));
 		} finally {
 			this.destroy();
@@ -2290,7 +2290,7 @@ var PreflightRunner = class extends Destroyable {
 				if (track.kind === "video" && track.readyState === "live") videoWorking = true;
 			}
 		} catch (error) {
-			logger$26.warn("[PreflightRunner] Device test failed:", error);
+			logger$27.warn("[PreflightRunner] Device test failed:", error);
 		} finally {
 			if (audioStream) audioStream.getTracks().forEach((t) => t.stop());
 		}
@@ -2348,7 +2348,7 @@ var PreflightRunner = class extends Destroyable {
 				rttMs
 			};
 		} catch (error) {
-			logger$26.warn("[PreflightRunner] ICE connectivity test failed:", error);
+			logger$27.warn("[PreflightRunner] ICE connectivity test failed:", error);
 			return {
 				type: "failed",
 				turnReachable: false,
@@ -2395,7 +2395,7 @@ var PreflightRunner = class extends Destroyable {
 
 //#endregion
 //#region src/controllers/VisibilityController.ts
-const logger$25 = getLogger();
+const logger$26 = getLogger();
 /**
 * Checks whether the document visibility API is available.
 */
@@ -2432,8 +2432,8 @@ var VisibilityController = class extends Destroyable {
 		this._boundHandler = this._handleVisibilityChange.bind(this);
 		if (this._hasVisibilityApi) {
 			document.addEventListener("visibilitychange", this._boundHandler);
-			logger$25.debug("VisibilityController: listening for visibilitychange events");
-		} else logger$25.debug("VisibilityController: document visibility API not available, defaulting to visible");
+			logger$26.debug("VisibilityController: listening for visibilitychange events");
+		} else logger$26.debug("VisibilityController: document visibility API not available, defaulting to visible");
 	}
 	/**
 	* Observable of the current visibility state.
@@ -2458,7 +2458,7 @@ var VisibilityController = class extends Destroyable {
 	destroy() {
 		if (this._hasVisibilityApi) {
 			document.removeEventListener("visibilitychange", this._boundHandler);
-			logger$25.debug("VisibilityController: removed visibilitychange listener");
+			logger$26.debug("VisibilityController: removed visibilitychange listener");
 		}
 		super.destroy();
 	}
@@ -2476,7 +2476,7 @@ var VisibilityController = class extends Destroyable {
 			timestamp: Date.now()
 		};
 		this._visibilityChange$.next(changeEvent);
-		logger$25.debug("VisibilityController: visibility changed", {
+		logger$26.debug("VisibilityController: visibility changed", {
 			from: previousState,
 			to: newState
 		});
@@ -2677,15 +2677,57 @@ const RPCEventAckResponse = (id) => makeRPCResponse({
 	result: {}
 });
 
+//#endregion
+//#region src/utils/authRecovery.ts
+/**
+* Walk an error's `error`/`cause` chain looking for a {@link JSONRPCError}.
+* Errors thrown by call creation are wrapped (e.g. `CallCreateError`), so the
+* underlying signaling error is nested. Bounded by a visited set to guard
+* against cyclic causes.
+*/
+function findJSONRPCError(error) {
+	const seen = /* @__PURE__ */ new Set();
+	let current = error;
+	while (current instanceof Error && !seen.has(current)) {
+		seen.add(current);
+		if (current instanceof JSONRPCError) return current;
+		current = current.error ?? current.cause;
+	}
+}
+/**
+* Whether an error is a session-recoverable authentication failure
+* (`-32002` authentication failed or `-32003` requester validation failed)
+* that a credential re-mint + retry can heal.
+*/
+function isRecoverableAuthError(error) {
+	const rpcError = findJSONRPCError(error);
+	return rpcError !== void 0 && (rpcError.code === RPC_ERROR_REQUESTER_VALIDATION_FAILED || rpcError.code === RPC_ERROR_AUTHENTICATION_FAILED);
+}
+/**
+* Whether an error is specifically a requester-validation rejection
+* (`-32003`) — the server refusing the session's credential.
+*
+* Narrower than {@link isRecoverableAuthError} on purpose. `-32002` is
+* overloaded server-side: a rejected reattach arrives as `-32002` with
+* `cause: INVALID_MSG_UNSPECIFIED` and message `CALL ERROR`, which is a
+* call-level rejection and says nothing about the credential. Use this where
+* the decision must not be fooled by that, such as deciding whether retrying
+* an operation could possibly succeed.
+*/
+function isRequesterValidationError(error) {
+	return findJSONRPCError(error)?.code === RPC_ERROR_REQUESTER_VALIDATION_FAILED;
+}
+
 //#endregion
 //#region src/managers/AttachManager.ts
-const logger$24 = getLogger();
+const logger$25 = getLogger();
 var AttachManager = class {
-	constructor(storage, deviceController, reconnectCallsTimeout, attachKey) {
+	constructor(storage, deviceController, reconnectCallsTimeout, attachKey, credentialRecovered) {
 		this.storage = storage;
 		this.deviceController = deviceController;
 		this.reconnectCallsTimeout = reconnectCallsTimeout;
 		this.attachKey = attachKey;
+		this.credentialRecovered = credentialRecovered;
 		this.writeQueue = Promise.resolve();
 	}
 	async detachAll() {
@@ -2700,7 +2742,7 @@ var AttachManager = class {
 		try {
 			return await this.storage.getItem(this.attachKey) ?? {};
 		} catch (error) {
-			logger$24.warn("[AttachManager] Failed to retrieve attached calls from storage", error);
+			logger$25.warn("[AttachManager] Failed to retrieve attached calls from storage", error);
 			return {};
 		}
 	}
@@ -2708,7 +2750,7 @@ var AttachManager = class {
 		try {
 			await this.storage.setItem(this.attachKey, attached);
 		} catch (error) {
-			logger$24.warn("[AttachManager] Failed to write attached calls to storage", error);
+			logger$25.warn("[AttachManager] Failed to write attached calls to storage", error);
 		}
 	}
 	/**
@@ -2727,11 +2769,39 @@ var AttachManager = class {
 	}
 	async attach(call) {
 		if (!call.to) {
-			logger$24.warn("[AttachManager] Skip attach for calls with no destination");
+			logger$25.warn("[AttachManager] Skip attach for calls with no destination");
 			return;
 		}
+		const attachment = this.buildAttachment(call, call.to);
+		await this.mutate((attached) => ({
+			...attached,
+			[call.id]: attachment
+		}));
+	}
+	/**
+	* Keep an already-stored call's reference alive and current — the periodic
+	* refresh the `verto.ping` keepalive drives.
+	*
+	* Only ever updates: a call with no record is one nothing wants reattached,
+	* and re-creating it here would undo a `detach`. That matters because a ping
+	* can land in the window between `bye()` detaching and the call being torn
+	* down, and a record revived there survives the hangup — so the next page
+	* load dials a call nobody is on. The existence check and the write share
+	* one {@link mutate} turn, so a concurrent detach cannot slip between them.
+	*/
+	async refresh(call) {
+		if (!call.to) return;
 		const destination = call.to;
-		const attachment = {
+		await this.mutate((attached) => {
+			if (!Object.hasOwn(attached, call.id)) return attached;
+			return {
+				...attached,
+				[call.id]: this.buildAttachment(call, destination)
+			};
+		});
+	}
+	buildAttachment(call, destination) {
+		return {
 			nodeId: call.nodeId,
 			destination,
 			mediaDirections: call.mediaDirections,
@@ -2739,10 +2809,6 @@ var AttachManager = class {
 			videoInputDevice: call.mediaDirections.video !== "inactive" ? this.deviceController.selectedVideoInputDevice : null,
 			attachedAt: Date.now()
 		};
-		await this.mutate((attached) => ({
-			...attached,
-			[call.id]: attachment
-		}));
 	}
 	async detach(call) {
 		await this.mutate((attached) => {
@@ -2765,8 +2831,14 @@ var AttachManager = class {
 	* rejecting. Once that fix is deployed, this will work for both
 	* page reloads and WebSocket reconnects.
 	*
-	* Failed reattach attempts are handled gracefully — the stale call
-	* reference is cleaned up from storage.
+	* A failed reattach does NOT generally cost the stored reference. It is
+	* discarded only when the server denied the reattach on a session whose
+	* credential it had already accepted — a verified reauthentication followed
+	* by a refusal is the server saying the call is gone, and that is the one
+	* refusal worth acting on. Until then the credential may be what is being
+	* refused, and the record is the only way a later reload can try again;
+	* keeping it costs nothing, since `detachExpired` reaps it once it is older
+	* than `reconnectCallsTimeout`.
 	*/
 	async reattachCalls() {
 		const attached = await this.readAttached();
@@ -2775,25 +2847,31 @@ var AttachManager = class {
 			const { destination } = attachment;
 			const options = this.buildCallOptions(attachment);
 			let succeeded = false;
+			let refusedOnCredentials = false;
 			for (let attempt = 1; attempt <= 3; attempt++) try {
 				await this.session.createOutboundCall(destination, {
 					callId,
 					...options
 				});
-				logger$24.info(`[AttachManager] Reattached call ${callId} (attempt ${attempt})`);
+				logger$25.info(`[AttachManager] Reattached call ${callId} (attempt ${attempt})`);
 				succeeded = true;
 				break;
 			} catch (error) {
-				logger$24.warn(`[AttachManager] Reattach attempt ${attempt}/3 failed for call ${callId}:`, error);
+				logger$25.warn(`[AttachManager] Reattach attempt ${attempt}/3 failed for call ${callId}:`, error);
+				if (isRequesterValidationError(error)) {
+					refusedOnCredentials = true;
+					logger$25.warn(`[AttachManager] Reattach of ${callId} was refused on credentials; not retrying.`);
+					break;
+				}
 				if (attempt < 3) await new Promise((r) => setTimeout(r, (attempt + 1) * 1e3));
 			}
-			if (!succeeded) {
-				logger$24.warn(`[AttachManager] Reattach failed after 3 attempts for call ${callId}, removing reference`);
+			if (!succeeded) if (this.credentialRecovered() && !refusedOnCredentials) {
+				logger$25.warn(`[AttachManager] Reattach of ${callId} was denied after a verified reauthentication, removing reference`);
 				await this.detach({
 					id: callId,
 					mediaDirections: attachment.mediaDirections
 				});
-			}
+			} else logger$25.warn(`[AttachManager] Reattach failed for call ${callId}; keeping the reference (credential refused or never proven good)`);
 		}
 	}
 	/**
@@ -3106,7 +3184,7 @@ function toggleHandraiseMethod(is) {
 
 //#endregion
 //#region src/core/entities/Participant.ts
-const logger$23 = getLogger();
+const logger$24 = getLogger();
 const initialState = {};
 /**
 * Represents a participant in a call.
@@ -3116,9 +3194,9 @@ const initialState = {};
 * the local participant with additional device control.
 */
 var Participant = class extends Destroyable {
-	constructor(id, executeMethod, deviceController) {
+	constructor(id, callExecuteMethod, deviceController) {
 		super();
-		this.executeMethod = executeMethod;
+		this.callExecuteMethod = callExecuteMethod;
 		this.deviceController = deviceController;
 		this._state$ = this.createBehaviorSubject(initialState);
 		this.id = id;
@@ -3340,22 +3418,55 @@ var Participant = class extends Destroyable {
 	get value() {
 		return this._state$.value;
 	}
+	/**
+	* Target triple for member RPCs, built from the participant's own state.
+	* The backend locates the member's session by the target `call_id`/`node_id`,
+	* so this must always be the participant's own call context — never the
+	* local call's id (issue #19400).
+	*
+	* Reading it doubles as a readiness probe: it throws until the first full
+	* member event (`member.joined`/`member.updated` or the `call.joined`
+	* roster) arrives, and never regresses afterwards.
+	*
+	* @throws {ParticipantNotReadyError} If the member state has not been
+	* received yet (e.g. a participant first seen via `member.talking`) — an
+	* empty call context can never address the member, so fail fast instead of
+	* sending a doomed RPC.
+	*/
+	get target() {
+		const { call_id, node_id } = this._state$.value;
+		if (!call_id || !node_id) throw new ParticipantNotReadyError(this.id);
+		return {
+			member_id: this.id,
+			call_id,
+			node_id
+		};
+	}
+	/**
+	* Executes a member RPC against this participant, injecting its own
+	* {@link target} as the target.
+	*
+	* @throws {ParticipantNotReadyError} Via {@link target}, when the
+	* member state has not been received yet.
+	*/
+	async executeMethod(method, args) {
+		return this.callExecuteMethod(this.target, method, args);
+	}
 	/** Toggles the deafened state (mutes/unmutes incoming audio). */
 	async toggleDeaf() {
-		const method = toggleDeafMethod(this.deaf);
-		await this.executeMethod(this.id, method, {});
+		await this.executeMethod(toggleDeafMethod(this.deaf), {});
 	}
 	/** Toggles the hand-raised state. */
 	async toggleHandraise() {
-		await this.executeMethod(this.id, toggleHandraiseMethod(this.handraised), {});
+		await this.executeMethod(toggleHandraiseMethod(this.handraised), {});
 	}
 	/** Mutes the participant's audio. */
 	async mute() {
-		await this.executeMethod(this.id, "call.mute", { channels: ["audio"] });
+		await this.executeMethod("call.mute", { channels: ["audio"] });
 	}
 	/** Unmutes the participant's audio. */
 	async unmute() {
-		await this.executeMethod(this.id, "call.unmute", { channels: ["audio"] });
+		await this.executeMethod("call.unmute", { channels: ["audio"] });
 	}
 	/** Toggles the participant's audio mute state. */
 	async toggleMute() {
@@ -3363,11 +3474,11 @@ var Participant = class extends Destroyable {
 	}
 	/** Mutes the participant's video. */
 	async muteVideo() {
-		await this.executeMethod(this.id, "call.mute", { channels: ["video"] });
+		await this.executeMethod("call.mute", { channels: ["video"] });
 	}
 	/** Unmutes the participant's video. */
 	async unmuteVideo() {
-		await this.executeMethod(this.id, "call.unmute", { channels: ["video"] });
+		await this.executeMethod("call.unmute", { channels: ["video"] });
 	}
 	/** Toggles the participant's video mute state. */
 	async toggleMuteVideo() {
@@ -3375,7 +3486,7 @@ var Participant = class extends Destroyable {
 	}
 	/** Toggles echo cancellation on the audio input. */
 	async toggleEchoCancellation() {
-		await this.executeMethod(this.id, "call.audioflags.set", {
+		await this.executeMethod("call.audioflags.set", {
 			echo_cancellation: !this.echoCancellation,
 			auto_gain: this.autoGain,
 			noise_suppression: this.noiseSuppression
@@ -3383,7 +3494,7 @@ var Participant = class extends Destroyable {
 	}
 	/** Toggles automatic gain control on the audio input. */
 	async toggleAudioInputAutoGain() {
-		await this.executeMethod(this.id, "call.audioflags.set", {
+		await this.executeMethod("call.audioflags.set", {
 			echo_cancellation: this.echoCancellation,
 			auto_gain: !this.autoGain,
 			noise_suppression: this.noiseSuppression
@@ -3391,7 +3502,7 @@ var Participant = class extends Destroyable {
 	}
 	/** Toggles noise suppression on the audio input. */
 	async toggleNoiseSuppression() {
-		await this.executeMethod(this.id, "call.audioflags.set", {
+		await this.executeMethod("call.audioflags.set", {
 			echo_cancellation: this.echoCancellation,
 			auto_gain: this.autoGain,
 			noise_suppression: !this.noiseSuppression
@@ -3399,7 +3510,7 @@ var Participant = class extends Destroyable {
 	}
 	/** Toggles low-bitrate mode for this participant's media. */
 	async toggleLowbitrate() {
-		await this.executeMethod(this.id, "call.lowbitrate.set", { lowbitrate: !this.lowbitrate });
+		await this.executeMethod("call.lowbitrate.set", { lowbitrate: !this.lowbitrate });
 	}
 	/**
 	* Adjusts the **conference-only** microphone energy gate / sensitivity level
@@ -3415,7 +3526,7 @@ var Participant = class extends Destroyable {
 	*   (integer, larger values are more sensitive).
 	*/
 	async setAudioInputSensitivity(value) {
-		await this.executeMethod(this.id, "call.microphone.sensitivity.set", { sensitivity: value });
+		await this.executeMethod("call.microphone.sensitivity.set", { sensitivity: value });
 	}
 	/**
 	* Sets the **server-side** microphone volume on this participant's bridged
@@ -3428,7 +3539,7 @@ var Participant = class extends Destroyable {
 	* @param value - Volume level (0-100).
 	*/
 	async setAudioInputVolume(value) {
-		await this.executeMethod(this.id, "call.microphone.volume.set", { volume: value });
+		await this.executeMethod("call.microphone.volume.set", { volume: value });
 	}
 	/**
 	* Sets the **server-side** speaker volume on this participant's bridged call
@@ -3442,45 +3553,31 @@ var Participant = class extends Destroyable {
 	* @param value - Volume level (0-100).
 	*/
 	async setAudioOutputVolume(value) {
-		await this.executeMethod(this.id, "call.speaker.volume.set", { volume: value });
+		await this.executeMethod("call.speaker.volume.set", { volume: value });
 	}
 	/**
 	* Sets the participant's position in the video layout.
 	*
-	* Requires the `member.position` capability. The gateway keys positions by the
-	* **target member's own** `call_id`/`node_id` (see issue #19400 and the legacy
-	* `setPositions` implementation), so this sends the participant's own call
-	* context — matching {@link Participant.remove}. A resolved promise does not
-	* guarantee a visible change: the backend silently returns `200` (no-op) for
-	* non-conference targets.
+	* Requires the `member.position` capability. The gateway requires a
+	* `targets` array of `{ target, position }` entries (issue #19400). A
+	* resolved promise does not guarantee a visible change: the backend silently
+	* returns `200` (no-op) for non-conference targets.
 	*
 	* @param value - The {@link VideoPosition} to assign (e.g. `'auto'`, `'reserved-0'`).
 	*/
 	async setPosition(value) {
-		const state = this._state$.value;
-		const target = {
-			member_id: this.id,
-			call_id: state.call_id ?? "",
-			node_id: state.node_id ?? ""
-		};
-		await this.executeMethod(target, "call.member.position.set", { targets: [{
-			target,
+		await this.executeMethod("call.member.position.set", { targets: [{
+			target: this.target,
 			position: value
 		}] });
 	}
 	/** Removes this participant from the call. */
 	async remove() {
-		const state = this._state$.value;
-		const target = {
-			member_id: this.id,
-			call_id: state.call_id ?? "",
-			node_id: state.node_id ?? ""
-		};
-		await this.executeMethod(target, "call.member.remove", {});
+		await this.executeMethod("call.member.remove", { targets: [this.target] });
 	}
 	/** Ends the call for this participant. */
 	async end() {
-		await this.executeMethod(this.id, "call.end", {});
+		await this.executeMethod("call.end", {});
 	}
 	/**
 	* Replaces custom metadata for this participant.
@@ -3500,7 +3597,7 @@ var Participant = class extends Destroyable {
 	}
 	/** Destroys the participant, releasing all subscriptions and references. */
 	destroy() {
-		this.executeMethod = void 0;
+		this.callExecuteMethod = void 0;
 		super.destroy();
 	}
 };
@@ -3512,8 +3609,8 @@ var Participant = class extends Destroyable {
 */
 var SelfParticipant = class extends Participant {
 	/** @internal */
-	constructor(id, executeMethod, vertoManager, deviceController) {
-		super(id, executeMethod, deviceController);
+	constructor(id, callExecuteMethod, vertoManager, deviceController) {
+		super(id, callExecuteMethod, deviceController);
 		this.vertoManager = vertoManager;
 		this._studioAudio$ = this.createBehaviorSubject(false);
 		this.capabilities = new SelfCapabilities();
@@ -3537,7 +3634,7 @@ var SelfParticipant = class extends Participant {
 	async enableStudioAudio() {
 		if (this._studioAudio$.value) return;
 		this._studioAudio$.next(true);
-		await this.executeMethod(this.id, "call.audioflags.set", {
+		await this.executeMethod("call.audioflags.set", {
 			echo_cancellation: false,
 			auto_gain: false,
 			noise_suppression: false
@@ -3550,7 +3647,7 @@ var SelfParticipant = class extends Participant {
 	async disableStudioAudio() {
 		if (!this._studioAudio$.value) return;
 		this._studioAudio$.next(false);
-		await this.executeMethod(this.id, "call.audioflags.set", {
+		await this.executeMethod("call.audioflags.set", {
 			echo_cancellation: true,
 			auto_gain: true,
 			noise_suppression: true
@@ -3559,17 +3656,27 @@ var SelfParticipant = class extends Participant {
 	/**
 	* Starts sharing the local screen.
 	*
+	* A call carries at most one screen share. Read `screenShareStatus` before
+	* calling and treat `'starting'`/`'stopping'` as busy.
+	*
 	* The call is unaffected when acquisition fails.
 	*
+	* @param options - Pass `{ audio: true }` to also request the shared
+	* surface's audio. Defaults to video only.
+	* @throws {ScreenShareAlreadyActiveError} When this call is already
+	* sharing a screen. Call {@link stopScreenShare} before starting another.
+	* @throws {AuxiliaryLegCancelledError} When {@link stopScreenShare} removes
+	* the share before its leg finishes connecting.
 	* @throws The raw `getDisplayMedia` error. A dismissed picker or a
 	* permission denial rejects with a `NotAllowedError` `DOMException` —
 	* inspect `error.name` to tell benign cancels apart from real failures.
 	*/
-	async startScreenShare() {
+	async startScreenShare(options) {
 		try {
-			await this.vertoManager.addScreenMedia();
+			await this.vertoManager.addScreenMedia(options);
 		} catch (error) {
-			logger$23.error("[Participant.startScreenShare] Screen share error:", error);
+			if (error instanceof AuxiliaryLegCancelledError) logger$24.debug("[Participant.startScreenShare] Screen share cancelled before connecting.");
+			else logger$24.error("[Participant.startScreenShare] Screen share error:", error);
 			throw error;
 		}
 	}
@@ -3590,14 +3697,18 @@ var SelfParticipant = class extends Participant {
 	*
 	* The call is unaffected when acquisition fails.
 	*
+	* @throws {AuxiliaryLegCancelledError} When {@link removeAdditionalDevice}
+	* removes the device before its leg finishes connecting.
 	* @throws The raw `getUserMedia` error (e.g. `NotAllowedError` on
-	* permission denial) — inspect `error.name` to decide how to react.
+	* permission denial) — inspect `error.name` to decide how to react — or
+	* `AuxiliaryLegTimeoutError` if the leg does not connect in time.
 	*/
 	async addAdditionalDevice(options) {
 		try {
 			await this.vertoManager.addInputDevice(options);
 		} catch (error) {
-			logger$23.error("[Participant.addAdditionalDevice] Additional device error:", error);
+			if (error instanceof AuxiliaryLegCancelledError) logger$24.debug("[Participant.addAdditionalDevice] Device removed before connecting.");
+			else logger$24.error("[Participant.addAdditionalDevice] Additional device error:", error);
 			throw error;
 		}
 	}
@@ -3632,22 +3743,31 @@ var SelfParticipant = class extends Participant {
 		this.deviceController.selectAudioInputDevice(device);
 		if (options.savePreference) PreferencesContainer.instance.preferredAudioInput = device;
 	}
-	/** Updates the audio input track constraints for the active call. */
+	/**
+	* Updates the audio input track constraints for the active call.
+	* @returns whether the constraints reached the media the call is sending.
+	*/
 	async setAudioInputDeviceConstraints(constraints) {
-		await this.vertoManager.updateMediaConstraints({ audio: constraints });
+		return this.vertoManager.updateMediaConstraints({ audio: constraints });
 	}
-	/** Updates both audio and video input track constraints for the active call. */
+	/**
+	* Updates both audio and video input track constraints for the active call.
+	* @returns whether both kinds took the constraints.
+	*/
 	async setInputDevicesConstraints(constraints) {
-		await this.vertoManager.updateMediaConstraints(constraints);
+		return this.vertoManager.updateMediaConstraints(constraints);
 	}
 	/** Selects the video input device for future calls. Optionally saves as a preference. */
 	selectVideoInputDevice(device, options = {}) {
 		this.deviceController.selectVideoInputDevice(device);
 		if (options.savePreference) PreferencesContainer.instance.preferredVideoInput = device;
 	}
-	/** Updates the video input track constraints for the active call. */
+	/**
+	* Updates the video input track constraints for the active call.
+	* @returns whether the constraints reached the media the call is sending.
+	*/
 	async setVideoInputDeviceConstraints(constraints) {
-		await this.vertoManager.updateMediaConstraints({ video: constraints });
+		return this.vertoManager.updateMediaConstraints({ video: constraints });
 	}
 	/** Selects the audio output device. Optionally saves as a preference. */
 	selectAudioOutputDevice(device, options = {}) {
@@ -3660,7 +3780,7 @@ var SelfParticipant = class extends Participant {
 	*/
 	exitStudioModeIfActive() {
 		if (this._studioAudio$.value) {
-			logger$23.debug("[SelfParticipant] Exiting studio audio mode due to individual flag toggle");
+			logger$24.debug("[SelfParticipant] Exiting studio audio mode due to individual flag toggle");
 			this._studioAudio$.next(false);
 		}
 	}
@@ -3684,7 +3804,7 @@ var SelfParticipant = class extends Participant {
 		try {
 			await super.mute();
 		} catch (error) {
-			logger$23.warn("[Participant.toggleAudioInput] Server Error while muting audio input, proceeding with local toggle anyway", error);
+			logger$24.warn("[Participant.toggleAudioInput] Server Error while muting audio input, proceeding with local toggle anyway", error);
 		} finally {
 			this.vertoManager.muteMainAudioInputDevice();
 		}
@@ -3694,7 +3814,7 @@ var SelfParticipant = class extends Participant {
 		try {
 			await super.unmute();
 		} catch (error) {
-			logger$23.warn("[Participant.toggleAudioInput] Server Error while unmuting audio input, proceeding with local toggle anyway", error);
+			logger$24.warn("[Participant.toggleAudioInput] Server Error while unmuting audio input, proceeding with local toggle anyway", error);
 		} finally {
 			await this.vertoManager.unmuteMainAudioInputDevice();
 		}
@@ -3704,7 +3824,7 @@ var SelfParticipant = class extends Participant {
 		try {
 			await super.muteVideo();
 		} catch (error) {
-			logger$23.warn("[Participant.toggleVideoInput] Server Error while muting video input, proceeding with local toggle anyway", error);
+			logger$24.warn("[Participant.toggleVideoInput] Server Error while muting video input, proceeding with local toggle anyway", error);
 		} finally {
 			this.vertoManager.muteMainVideoInputDevice();
 		}
@@ -3714,7 +3834,7 @@ var SelfParticipant = class extends Participant {
 		try {
 			await super.unmuteVideo();
 		} catch (error) {
-			logger$23.warn("[Participant.toggleVideoInput] Server Error while unmuting video input, proceeding with local toggle anyway", error);
+			logger$24.warn("[Participant.toggleVideoInput] Server Error while unmuting video input, proceeding with local toggle anyway", error);
 		} finally {
 			await this.vertoManager.unmuteMainVideoInputDevice();
 		}
@@ -3808,7 +3928,7 @@ function isLayoutChangedPayload(value) {
 
 //#endregion
 //#region src/managers/CallEventsManager.ts
-const logger$22 = getLogger();
+const logger$23 = getLogger();
 const initialSessionState = {};
 /** @internal */
 var CallEventsManager = class extends Destroyable {
@@ -3912,7 +4032,7 @@ var CallEventsManager = class extends Destroyable {
 	}
 	initSubscriptions() {
 		this.subscribeTo(this.callJoinedEvent$, (callJoinedEvent) => {
-			logger$22.debug("[CallEventsManager] Handling call.joined event for call/session IDs:", {
+			logger$23.debug("[CallEventsManager] Handling call.joined event for call/session IDs:", {
 				callId: callJoinedEvent.call_id,
 				roomSessionId: callJoinedEvent.room_session_id
 			});
@@ -3939,19 +4059,19 @@ var CallEventsManager = class extends Destroyable {
 			if (this._self$.value?.capabilities.setLayout) this.updateLayouts();
 		});
 		this.subscribeTo(this.memberUpdates$, (member) => {
-			logger$22.debug("[CallEventsManager] Handling member update event for member ID:", member);
+			logger$23.debug("[CallEventsManager] Handling member update event for member ID:", member);
 			this.upsertParticipant(member);
 		});
 		this.subscribeTo(this.webRtcCallSession.memberLeft$, (memberLeftEvent) => {
-			logger$22.debug("[CallEventsManager] Handling member.left event for member ID:", memberLeftEvent.member.member_id);
+			logger$23.debug("[CallEventsManager] Handling member.left event for member ID:", memberLeftEvent.member.member_id);
 			const participants = { ...this._participants$.value };
 			if (memberLeftEvent.member.member_id in participants) {
 				delete participants[memberLeftEvent.member.member_id];
 				this._participants$.next(participants);
-			} else logger$22.warn(`[CallEventsManager] Received member.left event for unknown member ID: ${memberLeftEvent.member.member_id}`);
+			} else logger$23.warn(`[CallEventsManager] Received member.left event for unknown member ID: ${memberLeftEvent.member.member_id}`);
 		});
 		this.subscribeTo(this.webRtcCallSession.callUpdated$, (callUpdatedEvent) => {
-			logger$22.debug("[CallEventsManager] Handling call.updated event:", callUpdatedEvent);
+			logger$23.debug("[CallEventsManager] Handling call.updated event:", callUpdatedEvent);
 			const roomSession = callUpdatedEvent.room_session;
 			this._sessionState$.next({
 				...this._sessionState$.value,
@@ -3966,7 +4086,7 @@ var CallEventsManager = class extends Destroyable {
 			});
 		});
 		this.subscribeTo(this.layoutChangedEvent$, (layoutChangedEvent) => {
-			logger$22.debug("[CallEventsManager] Handling layout.changed event:", layoutChangedEvent);
+			logger$23.debug("[CallEventsManager] Handling layout.changed event:", layoutChangedEvent);
 			this._sessionState$.next({
 				...this._sessionState$.value,
 				layout_name: layoutChangedEvent.id,
@@ -3976,10 +4096,10 @@ var CallEventsManager = class extends Destroyable {
 		});
 	}
 	updateParticipantPositions(layoutChangedEvent) {
-		if (Object.keys(this._participants$.value).length > 0 && !layoutChangedEvent.layers.some((layer) => !!layer.member_id)) logger$22.warn("[CallEventsManager] No layers with member_id found in layout.changed event. Nothing to update.");
+		if (Object.keys(this._participants$.value).length > 0 && !layoutChangedEvent.layers.some((layer) => !!layer.member_id)) logger$23.warn("[CallEventsManager] No layers with member_id found in layout.changed event. Nothing to update.");
 		layoutChangedEvent.layers.filter((layer) => !!layer.member_id).filter((layer) => {
 			if (!(layer.member_id in this._participants$.value)) {
-				logger$22.warn(`[CallEventsManager] Skipping layout layer for unknown member_id: ${layer.member_id}`);
+				logger$23.warn(`[CallEventsManager] Skipping layout layer for unknown member_id: ${layer.member_id}`);
 				return false;
 			}
 			return true;
@@ -3997,12 +4117,17 @@ var CallEventsManager = class extends Destroyable {
 	updateLayouts() {
 		if (!this.selfId) return;
 		this.webRtcCallSession.executeMethod(this.selfId, "call.layout.list", {}).then((response) => {
+			const layouts = response.result?.layouts;
+			if (!layouts) {
+				logger$23.warn("[CallEventsManager] Layout list response carried no layouts; keeping current layouts");
+				return;
+			}
 			this._sessionState$.next({
 				...this._sessionState$.value,
-				layouts: response.result.layouts
+				layouts
 			});
 		}).catch((error) => {
-			logger$22.error("[CallEventsManager] Error fetching layouts:", error);
+			logger$23.error("[CallEventsManager] Error fetching layouts:", error);
 		});
 	}
 	updateParticipants(members) {
@@ -4018,7 +4143,7 @@ var CallEventsManager = class extends Destroyable {
 		}
 		const participant = this._participants$.value[member.member_id];
 		const oldValue = participant.value;
-		logger$22.debug("[CallEventsManager] Updating participant:", member.member_id, {
+		logger$23.debug("[CallEventsManager] Updating participant:", member.member_id, {
 			oldValue,
 			newValue: member
 		});
@@ -4031,17 +4156,17 @@ var CallEventsManager = class extends Destroyable {
 	}
 	get callJoinedEvent$() {
 		return this.cachedObservable("callJoinedEvent$", () => this.webRtcCallSession.callEvent$.pipe(filter(isCallJoinedPayload), tap((event) => {
-			logger$22.debug("[CallEventsManager] Call joined event:", event);
+			logger$23.debug("[CallEventsManager] Call joined event:", event);
 		})));
 	}
 	get layoutChangedEvent$() {
 		return this.cachedObservable("layoutChangedEvent$", () => this.webRtcCallSession.callEvent$.pipe(filterAs(isLayoutChangedPayload, "layout"), tap((event) => {
-			logger$22.debug("[CallEventsManager] Layout changed event:", event);
+			logger$23.debug("[CallEventsManager] Layout changed event:", event);
 		})));
 	}
 	get memberUpdates$() {
 		return this.cachedObservable("memberUpdates$", () => merge(this.webRtcCallSession.memberJoined$, this.webRtcCallSession.memberUpdated$, this.webRtcCallSession.memberTalking$).pipe(map((event) => event.member), tap((event) => {
-			logger$22.debug("[CallEventsManager] Member update event:", event);
+			logger$23.debug("[CallEventsManager] Member update event:", event);
 		})));
 	}
 	destroy() {
@@ -4060,6 +4185,111 @@ var CallEventsManager = class extends Destroyable {
 	}
 };
 
+//#endregion
+//#region src/controllers/ConstraintFallbackHelper.ts
+/**
+* ConstraintFallbackHelper - Provides getUserMedia with automatic constraint
+* fallback on OverconstrainedError.
+*
+* When a specific device ID is requested, the helper tries progressively
+* looser constraints:
+*   1. `{ deviceId: { exact: deviceId } }` -- exact match
+*   2. `{ deviceId: deviceId }` -- preferred (browser may pick another)
+*   3. `{}` -- no constraint, browser default
+*
+* This prevents stale device IDs from blocking call setup.
+*
+* @see Section 5.8 and Section 11 of the Implementation Guide
+*/
+const logger$22 = getLogger();
+/**
+* Attempts getUserMedia with progressively looser constraints.
+*
+* The function tries three levels of constraint specificity for the given
+* device kind. Each level is only attempted if the previous one fails with
+* an OverconstrainedError. Non-OverconstrainedError failures (e.g.,
+* NotAllowedError) are thrown immediately without fallback.
+*
+* @param mediaDevices - Anything exposing `getUserMedia` (a full
+*   `WebRTCMediaDevices`, or a shim wrapping one)
+* @param constraints - The full MediaStreamConstraints to use as a base
+* @param kind - Which track kind to apply fallback to ('audio' | 'video')
+* @param deviceId - The device ID to try (if undefined, calls getUserMedia as-is)
+* @returns The stream and the fallback level that succeeded
+* @throws When all fallback levels fail, or when a non-OverconstrainedError occurs
+*/
+async function getUserMediaWithFallback(mediaDevices, constraints, kind, deviceId) {
+	if (!deviceId) return {
+		stream: await mediaDevices.getUserMedia(constraints),
+		fallbackLevel: "default"
+	};
+	const baseConstraints = typeof constraints[kind] === "object" ? constraints[kind] : {};
+	try {
+		const exactConstraints = {
+			...constraints,
+			[kind]: {
+				...baseConstraints,
+				deviceId: { exact: deviceId }
+			}
+		};
+		return {
+			stream: await mediaDevices.getUserMedia(exactConstraints),
+			fallbackLevel: "exact"
+		};
+	} catch (error) {
+		if (!isOverconstrainedError(error)) throw error;
+		logger$22.debug(`[ConstraintFallbackHelper] Exact constraint failed for ${kind}, trying preferred`, { deviceId });
+	}
+	try {
+		const preferredConstraints = {
+			...constraints,
+			[kind]: {
+				...baseConstraints,
+				deviceId
+			}
+		};
+		return {
+			stream: await mediaDevices.getUserMedia(preferredConstraints),
+			fallbackLevel: "preferred"
+		};
+	} catch (error) {
+		if (!isOverconstrainedError(error)) throw error;
+		logger$22.debug(`[ConstraintFallbackHelper] Preferred constraint failed for ${kind}, trying default`, { deviceId });
+	}
+	try {
+		const defaultConstraints = {
+			...constraints,
+			[kind]: { ...baseConstraints }
+		};
+		if (typeof defaultConstraints[kind] === "object") {
+			const { deviceId: _removed, ...rest } = defaultConstraints[kind];
+			defaultConstraints[kind] = rest;
+		}
+		const stream = await mediaDevices.getUserMedia(defaultConstraints);
+		logger$22.warn(`[ConstraintFallbackHelper] Fell back to browser default for ${kind}`, { requestedDeviceId: deviceId });
+		return {
+			stream,
+			fallbackLevel: "default"
+		};
+	} catch (error) {
+		logger$22.error(`[ConstraintFallbackHelper] All fallback levels exhausted for ${kind}`, {
+			deviceId,
+			error
+		});
+		throw error;
+	}
+}
+/**
+* Checks whether an error is an OverconstrainedError.
+*
+* Browsers may throw either a native OverconstrainedError or a DOMException
+* with a specific name.
+*/
+function isOverconstrainedError(error) {
+	if (error instanceof Error) return error.name === "OverconstrainedError" || error.name === "ConstraintNotSatisfiedError";
+	return false;
+}
+
 //#endregion
 //#region src/helpers/SDPHelper.ts
 /**
@@ -4615,6 +4845,7 @@ var LocalStreamController = class extends Destroyable {
 		this._localAudioTracks$ = this.createBehaviorSubject([]);
 		this._localVideoTracks$ = this.createBehaviorSubject([]);
 		this._mediaTrackEnded$ = this.createSubject();
+		this._trackOrigins = /* @__PURE__ */ new WeakMap();
 	}
 	get localStream$() {
 		return this._localStream$.asObservable().pipe(takeUntil(this.destroyed$));
@@ -4637,6 +4868,22 @@ var LocalStreamController = class extends Destroyable {
 	get localVideoTracks() {
 		return this._localVideoTracks$.value;
 	}
+	tagTracks(tracks, origin) {
+		for (const track of tracks) this._trackOrigins.set(track, origin);
+	}
+	setTrackOrigin(track, origin) {
+		this._trackOrigins.set(track, origin);
+	}
+	getTrackOrigin(track) {
+		return this._trackOrigins.get(track);
+	}
+	/**
+	* Fail-safe: an unrecorded track reads as not-a-device-capture, so a missed
+	* tagging site leaves media alone rather than destroying it.
+	*/
+	isDeviceCapture(track) {
+		return this._trackOrigins.get(track) === "device";
+	}
 	/**
 	* Build the local media stream based on the provided options.
 	*/
@@ -4646,13 +4893,16 @@ var LocalStreamController = class extends Destroyable {
 		if (this.options.inputAudioStream ?? this.options.inputVideoStream) {
 			const tracks = [...this.options.inputAudioStream?.getTracks() ?? [], ...this.options.inputVideoStream?.getTracks() ?? []];
 			stream = new MediaStream(tracks);
+			this.tagTracks(tracks, "application");
 		} else if (this.options.propose === "screenshare") {
-			logger$19.debug("[LocalStreamController] Requesting display media for screen sharing with audio:", Boolean(this.options.inputAudioDeviceConstraints));
+			const audio = this.options.screenShareAudio ?? false;
+			logger$19.debug("[LocalStreamController] Requesting display media for screen sharing with audio:", audio);
 			stream = await this.options.getDisplayMedia({
 				video: true,
-				audio: Boolean(this.options.inputAudioDeviceConstraints)
+				audio
 			});
 			logger$19.debug("[LocalStreamController] Screen share media obtained:", stream);
+			this.tagTracks(stream.getTracks(), "display");
 		} else {
 			const constraints = {
 				audio: this.options.inputAudioDeviceConstraints,
@@ -4661,6 +4911,7 @@ var LocalStreamController = class extends Destroyable {
 			logger$19.debug("[LocalStreamController] Requesting user media with constraints:", constraints);
 			stream = await this.options.getUserMedia(constraints);
 			logger$19.debug("[LocalStreamController] User media obtained:", stream);
+			this.tagTracks(stream.getTracks(), "device");
 		}
 		this._localStream$.next(stream);
 		this._localAudioTracks$.next(stream.getAudioTracks());
@@ -4670,10 +4921,13 @@ var LocalStreamController = class extends Destroyable {
 	/**
 	* Add a local media track to the local stream.
 	* @param track - The MediaStreamTrack to add
+	* @param origin - Defaults to `'device'`; every internal caller passes a
+	* fresh `getUserMedia` capture.
 	* @returns The MediaStream (either existing or newly created)
 	*/
-	addTrack(track) {
+	addTrack(track, origin = "device") {
 		const localStream = this._localStream$.value ?? new MediaStream();
+		this._trackOrigins.set(track, origin);
 		track.addEventListener("ended", this.mediaTrackEndedHandler);
 		localStream.addTrack(track);
 		this._localStream$.next(localStream);
@@ -4943,15 +5197,27 @@ var TransceiverController = class extends Destroyable {
 			for (let i = 0; i < Number(msStreamsNumber); i++) this.peerConnection.addTransceiver("video", { direction: "recvonly" });
 		}
 	}
+	/**
+	* @returns whether every live sender of the kind took the constraints. A
+	* skipped non-device sender, an exhausted fallback, and having no live sender
+	* at all all report `false` — `mediaParamsUpdated.applied` is built from this,
+	* and an application told `true` cannot tell a working push from a no-op.
+	*/
 	async updateSendersConstraints(kind, constraints) {
 		if (!constraints) {
 			this.stopTrackSender(kind);
-			return Promise.resolve();
+			return false;
 		}
 		const senders = this.peerConnection.getSenders().filter((sender) => sender.track?.kind === kind && sender.track.readyState === "live");
+		let applied = senders.length > 0;
 		for (const sender of senders) {
 			const { track } = sender;
 			if (track) {
+				if (!this.options.localStreamController.isDeviceCapture(track)) {
+					logger$18.debug(`[TransceiverController] Skipping ${kind} constraints for a non-device track (origin: ${this.options.localStreamController.getTrackOrigin(track) ?? "unrecorded"}), track ${track.id}`);
+					applied = false;
+					continue;
+				}
 				const constraintsToApply = {
 					...track.getConstraints(),
 					...constraints
@@ -4967,33 +5233,39 @@ var TransceiverController = class extends Destroyable {
 					} catch (fallbackError) {
 						logger$18.warn(`[TransceiverController] Track replacement fallback also failed for ${kind} track:`, fallbackError);
 						this.options.onError?.(new MediaTrackError("updateSendersConstraints", kind, fallbackError));
+						applied = false;
 					}
 				}
 			}
 		}
+		return applied;
 	}
 	/**
-	* Fallback when applyConstraints fails: stop the current track, acquire a new
-	* one via getUserMedia with the merged constraints (preserving the current
-	* deviceId), replace the sender track, and update the localStream.
+	* Fallback when applyConstraints fails, which on iOS Safari it silently does.
 	*
-	* This is critical for iOS Safari where applyConstraints on audio tracks
-	* silently fails or throws.
+	* Order matters: acquiring before stopping means a failed acquisition leaves
+	* the existing media playing. The deviceId goes through the fallback ladder
+	* rather than pinned `{ exact }`, so a stale id degrades instead of failing.
 	*/
 	async replaceTrackFallback(sender, oldTrack, kind, mergedConstraints) {
 		const { deviceId } = oldTrack.getSettings();
-		const constraintsWithDevice = {
-			...mergedConstraints,
-			...deviceId ? { deviceId: { exact: deviceId } } : {}
-		};
-		const trackId = oldTrack.id;
+		const { stream, fallbackLevel } = await getUserMediaWithFallback({ getUserMedia: this.options.getUserMedia }, { [kind]: mergedConstraints }, kind, deviceId);
+		const newTrack = stream.getTracks().find((t) => t.kind === kind);
+		if (!newTrack) {
+			stream.getTracks().forEach((t) => t.stop());
+			throw new MediaTrackError("replaceTrackFallback", kind, /* @__PURE__ */ new Error("getUserMedia returned no track of the requested kind"));
+		}
+		try {
+			await sender.replaceTrack(newTrack);
+		} catch (error) {
+			stream.getTracks().forEach((t) => t.stop());
+			throw error;
+		}
+		const oldTrackId = oldTrack.id;
+		this.options.localStreamController.removeTrack(oldTrackId);
 		oldTrack.stop();
-		this.options.localStreamController.removeTrack(trackId);
-		const newTrack = (await this.options.getUserMedia({ [kind]: constraintsWithDevice })).getTracks().find((t) => t.kind === kind);
-		if (!newTrack) throw new MediaTrackError("replaceTrackFallback", kind, /* @__PURE__ */ new Error("getUserMedia returned no track of the requested kind"));
-		await sender.replaceTrack(newTrack);
 		this.options.localStreamController.addTrack(newTrack);
-		logger$18.debug(`[TransceiverController] Track replacement fallback succeeded for ${kind}. New track: ${newTrack.id}`);
+		logger$18.debug(`[TransceiverController] Track replacement fallback succeeded for ${kind} (deviceId fallback level: ${fallbackLevel}). New track: ${newTrack.id}`);
 	}
 	getMediaDirections() {
 		if (this.peerConnection.connectionState === "connected") return this.peerConnection.getTransceivers().reduce((acc, transceiver) => {
@@ -5062,48 +5334,44 @@ var RTCPeerConnectionController = class extends Destroyable {
 			this.negotiationNeeded$.next();
 		};
 		this.updateSelectedInputDevice = async (kind, deviceInfo) => {
+			const { localStream } = this;
+			if (!localStream) {
+				logger$17.warn("[RTCPeerConnectionController] No local stream available to update input device.");
+				return;
+			}
+			const currentTrack = localStream.getTracks().find((track) => track.kind === kind);
+			if (!currentTrack) {
+				logger$17.debug(`[RTCPeerConnectionController] No ${kind} track to switch.`);
+				return;
+			}
+			if (!deviceInfo) {
+				logger$17.debug(`[RTCPeerConnectionController] ${kind} input device selected: none`);
+				this.stopTrackSender(kind);
+				return;
+			}
+			const constraints = {
+				...currentTrack.getConstraints(),
+				...this.deviceController.deviceInfoToConstraints(deviceInfo)
+			};
 			try {
-				const { localStream } = this;
-				if (!localStream) {
-					logger$17.warn("[RTCPeerConnectionController] No local stream available to update input device.");
-					return;
-				}
-				logger$17.debug(`[RTCPeerConnectionController] Updating selected ${kind} input device:`, localStream.getTracks());
-				const track = localStream.getTracks().find((track$1) => track$1.kind === kind);
-				if (track) {
-					this.transceiverController?.stopTrackSender(kind);
-					this.localStreamController.removeTrack(track.id);
-					logger$17.debug(`[RTCPeerConnectionController] Stopped existing ${kind} track: ${track.id}`, localStream.getTracks());
-					if (!deviceInfo) {
-						logger$17.debug(`[RTCPeerConnectionController] ${kind} input device selected: none`);
-						return;
-					}
-					const streamTrack = (await this.getUserMedia({ [kind]: {
-						...track.getConstraints(),
-						...this.deviceController.deviceInfoToConstraints(deviceInfo)
-					} })).getTracks().find((t) => t.kind === kind);
-					if (streamTrack) {
-						logger$17.debug(`[RTCPeerConnectionController] Adding new ${kind} track: ${streamTrack.id}`);
-						this.localStreamController.addTrack(streamTrack);
-						await this.transceiverController?.replaceSenderTrack(kind, streamTrack);
-						logger$17.debug(`[RTCPeerConnectionController] Added new ${kind} track: ${streamTrack.id}`, this.localStream?.getTracks());
-					}
-				}
-				logger$17.debug(`[RTCPeerConnectionController] ${kind} input device selected:`, deviceInfo?.label);
+				const newTrack = await this.acquireInputTrack(kind, constraints, deviceInfo, currentTrack);
+				await this.attachInputTrack(kind, newTrack, currentTrack);
+				logger$17.debug(`[RTCPeerConnectionController] ${kind} input device selected:`, deviceInfo.label, newTrack.id);
 			} catch (error) {
 				logger$17.error(`[RTCPeerConnectionController] Failed to select ${kind} input device:`, error);
 				this._errors$.next(new MediaTrackError("updateSelectedInputDevice", kind, error));
-				throw error;
 			}
 		};
 		this._isNegotiating$ = this.createBehaviorSubject(false);
 		this._memberId = null;
+		this._nodeId = null;
 		this._iceConnectionState$ = this.createReplaySubject(1);
 		this._connectionState$ = this.createReplaySubject(1);
 		this._signalingState$ = this.createReplaySubject(1);
 		this._iceGatheringState$ = this.createReplaySubject(1);
 		this._errors$ = this.createReplaySubject(1);
 		this._iceCandidates$ = this.createReplaySubject(1);
+		this._localMediaSettled$ = this.createReplaySubject(1);
 		this._initialized$ = this.createReplaySubject(1);
 		this._remoteDescription$ = this.createReplaySubject(1);
 		this._remoteStream$ = this.createBehaviorSubject(null);
@@ -5136,6 +5404,7 @@ var RTCPeerConnectionController = class extends Destroyable {
 			inputVideoStream: this.options.inputVideoStream,
 			inputAudioDeviceConstraints: this.inputAudioDeviceConstraints,
 			inputVideoDeviceConstraints: this.inputVideoDeviceConstraints,
+			screenShareAudio: this.options.screenShareAudio,
 			getUserMedia: async (constraints) => this.getUserMedia(constraints),
 			getDisplayMedia: async (options$1) => this.getDisplayMedia(options$1)
 		});
@@ -5162,6 +5431,13 @@ var RTCPeerConnectionController = class extends Destroyable {
 	get memberId() {
 		return this._memberId;
 	}
+	/** The node this leg's invite landed on — auxiliary legs are placed independently. */
+	setNodeId(nodeId) {
+		this._nodeId = nodeId;
+	}
+	get nodeId() {
+		return this._nodeId;
+	}
 	stopTrackSender(kind, options = { updateTransceiverDirection: false }) {
 		const audioCovered = kind === "audio" || kind === "both";
 		if (audioCovered && this._localAudioPipeline) this.stopRawAudioInputForPipeline();
@@ -5171,10 +5447,7 @@ var RTCPeerConnectionController = class extends Destroyable {
 	}
 	stopRawAudioInputForPipeline() {
 		const rawTracks = this.localStreamController.localAudioTracks;
-		for (const track of rawTracks) if (track.readyState === "live") {
-			track.stop();
-			this.localStreamController.removeTrack(track.id);
-		}
+		for (const track of rawTracks) if (track.readyState === "live") this.localStreamController.removeTrack(track.id);
 		this._localAudioPipeline?.setInputTrack(null);
 	}
 	get isNegotiating$() {
@@ -5207,6 +5480,10 @@ var RTCPeerConnectionController = class extends Destroyable {
 	get remoteDescription$() {
 		return this.cachedObservable("remoteDescription$", () => this._remoteDescription$.asObservable().pipe(takeUntil(this.destroyed$)));
 	}
+	/** Emits once local media is settled — acquired, or knowingly receive-only. */
+	get localMediaSettled$() {
+		return this.cachedObservable("localMediaSettled$", () => this._localMediaSettled$.asObservable().pipe(takeUntil(this.destroyed$)));
+	}
 	get localStream$() {
 		return this.cachedObservable("localStream$", () => this.localStreamController.localStream$.pipe(takeUntil(this.destroyed$)));
 	}
@@ -5234,6 +5511,9 @@ var RTCPeerConnectionController = class extends Destroyable {
 	get propose() {
 		return this.options.propose ?? "main";
 	}
+	get connectionState() {
+		return this.peerConnection?.connectionState;
+	}
 	get isAdditionalDevice() {
 		return this.propose === "additional-device";
 	}
@@ -5362,7 +5642,7 @@ var RTCPeerConnectionController = class extends Destroyable {
 				this._isNegotiating$.next(true);
 				await this._setRemoteDescription(this.sdpInit);
 			} else {
-				await this.setupTrackHandling();
+				if (!await this.setupTrackHandling()) return;
 				this._initialized$.next(true);
 			}
 		} catch (error) {
@@ -5486,7 +5766,10 @@ var RTCPeerConnectionController = class extends Destroyable {
 				inputVideoDeviceConstraints: this.inputVideoDeviceConstraints
 			});
 		}
-		await this.setupLocalTracks();
+		if (!await this.setupLocalTracks()) {
+			logger$17.debug("[RTCPeerConnectionController] Inbound answer abandoned; the connection went away.");
+			return;
+		}
 		const { answerOptions } = this;
 		logger$17.debug("[RTCPeerConnectionController] Creating inbound answer with options:", answerOptions);
 		await this.createAnswer(answerOptions);
@@ -5624,35 +5907,52 @@ var RTCPeerConnectionController = class extends Destroyable {
 	}
 	/**
 	* Setup track handling for remote tracks.
+	*
+	* @returns `false` when the connection went away while local media was being
+	* acquired — see {@link setupLocalTracks}.
 	*/
 	async setupTrackHandling() {
 		if (!this.peerConnection) throw new DependencyError("RTCPeerConnection is not initialized");
-		await this.setupLocalTracks();
+		if (!await this.setupLocalTracks()) return false;
 		await this.setupRemoteTracks();
+		return true;
 	}
+	/**
+	* @returns `false` when the connection was torn down while getUserMedia was
+	* in flight. The acquisition is not cancellable, so the caller must stop
+	* rather than go on to touch a peer connection that is closed or gone.
+	*/
 	async setupLocalTracks() {
 		logger$17.debug("[RTCPeerConnectionController] Setting up local tracks/transceivers.");
 		if (this.hasNoLocalMediaToSend()) {
 			if (!this.receiveAudio && !this.receiveVideo) throw new InvalidParams("Call requests no media: enable audio/video or receiveAudio/receiveVideo");
 			logger$17.debug("[RTCPeerConnectionController] No local media requested; negotiating receive-only.");
 			this.setupReceiveOnlyTransceivers();
-			return;
+			this._localMediaSettled$.next();
+			return true;
 		}
 		let localStream;
 		try {
 			localStream = this.localStream ?? await this.localStreamController.buildLocalStream();
 		} catch (error) {
 			this.handleLocalMediaFailure(error);
-			return;
+			this._localMediaSettled$.next();
+			return true;
+		}
+		if (!this.peerConnection || this.peerConnection.signalingState === "closed") {
+			logger$17.debug("[RTCPeerConnectionController] Local media arrived after teardown; releasing it.");
+			localStream.getTracks().forEach((track) => track.stop());
+			return false;
 		}
+		this._localMediaSettled$.next();
 		if (this.transceiverController?.useAddStream ?? false) {
 			logger$17.warn("[RTCPeerConnectionController] Using deprecated addStream API to add local stream.");
-			this.peerConnection?.addStream(localStream);
+			this.peerConnection.addStream(localStream);
 			if (!this.isNegotiating) {
 				logger$17.debug("[RTCPeerConnectionController] Forcing negotiationneeded after local tracks setup.");
 				this.negotiationNeeded$.next();
 			}
-			return;
+			return true;
 		}
 		for (const kind of ["audio", "video"]) {
 			const tracks = (kind === "audio" ? localStream.getAudioTracks() : localStream.getVideoTracks()).map((track, index) => ({
@@ -5666,10 +5966,11 @@ var RTCPeerConnectionController = class extends Destroyable {
 					await this.transceiverController?.setupTransceiverSender(track, localStream, transceivers[index]);
 				} else {
 					logger$17.debug(`[RTCPeerConnectionController] Using addTrack for local ${kind} track:`, track.id);
-					this.peerConnection?.addTrack(track, localStream);
+					this.peerConnection.addTrack(track, localStream);
 				}
 			}
 		}
+		return true;
 	}
 	/** True for a main connection with no local media to send. */
 	hasNoLocalMediaToSend() {
@@ -5758,6 +6059,61 @@ var RTCPeerConnectionController = class extends Destroyable {
 		this._localAudioPipeline.setInputTrack(newTrack);
 	}
 	/**
+	* Capture the newly selected device, leaving the current capture running.
+	*
+	* A rejection must leave the current track sending, so nothing is released
+	* until the replacement is in hand. The one exception is hardware that admits
+	* a single opener — a phone's front and back cameras, typically — which
+	* rejects the second capture until the first is closed.
+	*/
+	async acquireInputTrack(kind, constraints, deviceInfo, currentTrack) {
+		try {
+			return await this.captureTrack(kind, constraints, deviceInfo.deviceId);
+		} catch (error) {
+			if (!isMediaDeviceInUse(error)) throw error;
+			logger$17.warn(`[RTCPeerConnectionController] ${kind} device is held exclusively; releasing the current capture to retry:`, error);
+			const previousDeviceId = currentTrack.getSettings().deviceId;
+			this.stopTrackSender(kind);
+			try {
+				return await this.captureTrack(kind, constraints, deviceInfo.deviceId);
+			} catch (retryError) {
+				await this.restorePreviousInputTrack(kind, constraints, previousDeviceId, currentTrack);
+				throw retryError;
+			}
+		}
+	}
+	async captureTrack(kind, constraints, deviceId) {
+		const { stream, fallbackLevel } = await getUserMediaWithFallback({ getUserMedia: async (c) => this.getUserMedia(c) }, { [kind]: constraints }, kind, deviceId);
+		const track = stream.getTracks().find((t) => t.kind === kind);
+		if (!track) {
+			stream.getTracks().forEach((t) => t.stop());
+			throw new MediaTrackError("updateSelectedInputDevice", kind, /* @__PURE__ */ new Error("getUserMedia returned no track of the requested kind"));
+		}
+		if (fallbackLevel !== "exact") logger$17.warn(`[RTCPeerConnectionController] ${kind} device acquired at fallback level '${fallbackLevel}'; the capture may not be the requested device.`);
+		return track;
+	}
+	/** Best-effort return to the device that was released for an exclusive retry. */
+	async restorePreviousInputTrack(kind, constraints, previousDeviceId, releasedTrack) {
+		try {
+			const restored = await this.captureTrack(kind, constraints, previousDeviceId);
+			await this.attachInputTrack(kind, restored, releasedTrack);
+		} catch (error) {
+			logger$17.error(`[RTCPeerConnectionController] Failed to restore the previous ${kind} device:`, error);
+		}
+	}
+	async attachInputTrack(kind, newTrack, oldTrack) {
+		const pipelineOwnsAudio = kind === "audio" && this._localAudioPipeline;
+		if (!pipelineOwnsAudio) try {
+			await this.transceiverController?.replaceSenderTrack(kind, newTrack);
+		} catch (error) {
+			newTrack.stop();
+			throw error;
+		}
+		this.localStreamController.removeTrack(oldTrack.id);
+		this.localStreamController.addTrack(newTrack);
+		if (pipelineOwnsAudio) this._localAudioPipeline?.setInputTrack(newTrack);
+	}
+	/**
 	* Return the lazily-created {@link LocalAudioPipeline}, constructing it on
 	* first access. On creation the current audio sender's track is routed
 	* through the pipeline (input → gain → analyser → destination) and the
@@ -5790,6 +6146,7 @@ var RTCPeerConnectionController = class extends Destroyable {
 		const sender = (this.transceiverController?.audioTransceivers.at(0))?.sender ?? this.peerConnection.getSenders().find((s) => s.track?.kind === "audio");
 		if (!sender || !raw) return;
 		try {
+			this.localStreamController.setTrackOrigin(this._localAudioPipeline.outputTrack, "processed");
 			await sender.replaceTrack(this._localAudioPipeline.outputTrack);
 		} catch (error) {
 			logger$17.warn("[RTCPeerConnectionController] Failed to route audio sender through pipeline:", error);
@@ -5850,37 +6207,68 @@ var RTCPeerConnectionController = class extends Destroyable {
 		for (const existingTrack of existingTracks) this.removeLocalTrack(existingTrack.id);
 		this.addLocalTrack(track);
 	}
+	/**
+	* @returns whether the constraints reached the media the leg is sending.
+	*
+	* With the pipeline engaged the audio sender carries the processed
+	* destination track, so the sender scan would find nothing it may touch and
+	* every audio constraint API would silently no-op. The constraints belong to
+	* the pipeline's device source, which is the capture that sender ultimately
+	* carries.
+	*/
 	async updateSendersConstraints(kind, constraints) {
-		await this.transceiverController?.updateSendersConstraints(kind, constraints);
+		if (kind === "audio" && this._localAudioPipeline) {
+			if (!constraints) {
+				this.stopTrackSender("audio");
+				return false;
+			}
+			return this.applyPipelineSourceConstraints(constraints);
+		}
+		return await this.transceiverController?.updateSendersConstraints(kind, constraints) ?? false;
 	}
 	/**
-	* Replace the current audio track with a new one using the given constraints.
-	* Used for server-pushed audio constraint changes where applyConstraints
-	* fails on iOS Safari. Stops the current track, acquires a new one via
-	* getUserMedia, and replaces the sender track.
+	* Mirror of the sender path for a piped audio leg: same merge, same fallback
+	* ladder, same device-capture invariant — but the swap target is the pipeline
+	* input, so the sender keeps emitting the pipeline's output track and its
+	* identity survives the change.
 	*/
-	async replaceAudioTrackWithConstraints(constraints) {
-		const senders = this.peerConnection?.getSenders().filter((s) => s.track?.kind === "audio" && s.track.readyState === "live");
-		if (!senders || senders.length === 0) {
-			logger$17.warn("[RTCPeerConnectionController] No live audio sender to replace");
-			return;
+	async applyPipelineSourceConstraints(constraints) {
+		const pipeline = this._localAudioPipeline;
+		const source = this.localStreamController.localAudioTracks.at(0);
+		if (!pipeline || !source) {
+			logger$17.debug("[RTCPeerConnectionController] No pipeline input to constrain.");
+			return false;
 		}
-		for (const sender of senders) {
-			const oldTrack = sender.track;
-			if (!oldTrack) continue;
-			const { deviceId } = oldTrack.getSettings();
-			const mergedConstraints = {
-				...oldTrack.getConstraints(),
-				...constraints,
-				...deviceId ? { deviceId: { exact: deviceId } } : {}
-			};
-			const trackId = oldTrack.id;
-			oldTrack.stop();
-			this.localStreamController.removeTrack(trackId);
-			const newTrack = (await this.getUserMedia({ audio: mergedConstraints })).getAudioTracks()[0];
-			await sender.replaceTrack(newTrack);
+		if (!this.localStreamController.isDeviceCapture(source)) {
+			logger$17.debug(`[RTCPeerConnectionController] Skipping audio constraints for a non-device pipeline input (origin: ${this.localStreamController.getTrackOrigin(source) ?? "unrecorded"}).`);
+			return false;
+		}
+		const merged = {
+			...source.getConstraints(),
+			...constraints
+		};
+		try {
+			await source.applyConstraints(merged);
+			logger$17.debug("[RTCPeerConnectionController] Pipeline input constraints updated:", merged);
+			return true;
+		} catch (error) {
+			logger$17.warn("[RTCPeerConnectionController] applyConstraints failed on the pipeline input, re-acquiring:", error);
+		}
+		try {
+			const { stream } = await getUserMediaWithFallback({ getUserMedia: async (c) => this.getUserMedia(c) }, { audio: merged }, "audio", source.getSettings().deviceId);
+			const newTrack = stream.getAudioTracks().at(0);
+			if (!newTrack) {
+				stream.getTracks().forEach((track) => track.stop());
+				throw new Error("getUserMedia returned no audio track");
+			}
+			this.localStreamController.removeTrack(source.id);
 			this.localStreamController.addTrack(newTrack);
-			logger$17.debug(`[RTCPeerConnectionController] Audio track replaced for server-pushed params. New track: ${newTrack.id}`);
+			pipeline.setInputTrack(newTrack);
+			return true;
+		} catch (error) {
+			logger$17.warn("[RTCPeerConnectionController] Failed to re-acquire the pipeline input for constraints:", error);
+			this._errors$.next(new MediaTrackError("updateSendersConstraints", "audio", error));
+			return false;
 		}
 	}
 	/**
@@ -5999,6 +6387,48 @@ const logger$16 = getLogger();
 function resolveInviteNodeId(args) {
 	return args.isInvite && !args.reattach && !args.explicitNodeId ? "" : args.currentNodeId ?? "";
 }
+/**
+* Surface the real outcome of a `webrtc.verto` reply.
+*
+* A webrtc.verto response nests several envelopes, each keyed by a verto-style
+* string `code` ("200" ok, "400"/etc. fail) rather than a JSON-RPC `error`. An outer
+* layer reports only whether the frame was delivered; an inner layer carries the op's
+* own outcome:
+*
+*   response.result = { code:"200", result:{…} }            ← delivery acknowledgement
+*     .result       = { jsonrpc, id, result:{…} }           ← the reply payload
+*       .result     = { code:"400", message:"Bad request" } ← the actual op outcome
+*
+* A failure can appear at any layer (delivery refused, or the op itself rejected
+* deeper down), so walk every nested `.result` object and return the FIRST non-2xx
+* `code` with its message. Returns null when every `code` seen is 2xx or absent —
+* i.e. the op succeeded. This is the only way to detect that e.g. a mute/kick was
+* rejected, since the outer delivery `code` is "200" (delivered) even then.
+*
+* Pure function — exported for unit testing.
+*/
+function findNestedVertoFailure(response) {
+	let node = response;
+	while (node !== null && typeof node === "object") {
+		const obj = node;
+		const err = obj.error;
+		if (err !== null && typeof err === "object") {
+			const e = err;
+			const errCode = typeof e.code === "string" || typeof e.code === "number" ? String(e.code) : void 0;
+			if (errCode !== void 0 && !/^2\d\d$/.test(errCode)) return {
+				code: errCode,
+				message: typeof e.message === "string" ? e.message : void 0
+			};
+		}
+		const code = typeof obj.code === "string" || typeof obj.code === "number" ? String(obj.code) : void 0;
+		if (code !== void 0 && !/^2\d\d$/.test(code)) return {
+			code,
+			message: typeof obj.message === "string" ? obj.message : void 0
+		};
+		node = obj.result !== null && typeof obj.result === "object" ? obj.result : null;
+	}
+	return null;
+}
 var VertoManager = class extends Destroyable {
 	constructor(callSession) {
 		super();
@@ -6021,7 +6451,7 @@ var WebRTCVertoManager = class extends VertoManager {
 		this._signalingStatus$ = this.createReplaySubject(1);
 		this._screenShareStatus$ = this.createBehaviorSubject("none");
 		this._rtcPeerConnectionsMap = /* @__PURE__ */ new Map();
-		this._screenShareTimeoutMs = 5e4;
+		this._legErrors$ = this.createSubject();
 		this._nodeId$ = this.createBehaviorSubject(options.nodeId ?? null);
 		this.onError = options.onError;
 		this.onModifyFailed = options.onModifyFailed;
@@ -6069,6 +6499,10 @@ var WebRTCVertoManager = class extends VertoManager {
 	get selfId$() {
 		return this._selfId$.asObservable();
 	}
+	/** Separates the media phase of call creation from the signalling phase. */
+	get localMediaSettled$() {
+		return this.mainPeerConnection.localMediaSettled$;
+	}
 	get localStream() {
 		return this._rtcPeerConnectionsMap.get(this.webRtcCallSession.id)?.localStream ?? null;
 	}
@@ -6125,41 +6559,101 @@ var WebRTCVertoManager = class extends VertoManager {
 			const { mediaParams, callID } = event;
 			const rtcPeerConnController = this._rtcPeerConnectionsMap.get(callID);
 			const { audio, video } = mediaParams;
-			(async () => {
-				try {
-					if (audio && rtcPeerConnController) await rtcPeerConnController.replaceAudioTrackWithConstraints(audio);
-					if (video) await rtcPeerConnController?.updateSendersConstraints("video", video);
-					this.webRtcCallSession.emitMediaParamsUpdated({
-						audio,
-						video,
-						timestamp: Date.now()
-					});
-				} catch (error) {
-					logger$16.warn("[WebRTCManager] Error applying server-pushed media params:", error);
-					this.onError?.(error instanceof Error ? error : new Error(String(error), { cause: error }));
-				}
-			})();
+			if (!rtcPeerConnController) {
+				logger$16.warn(`[WebRTCManager] Ignoring server-pushed media params for unknown leg ${callID}`);
+				return;
+			}
+			this.applyServerMediaParams(rtcPeerConnController, audio, video);
 		});
 		this.subscribeTo(this.vertoPing$, (vertoPing) => {
-			this.attachManager.attach(this.buildAttachableCall());
+			this.attachManager.refresh(this.buildAttachableCall());
 			this.sendVertoPong(vertoPing);
 		});
 	}
 	/**
-	* Set node_id/selfId only when the current value is null.
+	* An auxiliary-leg failure must never destroy the call; main-leg and
+	* call-level errors keep `CallFactory.isFatalError`'s classification.
 	*
-	* During reattach, `call.joined` and `verto.answer` events can deliver
-	* these identifiers before the `verto.invite` RPC response (`CALL CREATED`)
-	* arrives. These methods let early events populate them eagerly so that
-	* downstream RPC calls (e.g. `call.layout.list`) don't fail with empty
-	* identifiers. `processInviteResponse()` remains the authoritative source
-	* and always overwrites unconditionally.
+	* Every site holding a peer connection reports through here, so the invariant
+	* is structural rather than per-call-site — which is how cloud-product#20523
+	* happened, with only one of fourteen sites passing `{ fatal: false }`.
+	*
+	* `override` composes rather than replaces: a caller may force non-fatal for a
+	* reason of its own (a `verto.info` frame is best-effort whichever leg carries
+	* it), and an auxiliary leg stays non-fatal regardless.
 	*/
-	setNodeIdIfNull(nodeId) {
-		if (!this._nodeId$.value && nodeId) {
-			logger$16.debug(`[WebRTCManager] Early node_id set: ${nodeId}`);
-			this._nodeId$.next(nodeId);
-		}
+	reportLegError(error, rtcPeerConnController, override) {
+		const leg = rtcPeerConnController?.propose;
+		const legId = rtcPeerConnController?.id;
+		const auxiliary = Boolean(rtcPeerConnController) && !rtcPeerConnController?.isMainDevice;
+		this.onError?.(error, {
+			...override?.fatal === false || auxiliary ? { fatal: false } : {},
+			...leg ? { leg } : {},
+			...legId ? { legId } : {}
+		});
+		if (legId) this._legErrors$.next({
+			legId,
+			error
+		});
+	}
+	/**
+	* Errors reported for one leg, as a stream that fails with them.
+	*
+	* Signaling failures are reported, never thrown — so nothing that waits on a
+	* leg's progress would otherwise learn of a rejected invite. Merging this in
+	* lets the wait end with the reason the server gave.
+	*/
+	legError$(legId) {
+		return this._legErrors$.pipe(filter((report) => report.legId === legId), map((report) => {
+			throw report.error;
+		}));
+	}
+	/**
+	* Audio and video are applied independently so a failure in one cannot
+	* suppress the other, and `mediaParamsUpdated` is emitted whatever happens —
+	* an application should not be starved of the params by a constraint failure.
+	*/
+	async applyServerMediaParams(rtcPeerConnController, audio, video) {
+		const failures = [];
+		let applied = true;
+		if (audio) try {
+			applied = await rtcPeerConnController.updateSendersConstraints("audio", audio) && applied;
+		} catch (error) {
+			applied = false;
+			failures.push(toError(error));
+		}
+		if (video) try {
+			applied = await rtcPeerConnController.updateSendersConstraints("video", video) && applied;
+		} catch (error) {
+			applied = false;
+			failures.push(toError(error));
+		}
+		this.webRtcCallSession.emitMediaParamsUpdated({
+			audio,
+			video,
+			timestamp: Date.now(),
+			applied
+		});
+		for (const failure of failures) {
+			logger$16.warn("[WebRTCManager] Error applying server-pushed media params:", failure);
+			this.reportLegError(failure, rtcPeerConnController, { fatal: false });
+		}
+	}
+	/**
+	* Set node_id/selfId only when the current value is null.
+	*
+	* During reattach, `call.joined` and `verto.answer` events can deliver
+	* these identifiers before the `verto.invite` RPC response (`CALL CREATED`)
+	* arrives. These methods let early events populate them eagerly so that
+	* downstream RPC calls (e.g. `call.layout.list`) don't fail with empty
+	* identifiers. `processInviteResponse()` remains the authoritative source and
+	* overwrites unconditionally — for selfId, on the main leg only.
+	*/
+	setNodeIdIfNull(nodeId) {
+		if (!this._nodeId$.value && nodeId) {
+			logger$16.debug(`[WebRTCManager] Early node_id set: ${nodeId}`);
+			this._nodeId$.next(nodeId);
+		}
 	}
 	setSelfIdIfNull(selfId) {
 		if (!this._selfId$.value && selfId) {
@@ -6176,24 +6670,33 @@ var WebRTCVertoManager = class extends VertoManager {
 			this.onError?.(new VertoPongError(error));
 		}
 	}
+	/**
+	* @returns whether the constraints reached the media the call is sending.
+	* `false` is an outcome, not a failure: the leg may have no live sender of
+	* the kind, or carry media the SDK did not capture and may not replace.
+	* A failure behind it still reaches the call's `errors$`, so a caller that
+	* ignores this value learns of it there.
+	*/
 	async updateMediaConstraints(options = {}) {
 		const { audio, video } = options;
+		let applied = true;
 		try {
-			if (audio) await this.mainPeerConnection.updateSendersConstraints("audio", audio);
-			if (video) await this.mainPeerConnection.updateSendersConstraints("video", video);
+			if (audio) applied = await this.mainPeerConnection.updateSendersConstraints("audio", audio) && applied;
+			if (video) applied = await this.mainPeerConnection.updateSendersConstraints("video", video) && applied;
 		} catch (error) {
 			logger$16.warn("[WebRTCManager] Error updating media constraints:", error);
-			this.onError?.(error instanceof Error ? error : new Error(String(error), { cause: error }));
+			this.reportLegError(toError(error), this.mainPeerConnection);
 			throw error;
 		}
+		return applied;
 	}
 	get selfId() {
 		return this._selfId$.value;
 	}
 	/** Build an AttachableCall from the current call state. */
-	buildAttachableCall(idOverride) {
+	buildAttachableCall(idOverride, nodeIdOverride) {
 		return {
-			nodeId: this.nodeId ?? void 0,
+			nodeId: nodeIdOverride ?? this.nodeId ?? void 0,
 			id: idOverride ?? this.webRtcCallSession.id,
 			to: this.webRtcCallSession.to,
 			mediaDirections: this.webRtcCallSession.mediaDirections
@@ -6323,24 +6826,49 @@ var WebRTCVertoManager = class extends VertoManager {
 	get vertoPing$() {
 		return this.cachedObservable("vertoPing$", () => this.webRtcCallSession.webrtcMessages$.pipe(filterAs(isVertoPingInnerParams, "params"), takeUntil(this.destroyed$)));
 	}
+	/**
+	* Send a member-control op in-dialog via verto.info.
+	*
+	* The control payload rides in `params.command` — a sibling of `dialogParams`,
+	* at the same level as `dtmf` in {@link sendDigits} — and the inner verto.info
+	* is matched to this call's channel by `dialogParams.callID`, the in-dialog
+	* convention for member-scoped frames. Because it is delivered on the dialog
+	* itself, control lands on the call's own channel with no {node_id,call_id,member_id}
+	* "self" tuple to get wrong. The outer webrtc.verto envelope (added by executeVerto)
+	* still carries the own-leg callID + node_id for session routing.
+	*
+	* Keep `command` OUT of `dialogParams`: it is read at the params level, and
+	* filterVertoParams rewrites/filters dialogParams keys but passes params-level
+	* keys through verbatim.
+	*/
+	async sendCallControl(method, params) {
+		const response = await this.executeVerto(VertoInfo({
+			dialogParams: { callID: this.webRtcCallSession.id },
+			command: {
+				method,
+				params
+			}
+		}));
+		const failure = findNestedVertoFailure(response);
+		if (failure) throw new JSONRPCError(Number.parseInt(failure.code, 10) || 0, `Call control "${method}" failed (code ${failure.code})${failure.message ? `: ${failure.message}` : ""}`, void 0);
+		return response;
+	}
 	async executeVerto(message, optionals = {}) {
-		const webrtcVertoMessage = WebrtcVerto({
+		const params = {
 			callID: optionals.callID ?? this.webRtcCallSession.id,
 			node_id: optionals.node_id ?? this._nodeId$.value ?? "",
 			message,
 			subscribe: optionals.subscribe
-		});
+		};
+		const webrtcVertoMessage = WebrtcVerto(params);
 		const response = await this.webRtcCallSession.execute(webrtcVertoMessage);
-		if (response.error) {
-			const error = new JSONRPCError(response.error.code, response.error.message, response.error.data);
-			this.onError?.(error);
-			return response;
-		}
+		const nonFatal = message.method === "verto.info" ? { fatal: false } : void 0;
 		const innerResult = getValueFrom(response, "result.result");
-		if (innerResult?.error) {
-			const error = new JSONRPCError(innerResult.error.code, innerResult.error.message, innerResult.error.data);
-			this.onError?.(error);
-			return response;
+		const failure = response.error ?? innerResult?.error;
+		if (failure) {
+			const error = new JSONRPCError(failure.code, failure.message, failure.data);
+			if (message.method === "verto.invite" || message.method === "verto.answer") throw error;
+			this.reportLegError(error, this._rtcPeerConnectionsMap.get(params.callID), nonFatal);
 		}
 		return response;
 	}
@@ -6359,8 +6887,9 @@ var WebRTCVertoManager = class extends VertoManager {
 				default:
 			}
 		} catch (error) {
+			if (vertoMethod === "verto.answer") throw error;
 			logger$16.error(`[WebRTCManager] Error sending Verto ${vertoMethod}:`, error);
-			this.onError?.(error instanceof Error ? error : new Error(String(error), { cause: error }));
+			this.reportLegError(toError(error), rtcPeerConnController);
 			if (vertoMethod === "verto.modify") this.onModifyFailed?.();
 		}
 	}
@@ -6376,7 +6905,7 @@ var WebRTCVertoManager = class extends VertoManager {
 			} catch (error) {
 				logger$16.warn("[WebRTCManager] Error processing modify response:", error);
 				const modifyError = error instanceof Error ? error : new Error(String(error), { cause: error });
-				this.onError?.(modifyError);
+				this.reportLegError(modifyError, rtcPeerConnController);
 			}
 		}
 	}
@@ -6389,37 +6918,35 @@ var WebRTCVertoManager = class extends VertoManager {
 				status,
 				signalingError
 			});
-			this.onError?.(signalingError);
+			this.reportLegError(signalingError, null, { fatal: false });
 			return;
 		}
 		if (rtcPeerConnController.isMainDevice) this._signalingStatus$.next(status);
 	}
 	processInviteResponse(response, rtcPeerConnController) {
-		if (!response.error && getValueFrom(response, "result.result.result.message") === "CALL CREATED") {
+		if (getValueFrom(response, "result.result.result.message") === "CALL CREATED") {
 			this.emitMainSignalingStatus(rtcPeerConnController.id, "trying");
-			this._nodeId$.next(getValueFrom(response, "result.node_id") ?? null);
+			const nodeId = getValueFrom(response, "result.node_id") ?? null;
 			const memberId = getValueFrom(response, "result.result.result.memberID") ?? null;
-			const callId = getValueFrom(response, "result.result.result.callID") ?? null;
+			const callId = getValueFrom(response, "result.result.result.callID");
 			logger$16.debug("[WebRTCManager] Verto invite response:", {
 				callId,
 				memberId,
 				response
 			});
-			this._selfId$.next(memberId);
 			rtcPeerConnController.setMemberId(memberId);
-			if (callId) {
-				this.webRtcCallSession.addCallId(callId);
-				this.attachManager.attach(this.buildAttachableCall(callId));
-			} else logger$16.warn("[WebRTCManager] Cannot attach call, missing callId:", {
-				nodeId: this.nodeId,
-				callId
-			});
+			rtcPeerConnController.setNodeId(nodeId);
+			if (rtcPeerConnController.isMainDevice) {
+				this._selfId$.next(memberId);
+				this._nodeId$.next(nodeId);
+				this.attachManager.attach(this.buildAttachableCall(callId, nodeId ?? void 0));
+			}
+			if (callId) this.webRtcCallSession.addCallId(callId);
 			logger$16.info("[WebRTCManager] Verto invite successful");
 			logger$16.debug(`[WebRTCManager] nodeid: ${this._nodeId$.value}, selfId: ${this._selfId$.value}`);
 		} else {
 			logger$16.error("[WebRTCManager] Verto invite failed:", response);
-			const inviteError = response.error ? new JSONRPCError(response.error.code, response.error.message, response.error.data) : /* @__PURE__ */ new Error("Verto invite failed: unexpected response");
-			this.onError?.(inviteError);
+			this.reportLegError(/* @__PURE__ */ new Error("Verto invite failed: unexpected response"), rtcPeerConnController);
 		}
 	}
 	get RTCPeerConnectionConfig() {
@@ -6458,7 +6985,7 @@ var WebRTCVertoManager = class extends VertoManager {
 		this._rtcPeerConnectionsMap.set(rtcPeerConnController.id, rtcPeerConnController);
 		this._rtcPeerConnections$.next(Array.from(this._rtcPeerConnectionsMap.values()));
 		this.subscribeTo(rtcPeerConnController.errors$, (error) => {
-			this.onError?.(error);
+			this.reportLegError(error, rtcPeerConnController);
 		});
 		if (options.initOffer) this.handleInboundAnswer(rtcPeerConnController);
 	}
@@ -6487,7 +7014,7 @@ var WebRTCVertoManager = class extends VertoManager {
 				await rtcPeerConnController.acceptInbound(answerOptions);
 			} catch (error) {
 				logger$16.error("[WebRTCManager] Error creating inbound answer:", error);
-				this.onError?.(error instanceof Error ? error : new Error(String(error), { cause: error }));
+				this.reportLegError(toError(error), rtcPeerConnController);
 			}
 		}
 	}
@@ -6559,7 +7086,7 @@ var WebRTCVertoManager = class extends VertoManager {
 				isInvite: isVertoInviteMessage(vertoMessage),
 				reattach: this.webRtcCallSession.options.reattach === true,
 				explicitNodeId: this.webRtcCallSession.options.nodeId,
-				currentNodeId: this._nodeId$.value
+				currentNodeId: rtcPeerConnController.nodeId ?? this._nodeId$.value
 			}),
 			subscribe
 		};
@@ -6591,7 +7118,7 @@ var WebRTCVertoManager = class extends VertoManager {
 				await this.attachManager.attach(this.buildAttachableCall());
 			} catch (error) {
 				logger$16.error("[WebRTCManager] Error sending Verto answer:", error);
-				this.onError?.(error instanceof Error ? error : new Error(String(error), { cause: error }));
+				this.reportLegError(toError(error), rtcPeerConnectionController);
 				await rtcPeerConnectionController.updateAnswerStatus({ status: "failed" });
 			}
 		}
@@ -6663,15 +7190,19 @@ var WebRTCVertoManager = class extends VertoManager {
 			await this.mainPeerConnection.restoreTrackSender(deviceKind);
 		} else {
 			const error = new InvalidParams("No valid device to be added");
-			this.onError?.(error);
+			this.reportLegError(error, this.mainPeerConnection);
 			throw error;
 		}
 	}
-	async addScreenMedia(options = { audio: false }) {
-		await this.initAdditionalPeerConnection("screenshare", options);
+	async addScreenMedia(options = {}) {
+		await this.initAdditionalPeerConnection("screenshare", {
+			audio: false,
+			screenShareAudio: options.audio ?? false
+		});
 	}
 	async initAdditionalPeerConnection(propose, options) {
 		const isScreenShare = propose === "screenshare";
+		if (isScreenShare && this._screenShareId && this._rtcPeerConnectionsMap.has(this._screenShareId)) throw new ScreenShareAlreadyActiveError(this._screenShareId);
 		let firstPeerConnectionError;
 		let rtcPeerConnController = null;
 		try {
@@ -6688,21 +7219,36 @@ var WebRTCVertoManager = class extends VertoManager {
 			this._rtcPeerConnections$.next(Array.from(this._rtcPeerConnectionsMap.values()));
 			this.subscribeTo(rtcPeerConnController.errors$, (error) => {
 				firstPeerConnectionError ??= error;
-				this.onError?.(error, { fatal: false });
+				this.reportLegError(error, rtcPeerConnController);
 			});
-			await firstValueFrom(rtcPeerConnController.connectionState$.pipe(filter((state) => state === "connected"), take(1), timeout(this._screenShareTimeoutMs), takeUntil(this.destroyed$)));
+			const pc = rtcPeerConnController;
+			await firstValueFrom(merge(pc.localMediaSettled$.pipe(take(1), switchMap(() => pc.connectionState$.pipe(filter((state) => state === "connected"), take(1), timeout(DEFAULT_AUX_LEG_CONNECT_TIMEOUT_MS)))), this.legError$(pc.id)).pipe(takeUntil(merge(this.destroyed$, pc.destroyed$))));
 			if (isScreenShare) this._screenShareStatus$.next("started");
 			logger$16.info(`[WebRTCManager] Additional peer connection connected (${propose}).`);
 			return rtcPeerConnController.id;
 		} catch (error) {
-			logger$16.warn("[WebRTCManager] Error initializing additional peer connection:", error);
-			if (rtcPeerConnController) rtcPeerConnController.destroy();
-			if (isScreenShare) this._screenShareStatus$.next("none");
+			const cancelled = error instanceof AuxiliaryLegCancelledError;
+			const aborted = error instanceof EmptyError && !firstPeerConnectionError;
+			if (!cancelled && !aborted) logger$16.warn("[WebRTCManager] Error initializing additional peer connection:", error);
+			if (rtcPeerConnController && this._rtcPeerConnectionsMap.has(rtcPeerConnController.id)) {
+				rtcPeerConnController.destroy();
+				this._rtcPeerConnectionsMap.delete(rtcPeerConnController.id);
+				this._rtcPeerConnections$.next(Array.from(this._rtcPeerConnectionsMap.values()));
+			}
+			if (isScreenShare) {
+				this._screenShareId = void 0;
+				this._screenShareStatus$.next("none");
+			}
+			if (cancelled) {
+				logger$16.debug("[WebRTCManager] Additional peer connection removed before connecting.");
+				throw error;
+			}
 			if (firstPeerConnectionError) throw firstPeerConnectionError instanceof MediaAccessError && firstPeerConnectionError.originalError instanceof Error ? firstPeerConnectionError.originalError : firstPeerConnectionError;
 			if (error instanceof EmptyError) {
 				logger$16.debug("[WebRTCManager] Additional peer connection aborted before connecting.");
 				return;
 			}
+			if (error instanceof TimeoutError) throw new AuxiliaryLegTimeoutError(propose, error);
 			throw error instanceof Error ? error : new Error(String(error), { cause: error });
 		}
 	}
@@ -6719,7 +7265,10 @@ var WebRTCVertoManager = class extends VertoManager {
 		if (removeTrack) return this.mainPeerConnection.stopTrackSender(removeTrack, { updateTransceiverDirection: true });
 	}
 	async removeScreenMedia() {
-		if (!["starting", "started"].includes(this._screenShareStatus$.value)) logger$16.warn("[WebRTCManager] No active screen share to stop.");
+		if (!["starting", "started"].includes(this._screenShareStatus$.value)) {
+			logger$16.warn("[WebRTCManager] No active screen share to stop.");
+			return;
+		}
 		if (!this._screenShareId) {
 			logger$16.debug("[WebRTCManager] No screen share peer connection found.");
 			return;
@@ -6734,6 +7283,10 @@ var WebRTCVertoManager = class extends VertoManager {
 		try {
 			if (rtcPeerConnController) await this.executeVertoBye(rtcPeerConnController);
 		} finally {
+			if (rtcPeerConnController && rtcPeerConnController.connectionState !== "connected") this._legErrors$.next({
+				legId: id,
+				error: new AuxiliaryLegCancelledError(rtcPeerConnController.propose)
+			});
 			rtcPeerConnController?.destroy();
 			this._rtcPeerConnectionsMap.delete(id);
 			this._rtcPeerConnections$.next(Array.from(this._rtcPeerConnectionsMap.values()));
@@ -6748,7 +7301,10 @@ var WebRTCVertoManager = class extends VertoManager {
 			await this.executeVerto(VertoBye({
 				...causeParams,
 				dialogParams: this.dialogParams(rtcPeerConnController)
-			}));
+			}), {
+				callID: rtcPeerConnController.id,
+				node_id: rtcPeerConnController.nodeId ?? void 0
+			});
 		} catch (error) {
 			logger$16.warn("[WebRTCManager] Call might already be disconnected, error sending Verto bye:", error);
 			throw error;
@@ -7631,14 +8187,35 @@ function mosToQualityLevel(mos) {
 }
 
 //#endregion
-//#region src/core/entities/Call.ts
-const logger$12 = getLogger();
+//#region src/utils/unwrapVertoReply.ts
 /**
-* Verto method for setting member layout positions. Its gateway DTO requires a
-* `targets` array whose entries are `{ target, position }` (NOT bare targets),
-* so {@link WebRTCCall.buildMethodParams} special-cases it. See issue #19400.
+* Unwrap a method's own reply from a `webrtc.verto` envelope.
+*
+* A control verb sent in-dialog comes back nested two levels deep:
+*
+* ```
+* { result: { node_id, code, result: { jsonrpc, id, result: <method payload> } } }
+* ```
+*
+* whereas the routed transport resolves the method payload directly under
+* `.result`. Readers want the latter shape, and the difference is silent when it
+* is wrong — `response.result.layouts` simply evaluates to `undefined` against the
+* envelope, so the data arrives, nothing throws, and the caller sees an empty
+* value. That exact failure produced an empty layout dropdown with a successful
+* request behind it.
+*
+* Accepting both shapes here keeps every reader indifferent to which transport
+* produced the response. Anything that is not a nested envelope (a plain ack, or
+* an already-unwrapped reply) passes through untouched.
 */
-const POSITION_SET_METHOD = "call.member.position.set";
+function unwrapVertoReply(response) {
+	const inner = getValueFrom(response, "result.result");
+	return inner && typeof inner === "object" && "result" in inner ? inner : response;
+}
+
+//#endregion
+//#region src/core/entities/Call.ts
+const logger$12 = getLogger();
 /**
 * Ratio between the critical and warning RTT spike multipliers.
 * Warning threshold = baseline * warningMultiplier (default 3x)
@@ -7734,8 +8311,11 @@ var WebRTCCall = class extends Destroyable {
 	emitError(callError) {
 		if (this._status$.value === "destroyed" || this._status$.value === "failed") return;
 		this._errors$.next(callError);
-		if (callError.fatal) {
+		if (callError.fatal && this._status$.value !== "disconnecting") {
 			this._status$.next("failed");
+			this.vertoManager.bye().catch((error) => {
+				logger$12.debug("[Call] fatal-teardown bye failed (signaling likely already dead):", error);
+			});
 			this.destroy();
 		}
 	}
@@ -7790,7 +8370,7 @@ var WebRTCCall = class extends Destroyable {
 	/** Toggles the call lock state, preventing or allowing new participants from joining. */
 	async toggleLock() {
 		const method = this.locked ? "call.unlock" : "call.lock";
-		await this.executeMethod(this.selfId ?? "", method, {});
+		await this.executeMethod(this.callSelf, method, {});
 	}
 	/**
 	* Toggles the hold state of the call (pauses/resumes local media transmission).
@@ -7839,14 +8419,25 @@ var WebRTCCall = class extends Destroyable {
 	*
 	* Constructs call context (node_id, call_id, member_id) and sends the RPC request.
 	*
-	* @param target - Target member ID string, or a {@link MemberTarget} object.
+	* @param target - Target {@link MemberTarget} triple, or the local member's
+	*   ID string for self-operations (any other string is rejected — a bare
+	*   member id cannot carry the remote member's own call context).
 	* @param method - Verto method name (e.g. `'call.mute'`, `'call.member.remove'`).
 	* @param args - Parameters for the RPC method.
 	* @returns The RPC response.
+	* @throws {CallNotReadyError} If the call has no self member context yet.
+	* @throws {InvalidParams} If a string target is not the local member's ID.
 	* @throws {JSONRPCError} If the RPC call returns an error.
 	*/
 	async executeMethod(target, method, args) {
-		const params = this.buildMethodParams(target, args, method);
+		const self = this.callSelf;
+		if (typeof target === "string" && target !== self.member_id) throw new InvalidParams(`Target member ID ${target} does not match call's self member ID ${self.member_id}`);
+		if (this.clientSession.callControl === "in-dialog") return this.executeMethodInDialog(target, method, args);
+		const params = {
+			...args,
+			self,
+			target: typeof target === "string" ? self : target
+		};
 		const request = buildRPCRequest({
 			method,
 			params
@@ -7860,29 +8451,98 @@ var WebRTCCall = class extends Destroyable {
 			throw error;
 		}
 	}
-	buildMethodParams(target, args, method) {
-		const self = {
-			node_id: this.nodeId ?? "",
-			call_id: this.id,
-			member_id: this.vertoManager.selfId ?? ""
-		};
-		if (method === POSITION_SET_METHOD) return {
-			...args,
-			self
-		};
-		if (typeof target === "object") return {
-			...args,
-			self,
-			targets: [target]
-		};
-		return {
-			...args,
-			self,
-			target: {
-				node_id: this.nodeId ?? "",
+	/**
+	* `executeMethod` for a call opened with `callControl: 'in-dialog'`.
+	*
+	* Translates the routed transport's calling convention into the in-dialog one. No
+	* `self` tuple is sent, but a `target` is — the same {call_id, member_id} the routed
+	* transport puts in `target` (minus node_id), for self-ops and cross-member ops alike.
+	*
+	* Target shapes are per-verb and irregular, so they are centralised here rather
+	* than left to callers: most verbs take a singular `target`, `call.member.remove`
+	* takes a plural `targets` array, and `call.member.position.set` takes a flat
+	* `targets` of `{call_id, position}` — the one verb keyed on call_id rather than
+	* member_id, so the member triple `Participant.setPosition` built is unwrapped.
+	*/
+	async executeMethodInDialog(target, method, args) {
+		const control = { ...args };
+		if (method === "call.member.position.set") control.targets = (args.targets ?? []).map((entry) => ({
+			call_id: entry.target?.call_id ?? entry.call_id,
+			position: entry.position
+		}));
+		else {
+			const member = typeof target === "object" ? {
+				call_id: target.call_id,
+				member_id: target.member_id
+			} : {
 				call_id: this.id,
 				member_id: target
-			}
+			};
+			if (method === "call.member.remove") control.targets = [member];
+			else control.target = member;
+		}
+		return this.sendCommand(method, control);
+	}
+	/**
+	* Sends a `call.*` control verb **in-dialog** via `verto.info`, as an alternative
+	* to the routed {@link executeMethod} transport.
+	*
+	* Why both exist: `executeMethod` addresses the member with an explicit
+	* `{node_id, call_id, member_id}` tuple, which does not resolve for every conference,
+	* so the op can fail. An in-dialog frame carries the verb on the member's own
+	* signaling channel instead, so control works without the client needing to know how
+	* the conference is hosted.
+	*
+	* The trade-off is reach: the in-dialog transport is only accepted for calls that
+	* join a conference over SWML (e.g. an SWML `join_conference`); use the routed
+	* default otherwise.
+	*
+	* `params` are sent verbatim — nothing is built for you, which includes the target.
+	* **A self-directed op still needs one**, or it is refused; name yourself explicitly:
+	*
+	* ```ts
+	* const { call_id, member_id } = call.self.target;
+	* await call.sendCommand('call.mute', { channels: ['audio'], target: { call_id, member_id } });
+	* ```
+	*
+	* Never include `node_id` — only the two ids. The shapes are per-verb: most take a
+	* singular `target`, `call.member.remove` takes a plural `targets` array, and
+	* `call.member.position.set` takes a flat `targets: [{call_id, position}]` (the one
+	* verb keyed on `call_id` rather than `member_id`). Verbs that act on the call as a
+	* whole, or that the SDK does not wrap at all, take no target.
+	*
+	* For the typed alternative that handles all of this, create the client with
+	* `callControl: 'in-dialog'` and use the ordinary `Call`/`Participant` methods.
+	*
+	* @internal Not part of the supported surface while the in-dialog transport is still
+	* rolling out. `WebRTCCall` is exported from the package entry, so without this tag
+	* TypeDoc publishes the method — and the example above — as public API.
+	*
+	* @param method - A `call.*` method name (e.g. `'call.mute'`).
+	* @param params - Method parameters, sent verbatim.
+	* @returns The method's own reply, unwrapped from the `verto.info` envelope.
+	* @throws {JSONRPCError} If the control op fails.
+	*/
+	async sendCommand(method, params = {}) {
+		return unwrapVertoReply(await this.vertoManager.sendCallControl(method, params));
+	}
+	/**
+	* The local leg's member triple — sent as `self` in every member RPC
+	* envelope, and as the `target` of call-scoped self-operations (e.g. lock,
+	* layout).
+	*
+	* @throws {CallNotReadyError} Before `call.joined` delivers the self member
+	* context (`selfId`/`nodeId`) — an RPC without it cannot be routed, so fail
+	* fast instead of sending a doomed request.
+	*/
+	get callSelf() {
+		const node_id = this.nodeId;
+		const member_id = this.vertoManager.selfId;
+		if (!node_id || !member_id) throw new CallNotReadyError(this.id);
+		return {
+			node_id,
+			call_id: this.id,
+			member_id
 		};
 	}
 	/** Observable of the current call status (e.g. `'ringing'`, `'connected'`). */
@@ -8038,13 +8698,13 @@ var WebRTCCall = class extends Destroyable {
 	get bandwidthConstrained$() {
 		return this.deferEmission(this._bandwidthConstrained$.asObservable());
 	}
-	/** Observable that emits when server-pushed media params are applied. */
+	/** Observable that emits when the server pushes media params. */
 	get mediaParamsUpdated$() {
 		return this.deferEmission(this._mediaParamsUpdated$.asObservable());
 	}
 	/**
 	* @internal Emit a media params update event.
-	* Called by the VertoManager when server-pushed media params are applied.
+	* Called by the VertoManager when the server pushes media params.
 	*/
 	emitMediaParamsUpdated(event) {
 		this._mediaParamsUpdated$.next(event);
@@ -8252,6 +8912,10 @@ var WebRTCCall = class extends Destroyable {
 	get selfId$() {
 		return this.vertoManager.selfId$;
 	}
+	/** @internal Lets call creation bound the media and signalling phases apart. */
+	get localMediaSettled$() {
+		return this.vertoManager.localMediaSettled$;
+	}
 	/** Local participant's member ID, or `null` if not joined. */
 	get selfId() {
 		return this.vertoManager.selfId;
@@ -8445,12 +9109,17 @@ var WebRTCCall = class extends Destroyable {
 	*
 	* **These operations are NOT atomic.** The layout is applied first, then each
 	* member position sequentially, so members may briefly flash into their
-	* default slots before being moved to the requested positions.
+	* default slots before being moved to the requested positions. Targeted
+	* members are validated upfront, though: when any of them has no
+	* {@link Participant.target | member call context} yet, the whole call
+	* rejects before any request is sent and the layout is left unchanged.
 	*
 	* @param layout - Layout name (must be one of {@link layouts}).
 	* @param positions - Optional map of member IDs to {@link VideoPosition} values.
 	*   When omitted or empty, only the layout is changed.
 	* @throws {InvalidParams} If the layout is not in the available {@link layouts}.
+	* @throws {ParticipantNotReadyError} If a targeted member's call context has
+	*   not been received yet — thrown before any request is sent.
 	*
 	* @example
 	* ```ts
@@ -8461,18 +9130,19 @@ var WebRTCCall = class extends Destroyable {
 	*/
 	async setLayout(layout, positions) {
 		if (!this.layouts.includes(layout)) throw new InvalidParams(`Layout ${layout} is not available in the current call layouts: ${this.layouts.join(", ")}`);
-		const selfId = await firstValueFrom(this.selfId$.pipe(filter((id) => id !== null)));
-		await this.executeMethod(selfId, "call.layout.set", { layout });
-		const positionEntries = Object.entries(positions ?? {});
-		if (positionEntries.length === 0) return;
-		for (const [memberId, position] of positionEntries) {
+		const targets = [];
+		for (const [memberId, position] of Object.entries(positions ?? {})) {
 			const participant = this.participants.find((p) => p.id === memberId);
 			if (!participant) {
 				logger$12.warn(`[Call] setLayout: member ${memberId} not found in participants; skipping position ${position}`);
 				continue;
 			}
-			await participant.setPosition(position);
+			participant.target;
+			targets.push([participant, position]);
 		}
+		const selfId = await firstValueFrom(this.selfId$.pipe(filter((id) => id !== null)));
+		await this.executeMethod(selfId, "call.layout.set", { layout });
+		for (const [participant, position] of targets) await participant.setPosition(position);
 	}
 	/**
 	* Transfers the call to another destination.
@@ -8574,17 +9244,28 @@ var WebRTCCall = class extends Destroyable {
 	* (notably iOS Safari) fall back to re-acquiring the track with the new
 	* constraint set and plumbing the replacement through the local audio
 	* pipeline if one is active.
+	*
+	* @returns whether the constraint reached the microphone. `false` is an
+	* outcome rather than an error — a leg sending media the SDK did not capture
+	* is left alone — so a UI that reflects the toggle must read it. Any failure
+	* behind a `false` is also reported on {@link errors$}.
 	*/
 	async setEchoCancellation(enabled) {
-		await this.vertoManager.updateMediaConstraints({ audio: { echoCancellation: enabled } });
+		return this.vertoManager.updateMediaConstraints({ audio: { echoCancellation: enabled } });
 	}
-	/** Toggle browser noise suppression on the local mic at runtime. */
+	/**
+	* Toggle browser noise suppression on the local mic at runtime.
+	* @returns whether the constraint reached the microphone.
+	*/
 	async setNoiseSuppression(enabled) {
-		await this.vertoManager.updateMediaConstraints({ audio: { noiseSuppression: enabled } });
+		return this.vertoManager.updateMediaConstraints({ audio: { noiseSuppression: enabled } });
 	}
-	/** Toggle browser automatic gain control on the local mic at runtime. */
+	/**
+	* Toggle browser automatic gain control on the local mic at runtime.
+	* @returns whether the constraint reached the microphone.
+	*/
 	async setAutoGainControl(enabled) {
-		await this.vertoManager.updateMediaConstraints({ audio: { autoGainControl: enabled } });
+		return this.vertoManager.updateMediaConstraints({ audio: { autoGainControl: enabled } });
 	}
 	/**
 	* Observable of the aggregate remote audio level, 0..1 RMS. The server
@@ -8641,6 +9322,9 @@ var WebRTCCall = class extends Destroyable {
 /**
 * Infers the semantic error category from a raw Error thrown by VertoManager
 * or an RTCPeerConnection layer.
+*
+* Pure function — exported for unit testing.
+* @internal
 */
 function inferCallErrorKind(error) {
 	if (error instanceof RPCTimeoutError) return "timeout";
@@ -8659,7 +9343,14 @@ const RECOVERABLE_RPC_CODES = new Set([
 	RPC_ERROR_AUTHENTICATION_FAILED,
 	RPC_ERROR_INVALID_PARAMS
 ]);
-/** Determines whether an error should be fatal (destroy the call). */
+/**
+* A *fallback*: callers knowing which leg failed pass an explicit `fatal` and
+* never reach here, so the default-fatal branch only sees call- and main-leg
+* errors. Auxiliary legs go through `WebRTCVertoManager.reportLegError`.
+*
+* Pure function — exported for unit testing.
+* @internal
+*/
 function isFatalError(error) {
 	if (error instanceof VertoPongError) return false;
 	if (error instanceof MediaTrackError) return false;
@@ -8694,7 +9385,9 @@ var CallFactory = class {
 								kind: inferCallErrorKind(error),
 								fatal: options$1?.fatal ?? isFatalError(error),
 								error,
-								callId: callInstance.id
+								callId: callInstance.id,
+								...options$1?.leg ? { leg: options$1.leg } : {},
+								...options$1?.legId ? { legId: options$1.legId } : {}
 							};
 							callInstance.emitError(callError);
 						},
@@ -9162,6 +9855,30 @@ const logger$9 = getLogger();
 function shouldAbortDial(callError) {
 	return callError.fatal || !(callError.error instanceof MediaAccessError);
 }
+/**
+* Wait for a dialed call to be ready, or for the failure that stops it.
+*
+* Local media acquisition is deliberately unbounded: a permission prompt or a
+* device picker is human time, and `getUserMedia` cannot be cancelled anyway.
+* The clock starts only once acquisition settles, so a slow human never spends
+* the server's budget.
+*
+* `merge` rather than `race`, because the two legs settle asymmetrically. A
+* fatal acquisition failure reports the error and then destroys the call in the
+* same synchronous step; `errors$` defers delivery by a microtask while
+* `localMediaSettled$` completes immediately. Under `race` that bare completion
+* ended the wait first and `dial()` rejected with an RxJS `EmptyError`, burying
+* the `NotAllowedError` applications are told to inspect. Under `merge` the
+* completed leg is simply spent, and the queued error — enqueued before the
+* completion, so delivered before it — arrives to reject the wait. A dial
+* abandoned with no error at all still ends both legs, and the resulting
+* `EmptyError` remains the benign-cancel signal.
+*
+* Exported for unit testing.
+*/
+async function awaitDialReady(session, signalingTimeoutMs) {
+	return firstValueFrom(merge(session.localMediaSettled$.pipe(take(1), switchMap(() => session.selfId$.pipe(filter((id) => Boolean(id)), take(1), timeout(signalingTimeoutMs)))), session.errors$.pipe(filter(shouldAbortDial), take(1), switchMap((callError) => throwError(() => callError.error)))));
+}
 const getAddressSearchURI = (options) => {
 	const to = options.to?.split("?")[0];
 	const from$1 = options.from?.startsWith("subscriber://") ? options.from.replace("subscriber://", "") : options.from;
@@ -9178,7 +9895,6 @@ var ClientSessionManager = class extends Destroyable {
 		this.authorizationStateKey = authorizationStateKey;
 		this.attachManager = attachManager;
 		this.dpopManager = dpopManager;
-		this.callCreateTimeout = 6e3;
 		this.agent = `signalwire-js/4.0.0`;
 		this.eventAcks = true;
 		this.authorizationState$ = this.createReplaySubject(1);
@@ -9187,6 +9903,7 @@ var ClientSessionManager = class extends Destroyable {
 			minor: 0,
 			revision: 0
 		};
+		this.callControl = "routed";
 		this._authorization$ = this.createBehaviorSubject(void 0);
 		this._errors$ = this.createReplaySubject(1);
 		this._authState$ = this.createBehaviorSubject({ kind: "unauthenticated" });
@@ -9387,21 +10104,18 @@ var ClientSessionManager = class extends Destroyable {
 	}
 	async handleAuthenticationError(error) {
 		logger$9.error("Authentication error:", error);
-		const isRecoverableAuthError = error instanceof JSONRPCError && (error.code === RPC_ERROR_REQUESTER_VALIDATION_FAILED || error.code === RPC_ERROR_INVALID_PARAMS || error.code === RPC_ERROR_AUTHENTICATION_FAILED);
+		const isRecoverableAuthError$1 = error instanceof JSONRPCError && (error.code === RPC_ERROR_REQUESTER_VALIDATION_FAILED || error.code === RPC_ERROR_INVALID_PARAMS || error.code === RPC_ERROR_AUTHENTICATION_FAILED);
 		const hasStoredState = await firstValueFrom(this.authorizationState$.pipe(take(1))) !== void 0;
-		if (isRecoverableAuthError && hasStoredState) {
+		if (isRecoverableAuthError$1 && hasStoredState) {
 			logger$9.debug("[Session] Recoverable auth error — cleaning up stored state and reconnecting fresh");
-			try {
-				await this.cleanupStoredConnectionParams();
-			} catch (cleanupError) {
-				logger$9.error("Failed to cleanup stored connection params:", cleanupError);
-			} finally {
-				this.transport.reconnect();
-			}
+			await this.discardResumeStateAndReconnect();
 		} else this._errors$.next(error);
 	}
 	/**
-	* Clear the resume state (authorization_state + protocol) only.
+	* Clear the resume state (authorization_state + protocol) and ask the
+	* transport to reconnect. The `connected` event re-triggers
+	* `authenticate()`, which now has no stored state and so performs a fresh
+	* connect.
 	*
 	* This is the stale-auth-state recovery helper used by handleAuthError:
 	* the server rejected a reconnect, so the resume state is discarded and a
@@ -9409,9 +10123,24 @@ var ClientSessionManager = class extends Destroyable {
 	* session lives on through the reconnect and reattachCalls() needs the
 	* stored call references afterwards. Do NOT add detachAll() here.
 	*
+	* Connect-time recovery only. A *request* refused on an already
+	* authenticated session is never healed here: dropping the resume state
+	* destroys the association between the socket and the previous session,
+	* which is what reattach depends on. That path mints a fresh credential and
+	* reauthenticates instead (see `SignalWire.recoverAndRetry`).
+	*
 	* For public teardown (disconnect/destroy), use {@link teardownSessionState}
 	* instead, which clears the attach records as well.
 	*/
+	async discardResumeStateAndReconnect() {
+		try {
+			await this.cleanupStoredConnectionParams();
+		} catch (cleanupError) {
+			logger$9.error("Failed to cleanup stored connection params:", cleanupError);
+		} finally {
+			this.transport.reconnect();
+		}
+	}
 	async cleanupStoredConnectionParams() {
 		await this.transport.setProtocol(void 0);
 		await this.updateAuthorizationStateInStorage(void 0);
@@ -9485,11 +10214,15 @@ var ClientSessionManager = class extends Destroyable {
 		const isReconnect = hasReconnectState && storedToken;
 		let dpopToken;
 		if (isReconnect) logger$9.debug("[Session] Reconnecting with stored jwt_token + authorization_state");
-		else if (this.onBeforeReconnect && this.clientBound) {
-			logger$9.debug("[Session] Refreshing credentials before fresh connect");
-			await this.onBeforeReconnect();
+		else {
+			const credential = this.getCredential();
+			const credentialExpired = credential.expiry_at !== void 0 && credential.expiry_at <= Date.now() + CREDENTIAL_EXPIRY_SKEW_MS;
+			if (this.onBeforeReconnect && (this.clientBound || credentialExpired)) {
+				logger$9.debug("[Session] Refreshing credentials before fresh connect");
+				await this.onBeforeReconnect();
+			}
 		}
-		if ((!isReconnect || this.clientBound) && this.dpopManager?.initialized) try {
+		if (this.dpopManager?.initialized) try {
 			dpopToken = await this.dpopManager.createRpcProof({ method: "signalwire.connect" });
 		} catch (error) {
 			if (this.clientBound) throw error;
@@ -9522,6 +10255,7 @@ var ClientSessionManager = class extends Destroyable {
 		});
 		if (response.protocol) await this.transport.setProtocol(response.protocol);
 		this._authorization$.next(response.authorization);
+		if (response.authorization.cnf?.jkt) this._wasClientBound = true;
 		this._iceServers$.next(response.ice_servers ?? []);
 		this._authState$.next({ kind: "authenticated" });
 		logger$9.debug("[Session] Authentication completed successfully");
@@ -9588,7 +10322,7 @@ var ClientSessionManager = class extends Destroyable {
 				to: destinationURI,
 				...options
 			});
-			await firstValueFrom(race(callSession.selfId$.pipe(filter((id) => Boolean(id)), take(1), timeout(this.callCreateTimeout)), callSession.errors$.pipe(filter(shouldAbortDial), take(1), switchMap((callError) => throwError(() => callError.error)))));
+			await awaitDialReady(callSession, DEFAULT_CALL_SIGNALING_TIMEOUT_MS);
 			this._calls$.next({
 				[`${callSession.id}`]: callSession,
 				...this._calls$.value
@@ -9641,12 +10375,23 @@ var ClientSessionWrapper = class {
 	get authenticated() {
 		return this.clientSessionManager.authenticated;
 	}
+	/**
+	* Whether the session is using a Client Bound SAT (DPoP). Sticky — set
+	* when the binding is established or restored from a resumed session's
+	* server authorization.
+	*/
+	get clientBound() {
+		return this.clientSessionManager.clientBound;
+	}
 	get signalingEvent$() {
 		return this.clientSessionManager.signalingEvent$;
 	}
 	get iceServers() {
 		return this.clientSessionManager.iceServers;
 	}
+	get callControl() {
+		return this.clientSessionManager.callControl;
+	}
 	async execute(request, options) {
 		return this.clientSessionManager.execute(request, options);
 	}
@@ -9841,7 +10586,7 @@ var DeviceTokenManager = class extends Destroyable {
 			await session.reauthenticate(tokenData.token, rpcProof, { clientBound: true });
 			updateCredential({ token: tokenData.token });
 			logger$7.info("[DeviceToken] Client Bound SAT activated successfully");
-			this._currentToken$.next(tokenData);
+			this.emitCurrentToken(tokenData);
 			return { activated: true };
 		} catch (error) {
 			logger$7.error("[DeviceToken] Failed to activate Client Bound SAT:", error);
@@ -9853,6 +10598,21 @@ var DeviceTokenManager = class extends Destroyable {
 		}
 	}
 	/**
+	* Emit a freshly received token to the reactive pipeline, stamping an
+	* absolute `expires_at` when the response carried only `expires_in`.
+	* Resolving the expiry at RECEIVE time (not at read time) is what lets
+	* {@link refreshNowIfDue} detect due-ness on resume: a bare `expires_in`
+	* re-resolved later would always compute a full TTL from "now" and never
+	* cross the refresh buffer.
+	*/
+	emitCurrentToken(token) {
+		const stamped = token.expires_at ? token : {
+			...token,
+			expires_at: resolveExpiresAt(token)
+		};
+		this._currentToken$.next(stamped);
+	}
+	/**
 	* Returns true when the cached token has enough headroom before expiry to
 	* be safely reused on reactivation. The headroom matches the refresh
 	* buffer, so a token within the refresh window is treated as stale (the
@@ -9870,7 +10630,7 @@ var DeviceTokenManager = class extends Destroyable {
 			method: "POST",
 			uri: DEVICE_TOKEN_ENDPOINT
 		});
-		const response = await this.http.request({
+		const response = await this.http().request({
 			url: DEVICE_TOKEN_ENDPOINT,
 			...POST_PARAMS,
 			body: JSON.stringify({
@@ -9897,7 +10657,7 @@ var DeviceTokenManager = class extends Destroyable {
 			uri: DEVICE_REFRESH_ENDPOINT,
 			accessToken: currentToken
 		});
-		const response = await this.http.request({
+		const response = await this.http().request({
 			url: DEVICE_REFRESH_ENDPOINT,
 			...POST_PARAMS,
 			body: JSON.stringify({
@@ -9945,7 +10705,7 @@ var DeviceTokenManager = class extends Destroyable {
 			const currentToken = this.getCredential().token;
 			if (!currentToken) throw new TokenRefreshError("No current token available for refresh");
 			const newTokenData = await this.retryRefresh(session, currentToken, updateCredential);
-			this._currentToken$.next(newTokenData);
+			this.emitCurrentToken(newTokenData);
 		} catch (error) {
 			logger$7.error("[DeviceToken] Automatic Client Bound SAT refresh failed:", error);
 			this.errorHandler(error instanceof TokenRefreshError ? error : new TokenRefreshError("Automatic token refresh failed", error));
@@ -9972,6 +10732,22 @@ var DeviceTokenManager = class extends Destroyable {
 		throw lastError instanceof Error ? lastError : new TokenRefreshError("All refresh retries exhausted", lastError);
 	}
 	/**
+	* Force an immediate refresh when the cached Client Bound SAT is already
+	* past its refresh window. Called on resume from suspension where
+	* background-tab throttling can delay the reactive timer past the buffer.
+	* A no-op when no token is cached or it still has headroom; the normal
+	* {@link executeRefresh} guards (paused / in-progress / unauthenticated)
+	* still apply.
+	*/
+	refreshNowIfDue() {
+		const token = this._currentToken$.value;
+		if (!token) return;
+		if (resolveExpiresAt(token) * 1e3 - Date.now() <= DEVICE_TOKEN_REFRESH_BUFFER_MS) {
+			logger$7.debug("[DeviceToken] Resume: cached SAT past refresh window; refreshing now");
+			this.executeRefresh();
+		}
+	}
+	/**
 	* Stops the reactive refresh pipeline from firing. Use when the underlying
 	* session is being torn down (e.g., during {@link SignalWire.disconnect})
 	* so a scheduled refresh cannot fire against a destroyed session.
@@ -10022,6 +10798,7 @@ var CredentialRefreshCoordinator = class extends Destroyable {
 		this.deps = deps;
 		this._activating = false;
 		this._activationGeneration = 0;
+		this._developerRefreshInProgress = false;
 		if (dpopManager?.initialized) this._deviceTokenManager = (deps.deviceTokenManagerFactory ?? defaultDeviceTokenManagerFactory)(dpopManager, deps.http, (error) => deps.notifier.onError(error), () => deps.store.read());
 	}
 	/** True when the Client Bound SAT path is available (DPoP initialized). */
@@ -10040,28 +10817,120 @@ var CredentialRefreshCoordinator = class extends Destroyable {
 	* invokes `deps.onRefreshExhausted` so the orchestrator can disconnect.
 	*/
 	scheduleDeveloperRefresh(provider, expiresAt, attempt = 0) {
+		this._activeProvider = provider;
 		if (this._developerTimerId !== void 0) clearTimeout(this._developerTimerId);
 		const refreshInterval = attempt === 0 ? Math.max(expiresAt - Date.now() - CREDENTIAL_REFRESH_BUFFER_MS, 1e3) : Math.min(CREDENTIAL_REFRESH_RETRY_BASE_MS * Math.pow(2, attempt) * (.5 + Math.random() * .5), CREDENTIAL_REFRESH_MAX_DELAY_MS);
-		this._developerTimerId = setTimeout(async () => {
+		this._developerTimerId = setTimeout(() => {
+			this._developerTimerId = void 0;
+			this.executeDeveloperRefresh(provider, expiresAt, attempt);
+		}, refreshInterval);
+	}
+	/**
+	* Runs the developer-provided refresh once: mints a new credential, stores
+	* and persists it, reauthenticates the live session (via the notifier), and
+	* reschedules against the new expiry. On failure retries with backoff up to
+	* {@link CREDENTIAL_REFRESH_MAX_RETRIES}, then signals exhaustion.
+	*
+	* Shared by the scheduled timer tick and {@link forceRefreshIfDue}. The
+	* `_developerRefreshInProgress` guard prevents the two from overlapping.
+	*/
+	async executeDeveloperRefresh(provider, expiresAt, attempt) {
+		if (this._developerRefreshInProgress) {
+			logger$6.debug("[Coordinator] Developer refresh already in progress; skipping");
+			return;
+		}
+		this._developerRefreshInProgress = true;
+		try {
+			const newCredentials = await this.refreshCredential(provider);
+			this.deps.store.write(newCredentials);
+			this.deps.store.persist(newCredentials);
 			try {
-				if (!provider.refresh) throw new InvalidCredentialsError("Credential provider does not support refresh");
-				const newCredentials = await provider.refresh();
-				this.deps.store.write(newCredentials);
-				this.deps.store.persist(newCredentials);
-				logger$6.info("[Coordinator] Credentials refreshed successfully.");
-				if (newCredentials.expiry_at) this.scheduleDeveloperRefresh(provider, newCredentials.expiry_at, 0);
-			} catch (error) {
-				const nextAttempt = attempt + 1;
-				logger$6.error(`[Coordinator] Credential refresh failed (attempt ${nextAttempt}/${CREDENTIAL_REFRESH_MAX_RETRIES}):`, error);
-				this.deps.notifier.onError(error instanceof Error ? error : new Error(String(error), { cause: error }));
-				if (nextAttempt < CREDENTIAL_REFRESH_MAX_RETRIES) this.scheduleDeveloperRefresh(provider, expiresAt, nextAttempt);
-				else {
-					logger$6.error("[Coordinator] Credential refresh exhausted all retries. Disconnecting.");
-					this.deps.notifier.onError(new TokenRefreshError("Credential refresh failed after max retries"));
-					this.deps.notifier.onRefreshExhausted();
-				}
+				await this.deps.notifier.onCredentialRefreshed(newCredentials);
+			} catch (reauthError) {
+				logger$6.warn("[Coordinator] onCredentialRefreshed rejected (non-fatal):", reauthError);
 			}
-		}, refreshInterval);
+			logger$6.info("[Coordinator] Credentials refreshed successfully.");
+			if (newCredentials.expiry_at) this.scheduleDeveloperRefresh(provider, newCredentials.expiry_at, 0);
+		} catch (error) {
+			const nextAttempt = attempt + 1;
+			logger$6.error(`[Coordinator] Credential refresh failed (attempt ${nextAttempt}/${CREDENTIAL_REFRESH_MAX_RETRIES}):`, error);
+			this.deps.notifier.onError(error instanceof Error ? error : new Error(String(error), { cause: error }));
+			if (nextAttempt < CREDENTIAL_REFRESH_MAX_RETRIES) this.scheduleDeveloperRefresh(provider, expiresAt, nextAttempt);
+			else {
+				logger$6.error("[Coordinator] Credential refresh exhausted all retries. Disconnecting.");
+				this.deps.notifier.onError(new TokenRefreshError("Credential refresh failed after max retries"));
+				this.deps.notifier.onRefreshExhausted();
+			}
+		} finally {
+			this._developerRefreshInProgress = false;
+		}
+	}
+	/**
+	* Force an immediate refresh when the current credential is already past its
+	* scheduled refresh window. Called on resume from suspension, where
+	* background-tab timer throttling can delay the armed refresh well past
+	* expiry, leaving the live session stale.
+	*
+	* Routes to whichever mechanism is armed: the developer timer if armed,
+	* otherwise the Client Bound SAT pipeline. A no-op when nothing is due.
+	*/
+	forceRefreshIfDue() {
+		if (this._developerTimerId !== void 0 && this._activeProvider) {
+			const expiry = this.deps.store.read().expiry_at;
+			if (expiry !== void 0 && Date.now() >= expiry - CREDENTIAL_REFRESH_BUFFER_MS) {
+				logger$6.debug("[Coordinator] Resume: credential past refresh window; forcing refresh");
+				clearTimeout(this._developerTimerId);
+				this._developerTimerId = void 0;
+				this.executeDeveloperRefresh(this._activeProvider, expiry, 0);
+			}
+			return;
+		}
+		this._deviceTokenManager?.refreshNowIfDue();
+	}
+	/**
+	* Sync the credential's expiry from the server-provided authorization (the
+	* `signalwire.connect` result). SATs are opaque JWE, so
+	* `fabric_subscriber.expires_at` is the authoritative expiry of the token
+	* the session actually connected with — the provider-reported `expiry_at`
+	* is only a hint (and may be wrong or absent). Corrects the stored
+	* credential and re-arms the developer refresh timer against the real
+	* deadline when the provider supports `refresh()`.
+	*/
+	syncExpiryFromAuthorization(authorization, provider) {
+		const expiresAtSec = authorization?.fabric_subscriber?.expires_at;
+		if (!expiresAtSec) return;
+		const expiryAt = expiresAtSec * 1e3;
+		const credential = this.deps.store.read();
+		if (credential.expiry_at === expiryAt) return;
+		logger$6.debug(`[Coordinator] Correcting credential expiry from server authorization: ${new Date(expiryAt).toISOString()}`);
+		const updated = {
+			...credential,
+			expiry_at: expiryAt
+		};
+		this.deps.store.write(updated);
+		this.deps.store.persist(updated);
+		if (provider?.refresh) this.scheduleDeveloperRefresh(provider, expiryAt);
+	}
+	/**
+	* Invoke `provider.refresh()` deduped against any concurrent developer
+	* refresh. Concurrent callers — the scheduled tick, a resume-forced refresh,
+	* and the orchestrator's -32003 recovery / reconnect re-mint — share one
+	* in-flight promise, so a provider backed by one-time-use rotating refresh
+	* tokens is never invoked twice in parallel.
+	*
+	* The caller owns applying the returned credential (store write, session
+	* reauth, rescheduling); this method only serializes the network call.
+	*/
+	async refreshCredential(provider) {
+		if (this._refreshInFlight) return this._refreshInFlight;
+		if (!provider.refresh) throw new InvalidCredentialsError("Credential provider does not support refresh");
+		const run = provider.refresh();
+		this._refreshInFlight = run;
+		const clear = () => {
+			if (this._refreshInFlight === run) this._refreshInFlight = void 0;
+		};
+		run.then(clear, clear);
+		return run;
 	}
 	/**
 	* Cancels any scheduled developer-provided refresh. Idempotent.
@@ -10841,6 +11710,13 @@ var TransportManager = class extends Destroyable {
 //#endregion
 //#region src/clients/SignalWire.ts
 const logger$1 = getLogger();
+/**
+* Storage key for the client-bound marker. The SAT and authorization_state are
+* both opaque to the SDK, so on a page reload the preflight recovery — which
+* runs before any session exists — has no other way to know the session was
+* client-bound. See {@link SignalWire.persistClientBoundMarker}.
+*/
+const CLIENT_BOUND_STORAGE_KEY = "sw:client_bound";
 const buildOptionsFromDestination = (destination) => {
 	if (typeof destination === "string") {
 		const queryStartIndex = destination.indexOf("?");
@@ -10884,6 +11760,7 @@ var SignalWire = class extends Destroyable {
 		this.preferences = new ClientPreferences();
 		this._user$ = this.createBehaviorSubject(void 0);
 		this._directory$ = this.createBehaviorSubject(void 0);
+		this._credentialRecovered = false;
 		this._isConnected$ = this.createBehaviorSubject(false);
 		this._isRegistered$ = this.createBehaviorSubject(false);
 		this._errors$ = this.createReplaySubject(1);
@@ -10922,6 +11799,16 @@ var SignalWire = class extends Destroyable {
 		});
 	}
 	/**
+	* Build the refresh path's own HTTP controller, against whatever host is current.
+	*
+	* Called on first use rather than up front, so `apiHost` already reflects the
+	* token's `ch` claim. Same credential source as the container's controller — only
+	* the instance, and therefore its observable streams, is separate.
+	*/
+	createRefreshHttpController() {
+		return new HTTPRequestController(this._deps.apiHost, () => this._deps.credential);
+	}
+	/**
 	* Initializes DPoP if not already set up. Returns the fingerprint on success.
 	*/
 	async initDPoP() {
@@ -10948,11 +11835,19 @@ var SignalWire = class extends Destroyable {
 	async resolveCredentials() {
 		const fingerprint = await this.initDPoP();
 		this._refreshCoordinator = new CredentialRefreshCoordinator(this._dpopManager, {
-			http: this._deps.http,
+			http: () => {
+				if (!this._refreshHttp || this._refreshHttpHost !== this._deps.apiHost) {
+					this._refreshHttp?.destroy();
+					this._refreshHttp = this.createRefreshHttpController();
+					this._refreshHttpHost = this._deps.apiHost;
+				}
+				return this._refreshHttp;
+			},
 			notifier: {
 				onError: (error) => this._errors$.next(error),
 				onWarning: (warning) => this._warnings$.next(warning),
-				onRefreshExhausted: () => void this.disconnect()
+				onRefreshExhausted: () => void this.disconnect(),
+				onCredentialRefreshed: async (credential) => this.reauthenticateLiveSession(credential)
 			},
 			store: {
 				read: () => this._deps.credential,
@@ -10964,6 +11859,7 @@ var SignalWire = class extends Destroyable {
 						...this._deps.credential,
 						...partial
 					};
+					this.persistCredential(this._deps.credential);
 				},
 				persist: (credential) => this.persistCredential(credential)
 			}
@@ -11009,20 +11905,181 @@ var SignalWire = class extends Destroyable {
 		}
 		this._deps.credential = _credentials;
 		this.persistCredential(_credentials);
-		if (this.isConnected && this._clientSession.authenticated && _credentials.token) try {
-			await this._clientSession.reauthenticate(_credentials.token);
+		await this.reauthenticateLiveSession(_credentials);
+	}
+	/**
+	* Reauthenticate the currently-open session with a freshly obtained
+	* credential so the new token takes effect on the live socket immediately —
+	* not just on the next reconnect. No-op when the session is not
+	* connected/authenticated or the credential carries no token (e.g. an
+	* authorization-state-only refresh). Non-fatal: reauth failures surface on
+	* `errors$` without aborting the refresh that triggered this.
+	*/
+	async reauthenticateLiveSession(credential) {
+		if (!this.isConnected || !this._clientSession.authenticated || !credential.token) return;
+		try {
+			await this._clientSession.reauthenticate(credential.token);
 			logger$1.info("[SignalWire] Session refreshed with new credentials.");
 		} catch (error) {
 			logger$1.error("[SignalWire] Failed to refresh session with new credentials:", error);
 			this._errors$.next(error instanceof Error ? error : new Error(String(error), { cause: error }));
 		}
 	}
+	/**
+	* Recover a session the server is refusing: mint a fresh credential,
+	* reauthenticate the live session with it, and retry the operation.
+	*
+	* The connection is deliberately kept. A reload authenticates the new socket
+	* against the persisted `authorization_state`, and that handshake is what
+	* associates the socket with the previous session — the association reattach
+	* depends on. `signalwire.reauthenticate` swaps the credential *on that same
+	* session*, so recovery never touches the resume state. Discarding it would
+	* heal the credential by destroying the very thing the caller is trying to
+	* get back to.
+	*
+	* The operation is still the verdict, never the RPC. Reauthenticating with
+	* the in-memory token is accepted by a resume even while requests stay
+	* refused, because the persisted `authorization_state` short-circuits token
+	* validation — and `signalwire.reauthenticate` with a *freshly minted* token
+	* has also been observed accepted while `subscriber.online` keeps being
+	* refused (staging run 33826974634). Both look like success and are not.
+	*
+	* @returns the operation's value, or the reason recovery could not deliver
+	*   one. `error` is undefined when there was no way to mint at all.
+	*/
+	async recoverAndRetry(operation) {
+		if (!await this.remintAndReauthenticate()) return { ok: false };
+		try {
+			const value = await operation();
+			this._credentialRecovered = true;
+			return {
+				ok: true,
+				value
+			};
+		} catch (error) {
+			logger$1.warn("[SignalWire] Reauthentication was accepted but the operation is still refused:", error);
+			return {
+				ok: false,
+				error
+			};
+		}
+	}
+	/**
+	* Re-mint a credential and adopt it only if the live session accepts it.
+	*
+	* The mechanism follows the binding: a client-bound session re-mints a bound
+	* base SAT through `authenticate()` with the DPoP fingerprint, because the
+	* developer refresh handler would hand back an unbound token and silently
+	* degrade the session. An unbound session uses the refresh handler. Rotation
+	* cost is not a reason to skip this — the only reason is having no mechanism.
+	*
+	* @returns whether the session is now running on a freshly accepted credential.
+	*/
+	async remintAndReauthenticate() {
+		const provider = this._credentialProvider;
+		if (!provider) return false;
+		const { clientBound } = this._clientSession;
+		if (!clientBound && !provider.refresh) {
+			logger$1.debug("[SignalWire] [SW-NO-REFRESH-HANDLER] Unbound session with no refresh handler; cannot re-mint.");
+			return false;
+		}
+		try {
+			const newCredentials = clientBound ? await provider.authenticate(this._dpopManager?.initialized ? { fingerprint: this._dpopManager.fingerprint } : void 0) : await this.remintCredential(provider);
+			if (!newCredentials.token) {
+				logger$1.warn("[SignalWire] Re-minted credential has no token; keeping the current one.");
+				return false;
+			}
+			await this._clientSession.reauthenticate(newCredentials.token);
+			this._deps.credential = newCredentials;
+			this.persistCredential(newCredentials);
+			if (newCredentials.expiry_at && provider.refresh) this._refreshCoordinator?.scheduleDeveloperRefresh(provider, newCredentials.expiry_at);
+			return true;
+		} catch (error) {
+			logger$1.warn("[SignalWire] Re-mint recovery failed:", error);
+			return false;
+		}
+	}
+	/**
+	* Re-mint a credential via `provider.refresh()`, routed through the
+	* coordinator's shared in-flight guard so concurrent re-mint paths (a
+	* scheduled/resume refresh, -32003 recovery, and reconnect) never fire a
+	* second `provider.refresh()` in parallel — which rotating one-time-use
+	* refresh tokens reject. Falls back to a direct call only if the coordinator
+	* has not been constructed yet.
+	*/
+	async remintCredential(provider) {
+		if (this._refreshCoordinator) return this._refreshCoordinator.refreshCredential(provider);
+		if (!provider.refresh) throw new InvalidCredentialsError("Credential provider does not support refresh");
+		return provider.refresh();
+	}
+	/**
+	* Re-mint credentials before a fresh (re)connect (`onBeforeReconnect` hook).
+	* The session invokes this only when it is client-bound OR the in-memory
+	* token is expired. The re-mint mechanism depends on the binding:
+	*   - Client-bound: `authenticate()` with the DPoP fingerprint to obtain a
+	*     fresh base SAT the upcoming reconnect can re-bind (the
+	*     DeviceTokenManager re-activates afterwards).
+	*   - Unbound: the developer's non-interactive `refresh()` handler.
+	*     `authenticate()` is deliberately NOT used here — it may be interactive
+	*     (a login prompt) and must not fire on a background reconnect.
+	*
+	* Rejects on failure so the session aborts the reconnect rather than
+	* replaying a stale token.
+	*/
+	async refreshCredentialForReconnect() {
+		if (!this._credentialProvider) return;
+		try {
+			let newCredentials;
+			if (this._clientSession?.clientBound ?? await this.wasClientBound()) {
+				logger$1.debug("[SignalWire] Re-minting client-bound base SAT before reconnect");
+				newCredentials = await this._credentialProvider.authenticate(this._dpopManager?.initialized ? { fingerprint: this._dpopManager.fingerprint } : void 0);
+			} else if (this._credentialProvider.refresh) {
+				logger$1.debug("[SignalWire] Refreshing unbound credential before reconnect");
+				newCredentials = await this.remintCredential(this._credentialProvider);
+			} else {
+				logger$1.warn("[SignalWire] [SW-NO-REFRESH-HANDLER] Token expired on reconnect but no refresh handler; reconnecting with the existing token.");
+				return;
+			}
+			if (!newCredentials.token) {
+				logger$1.warn("[SignalWire] Re-minted credential has no token; keeping the existing credential for reconnect.");
+				return;
+			}
+			this._deps.credential = newCredentials;
+			this.persistCredential(newCredentials);
+			if (newCredentials.expiry_at && this._credentialProvider.refresh) this._refreshCoordinator?.scheduleDeveloperRefresh(this._credentialProvider, newCredentials.expiry_at);
+			logger$1.debug("[SignalWire] Credential refreshed successfully for reconnect");
+		} catch (error) {
+			logger$1.error("[SignalWire] Failed to refresh credentials for reconnect:", error);
+			this._errors$.next(error instanceof Error ? error : new Error(String(error), { cause: error }));
+			throw error;
+		}
+	}
 	/** Persist credential to localStorage when persistSession is enabled. */
 	persistCredential(credential) {
 		if (!credential.token) return;
 		this._deps.storage.setItem("sw:cached_credential", credential);
 		if (this._deps.persistSession) this._deps.storage.setItem("sw:cached_credential", credential, "local");
 	}
+	/**
+	* Persist whether the session is client-bound, mirroring the credential's
+	* storage scopes so it survives a reload. The preflight recovery reads it
+	* before any session exists to decide whether to re-bind via `authenticate()`
+	* or refresh an unbound token; the marker tracks the latest binding, so an
+	* unbound reconnect clears a stale marker from an earlier client-bound login.
+	*/
+	persistClientBoundMarker(bound) {
+		const scopes = this._deps.persistSession ? ["session", "local"] : ["session"];
+		for (const scope of scopes) if (bound) this._deps.storage.setItem(CLIENT_BOUND_STORAGE_KEY, true, scope);
+		else this._deps.storage.removeItem(CLIENT_BOUND_STORAGE_KEY, scope);
+	}
+	/** Read the persisted client-bound marker (see {@link persistClientBoundMarker}). */
+	async wasClientBound() {
+		const scopes = this._deps.persistSession ? ["local", "session"] : ["session"];
+		for (const scope of scopes) try {
+			if (await this._deps.storage.getItem(CLIENT_BOUND_STORAGE_KEY, scope)) return true;
+		} catch {}
+		return false;
+	}
 	async init() {
 		this._user$.next(new User(this._deps.http));
 		if (!this._options.skipConnection) await this.connect();
@@ -11046,6 +12103,42 @@ var SignalWire = class extends Destroyable {
 		} catch (error) {
 			logger$1.error("[SignalWire] Failed to reattach calls:", error);
 			this._errors$.next(error instanceof Error ? error : new Error(String(error), { cause: error }));
+		} finally {
+			this._credentialRecovered = false;
+		}
+	}
+	/**
+	* Fetch the authenticated user profile, recovering a stale credential.
+	*
+	* On a reload the persisted credential can be expired. Unlike the WS resume —
+	* which the server accepts against the persisted `authorization_state` even
+	* with an expired token — this REST preflight has no such short-circuit and is
+	* refused (401). There is no session yet to reauthenticate, so recovery
+	* re-mints the credential through the provider ({@link refreshCredentialForReconnect})
+	* and retries with a FRESH {@link User}: Fetchable memoizes its result
+	* (shareReplay), so reusing the instance would replay the 401 instead of
+	* re-fetching with the new token. Without the user id the transport/session —
+	* and the reattach a reload is trying to preserve — cannot even be addressed.
+	*/
+	async fetchUserOrRecover() {
+		const fetchUser = async (user$1) => {
+			if (!await firstValueFrom(user$1.fetched$)) throw new UnexpectedError("Failed to fetch user information - fetched$ emitted false");
+			this._deps.user = user$1;
+		};
+		const user = this._user$.value;
+		if (!user) throw new UnexpectedError("User not initialized before connect");
+		try {
+			await fetchUser(user);
+		} catch (firstError) {
+			logger$1.error(`[SignalWire] Failed to fetch user information: ${firstError instanceof Error ? firstError.message : "Unknown error"}. This usually means the user token is invalid or expired. Re-minting the credential and retrying.`);
+			try {
+				await this.refreshCredentialForReconnect();
+				const refetched = new User(this._deps.http);
+				await fetchUser(refetched);
+				this._user$.next(refetched);
+			} catch (retryError) {
+				throw new UnexpectedError("Error fetching user information", { cause: retryError });
+			}
 		}
 	}
 	/**
@@ -11087,40 +12180,23 @@ var SignalWire = class extends Destroyable {
 	*/
 	async connect() {
 		await this.teardownTransportAndSession();
-		try {
-			const user = this._user$.value;
-			if (!user) throw new UnexpectedError("User not initialized before connect");
-			if (!await firstValueFrom(user.fetched$)) throw new UnexpectedError("Failed to fetch user information - fetched$ emitted false");
-			this._deps.user = user;
-		} catch (error) {
-			logger$1.error(`[SignalWire] Failed to fetch user information: ${error instanceof Error ? error.message : "Unknown error"}. This usually means the user token is invalid or expired.`);
-			throw new UnexpectedError("Error fetching user information", { cause: error });
-		}
+		await this.fetchUserOrRecover();
 		const errorHandler = (error) => {
 			this._errors$.next(error);
 		};
 		this._transport = new TransportManager(this._deps.storage, this._deps.protocolKey, this._deps.WebSocket, PreferencesContainer.instance.relayHost ?? this._deps.relayHost, errorHandler);
-		this._attachManager = new AttachManager(this._deps.storage, this._deps.deviceController, PreferencesContainer.instance.reconnectCallsTimeout, this._deps.attachedCallsKey);
+		this._attachManager = new AttachManager(this._deps.storage, this._deps.deviceController, PreferencesContainer.instance.reconnectCallsTimeout, this._deps.attachedCallsKey, () => this._credentialRecovered);
 		this._clientSession = new ClientSessionManager(() => this._deps.credential, this._transport, this._deps.storage, this._deps.authorizationStateKey, this._deps.deviceController, this._attachManager, this._deps.webRTCApiProvider, this._dpopManager, this._networkMonitor?.networkChange$);
 		this._publicSession = new ClientSessionWrapper(this._clientSession);
-		this._clientSession.onBeforeReconnect = async () => {
-			if (!this._credentialProvider) return;
-			try {
-				const fingerprint = this._dpopManager?.initialized ? this._dpopManager.fingerprint : void 0;
-				logger$1.debug("[SignalWire] Credential expired, refreshing before reconnect");
-				const newCredentials = await this._credentialProvider.authenticate(fingerprint ? { fingerprint } : void 0);
-				this._deps.credential = newCredentials;
-				if (newCredentials.expiry_at && this._credentialProvider.refresh) this._refreshCoordinator?.scheduleDeveloperRefresh(this._credentialProvider, newCredentials.expiry_at);
-				logger$1.debug("[SignalWire] Credential refreshed successfully for reconnect");
-			} catch (error) {
-				logger$1.error("[SignalWire] Failed to refresh credentials for reconnect:", error);
-				this._errors$.next(error instanceof Error ? error : new Error(String(error), { cause: error }));
-				throw error;
-			}
-		};
+		this._clientSession.callControl = this._options.callControl ?? "routed";
+		this._clientSession.onBeforeReconnect = async () => this.refreshCredentialForReconnect();
 		this.subscribeTo(this._clientSession.errors$, (error) => {
 			this._errors$.next(error);
 		});
+		this.subscribeTo(this._clientSession.authorization$, (authorization) => {
+			this._refreshCoordinator?.syncExpiryFromAuthorization(authorization, this._credentialProvider);
+			this.persistClientBoundMarker(Boolean(authorization?.cnf?.jkt));
+		});
 		await this._clientSession.connect();
 		await this._refreshCoordinator?.activate(this._deps.user, this._clientSession);
 		this.subscribeTo(this._clientSession.authenticated$.pipe(skip(1), filter(Boolean)), async () => {
@@ -11283,6 +12359,13 @@ var SignalWire = class extends Destroyable {
 		}
 		try {
 			this._visibilityController = new VisibilityController();
+			this.subscribeTo(this._visibilityController.visibilityChange$.pipe(filter((event) => event.to === "visible")), () => {
+				try {
+					this._refreshCoordinator?.forceRefreshIfDue();
+				} catch (error) {
+					logger$1.warn("[SignalWire] Resume credential revalidation failed (non-fatal):", error);
+				}
+			});
 			this.subscribeTo(this._visibilityController.visibilityChange$.pipe(filter((event) => event.to === "visible" && PreferencesContainer.instance.refreshDevicesOnVisible)), () => {
 				logger$1.debug("[SignalWire] Page visible, re-enumerating devices");
 				try {
@@ -11294,7 +12377,7 @@ var SignalWire = class extends Destroyable {
 			logger$1.warn("[SignalWire] Failed to initialize VisibilityController:", error);
 		}
 		try {
-			this._diagnosticsCollector = new DiagnosticsCollector({ sdkVersion: "4.0.0-rc.2" });
+			this._diagnosticsCollector = new DiagnosticsCollector({ sdkVersion: "4.0.0-rc.3" });
 		} catch (error) {
 			logger$1.warn("[SignalWire] Failed to initialize DiagnosticsCollector:", error);
 		}
@@ -11365,21 +12448,22 @@ var SignalWire = class extends Destroyable {
 				this._errors$.next(error instanceof Error ? error : new Error(String(error), { cause: error }));
 				throw error;
 			}
-			logger$1.debug("[SignalWire] Failed to register user, trying reauthentication...");
-			try {
-				await this._clientSession.reauthenticate(this._deps.credential.token);
-				logger$1.debug("[SignalWire] Reauthentication successful, retrying register()");
+			logger$1.debug("[SignalWire] Failed to register user, attempting credential recovery...");
+			const outcome = await this.recoverAndRetry(async () => {
 				await this._transport.execute(RPCExecute({
 					method: "subscriber.online",
 					params: {}
 				}));
+			});
+			if (outcome.ok) {
+				logger$1.debug("[SignalWire] Recovery restored registration");
 				this._isRegistered$.next(true);
-			} catch (reauthError) {
-				logger$1.error("[SignalWire] Reauthentication failed during register():", reauthError);
-				const registerError = new InvalidCredentialsError("Failed to register user, and reauthentication attempt also failed. Please check your credentials.", { cause: reauthError instanceof Error ? reauthError : new Error(String(reauthError), { cause: reauthError }) });
-				this._errors$.next(registerError);
-				throw registerError;
+				return;
 			}
+			const failureCause = outcome.error ?? error;
+			const registerError = new InvalidCredentialsError("Failed to register user, and credential recovery also failed. Please check your credentials.", { cause: failureCause instanceof Error ? failureCause : new Error(String(failureCause), { cause: failureCause }) });
+			this._errors$.next(registerError);
+			throw registerError;
 		}
 	}
 	/**
@@ -11410,6 +12494,11 @@ var SignalWire = class extends Destroyable {
 	* Returns a {@link Call} in `'ringing'` state. Subscribe to {@link Call.status$}
 	* to track progression through `'connected'` → `'disconnected'`.
 	*
+	* Local media acquisition is deliberately unbounded: an unanswered permission
+	* prompt leaves this promise pending indefinitely, so apply your own bound if
+	* your UI needs one. The 12 s signaling budget starts only once acquisition
+	* settles.
+	*
 	* @param destination - Address URI string (e.g. `'/public/my-room'`) or {@link Address} instance.
 	* @param options - Media and dial options (audio/video, device constraints). Overrides defaults.
 	* @returns The created {@link Call} instance.
@@ -11432,7 +12521,18 @@ var SignalWire = class extends Destroyable {
 		};
 		await this.waitAuthentication();
 		logger$1.debug("[SignalWire] Dialing with options:", computed_options);
-		return this._clientSession.createOutboundCall(destination, computed_options);
+		try {
+			return await this._clientSession.createOutboundCall(destination, computed_options);
+		} catch (error) {
+			if (!isRecoverableAuthError(error)) throw error;
+			logger$1.debug("[SignalWire] Dial hit a recoverable auth error; recovering the session and retrying");
+			const outcome = await this.recoverAndRetry(async () => {
+				await this.waitAuthentication();
+				return this._clientSession.createOutboundCall(destination, computed_options);
+			});
+			if (outcome.ok) return outcome.value;
+			throw outcome.error ?? error;
+		}
 	}
 	/**
 	* Runs a multi-phase connectivity test against the given destination.
@@ -11713,10 +12813,13 @@ var SignalWire = class extends Destroyable {
 	destroy() {
 		this._refreshCoordinator?.destroy();
 		this._refreshCoordinator = void 0;
+		this._refreshHttp?.destroy();
+		this._refreshHttp = void 0;
 		this._dpopManager?.destroy();
-		this._clientSession.teardownSessionState();
-		this._transport.destroy();
-		this._clientSession.destroy();
+		const session = this._clientSession;
+		session?.teardownSessionState();
+		this._transport?.destroy();
+		session?.destroy();
 		try {
 			this._networkMonitor?.destroy();
 		} catch {}
@@ -11828,7 +12931,7 @@ var StaticCredentialProvider = class {
 /**
 * Library version from package.json, injected at build time.
 */
-const version = "4.0.0-rc.2";
+const version = "4.0.0-rc.3";
 /**
 * Flag indicating the library has been loaded and is ready to use.
 * For UMD builds: `window.SignalWire.ready`
@@ -11850,12 +12953,12 @@ const ready = true;
 */
 const emitReadyEvent = () => {
 	if (typeof window !== "undefined") {
-		const event = new CustomEvent("signalwire:js:ready", { detail: { version: "4.0.0-rc.2" } });
+		const event = new CustomEvent("signalwire:js:ready", { detail: { version: "4.0.0-rc.3" } });
 		window.dispatchEvent(event);
 	}
 };
 emitReadyEvent();
 
 //#endregion
-export { Address, CallCreateError, ClientPreferences, CollectionFetchError, DPoPInitError, DeviceTokenError, EmbedTokenCredentialProvider, InvalidCredentialsError, MediaAccessError, MediaTrackError, MessageParseError, OverconstrainedFallbackError, Participant, PreflightError, RecoveryError, SelfCapabilities, SelfParticipant, SignalWire, StaticCredentialProvider, TokenRefreshError, UnexpectedError, User, VertoPongError, WebRTCCall, embeddableCall, getLogger, isSelfParticipant, ready, setDebugOptions, setLogLevel, setLogger, version };
+export { Address, AuxiliaryLegCancelledError, AuxiliaryLegTimeoutError, CallCreateError, CallNotReadyError, ClientPreferences, CollectionFetchError, DPoPInitError, DeviceTokenError, EmbedTokenCredentialProvider, InvalidCredentialsError, MediaAccessError, MediaTrackError, MessageParseError, OverconstrainedFallbackError, Participant, ParticipantNotReadyError, PreflightError, RecoveryError, ScreenShareAlreadyActiveError, SelfCapabilities, SelfParticipant, SignalWire, StaticCredentialProvider, TokenRefreshError, UnexpectedError, User, VertoPongError, WebRTCCall, embeddableCall, getLogger, isSelfParticipant, ready, setDebugOptions, setLogLevel, setLogger, version };
 //# sourceMappingURL=index.mjs.map