@signalwire/js 4.0.0-dev-20260420151734 → 4.0.0-dev-20260421201955

package/dist/index.cjs

@@ -143,7 +143,7 @@ const POST_PARAMS = {
 		"Content-Type": "application/json"
 	}
 };
-var HTTPRequestController = class HTTPRequestController {
+var HTTPRequestController = class HTTPRequestController extends Destroyable {
 	static {
 		this.defaultMaxRetries = 3;
 	}
@@ -164,11 +164,12 @@ var HTTPRequestController = class HTTPRequestController {
 		]);
 	}
 	constructor(baseURL, getCredential, options = {}) {
+		super();
 		this.baseURL = baseURL;
 		this.getCredential = getCredential;
-		this._responses$ = new rxjs.Subject();
-		this._errors$ = new rxjs.Subject();
-		this._status$ = new rxjs.BehaviorSubject("idle");
+		this._responses$ = this.createSubject();
+		this._errors$ = this.createSubject();
+		this._status$ = this.createBehaviorSubject("idle");
 		this.maxRetries = options.maxRetries ?? HTTPRequestController.defaultMaxRetries;
 		this.retryDelayMin = options.retryDelayMin ?? HTTPRequestController.defaultRetryDelayMinMs;
 		this.retryDelayMax = options.retryDelayMax ?? HTTPRequestController.defaultRetryDelayMaxMs;
@@ -478,6 +479,12 @@ const DEFAULT_ICE_DISCONNECTED_GRACE_PERIOD_MS = 3e3;
 const DEFAULT_ICE_RESTART_TIMEOUT_MS$1 = 5e3;
 /** Maximum recovery attempts before emitting 'max_attempts_reached'. */
 const DEFAULT_MAX_RECOVERY_ATTEMPTS = 3;
+/** Upper bound in ms for waiting on iceGatheringState === 'complete' after an ICE restart. */
+const ICE_GATHERING_COMPLETE_TIMEOUT_MS = 1e4;
+/** Upper bound in ms for waiting on RTCPeerConnection.connectionState === 'connected' after a recovery ICE restart. */
+const PEER_CONNECTION_RECOVERY_WAIT_MS = 5e3;
+/** Polling interval in ms while waiting for RTCPeerConnection.connectionState to transition. */
+const PEER_CONNECTION_RECOVERY_POLL_MS = 100;
 /** Whether to persist device selections to storage by default. */
 const DEFAULT_PERSIST_DEVICE_SELECTION = true;
 /** Whether to auto-apply device changes to active calls by default. */
@@ -2428,7 +2435,7 @@ var PreflightRunner = class extends Destroyable {
 			const candidateTypes = /* @__PURE__ */ new Set();
 			const startTime = Date.now();
 			const gatheringComplete = new Promise((resolve) => {
-				const timer$2 = setTimeout(resolve, ICE_GATHERING_TIMEOUT_MS);
+				const timer$3 = setTimeout(resolve, ICE_GATHERING_TIMEOUT_MS);
 				peerConnection.onicecandidate = (event) => {
 					if (event.candidate) {
 						const candidateStr = event.candidate.candidate;
@@ -2436,7 +2443,7 @@ var PreflightRunner = class extends Destroyable {
 						if (candidateStr.includes("typ srflx")) candidateTypes.add("srflx");
 						if (candidateStr.includes("typ relay")) candidateTypes.add("relay");
 					} else {
-						clearTimeout(timer$2);
+						clearTimeout(timer$3);
 						resolve();
 					}
 				};
@@ -2797,13 +2804,11 @@ var AttachManager = class {
 		this.deviceController = deviceController;
 		this.reconnectCallsTimeout = reconnectCallsTimeout;
 		this.attachKey = attachKey;
+		this.writeQueue = Promise.resolve();
 	}
 	async detachAll() {
-		const attached = await this.readAttached();
-		for (const callId of Object.keys(attached)) await this.detach({
-			id: callId,
-			nodeId: attached[callId].nodeId,
-			mediaDirections: attached[callId].mediaDirections
+		await this.mutate((attached) => {
+			return {};
 		});
 	}
 	setSession(session) {
@@ -2824,31 +2829,47 @@ var AttachManager = class {
 			logger$21.warn("[AttachManager] Failed to write attached calls to storage", error);
 		}
 	}
+	/**
+	* Serialize a read-modify-write operation against the attached-calls
+	* storage. The mutator receives the current state and returns the new
+	* state. Concurrent calls queue behind the in-flight one so writes never
+	* interleave.
+	*/
+	async mutate(mutator) {
+		const next = this.writeQueue.then(async () => {
+			const updated = await mutator(await this.readAttached());
+			await this.writeAttached(updated);
+		});
+		this.writeQueue = next.catch(() => void 0);
+		return next;
+	}
 	async attach(call) {
 		if (!call.to) {
 			logger$21.warn("[AttachManager] Skip attach for calls with no destination");
 			return;
 		}
+		const destination = call.to;
 		const attachment = {
 			nodeId: call.nodeId,
-			destination: call.to,
+			destination,
 			mediaDirections: call.mediaDirections,
 			audioInputDevice: call.mediaDirections.audio !== "inactive" ? this.deviceController.selectedAudioInputDevice : null,
 			videoInputDevice: call.mediaDirections.video !== "inactive" ? this.deviceController.selectedVideoInputDevice : null,
 			attachedAt: Date.now()
 		};
-		const updated = {
-			...await this.readAttached(),
+		await this.mutate((attached) => ({
+			...attached,
 			[call.id]: attachment
-		};
-		await this.writeAttached(updated);
+		}));
 	}
 	async detach(call) {
-		const { [call.id]: _, ...remaining } = await this.readAttached();
-		await this.writeAttached(remaining);
+		await this.mutate((attached) => {
+			const { [call.id]: _, ...remaining } = attached;
+			return remaining;
+		});
 	}
 	async flush() {
-		await this.writeAttached({});
+		await this.mutate(() => ({}));
 	}
 	/**
 	* Reattach to previously active calls by sending verto.invite with
@@ -2920,20 +2941,31 @@ var AttachManager = class {
 		};
 	}
 	/**
-	* Consume stored attachment data for a pending call (used by session-level
-	* verto.attach handler as a future path when server supports it).
+	* Look up stored attachment data for a call id and return CallOptions
+	* suitable for rehydrating a reattached call. Returns undefined when no
+	* matching entry exists in storage.
+	*
+	* Used by the session-level verto.attach handler when the server pushes
+	* an attach event for a call the client doesn't have an object for yet
+	* (e.g. after a reload).
 	*/
-	consumePendingAttachment(_callId) {}
+	async consumePendingAttachment(callId) {
+		const attachment = (await this.readAttached())[callId];
+		if (!attachment) return;
+		return this.buildCallOptions(attachment);
+	}
 	async detachExpired() {
-		const attached = await this.readAttached();
 		const now = Date.now();
 		const timeout$4 = this.reconnectCallsTimeout;
-		const expired = Object.entries(attached).filter(([, attachment]) => now - attachment.attachedAt > timeout$4);
-		if (expired.length > 0) {
+		await this.mutate((attached) => {
 			const remaining = { ...attached };
-			for (const [callId] of expired) delete remaining[callId];
-			await this.writeAttached(remaining);
-		}
+			let changed = false;
+			for (const [callId, attachment] of Object.entries(attached)) if (now - attachment.attachedAt > timeout$4) {
+				delete remaining[callId];
+				changed = true;
+			}
+			return changed ? remaining : attached;
+		});
 	}
 };
 
@@ -4401,12 +4433,12 @@ var ICEGatheringController = class extends Destroyable {
 			...this.peerConnection.getConfiguration(),
 			iceTransportPolicy: "relay"
 		});
-		if (!(this.peerConnection.connectionState === "connected")) this.peerConnection.restartIce();
+		this.peerConnection.restartIce();
 	}
-	removeTimer(timer$2) {
-		if (this[timer$2]) {
-			clearTimeout(this[timer$2]);
-			this[timer$2] = void 0;
+	removeTimer(timer$3) {
+		if (this[timer$3]) {
+			clearTimeout(this[timer$3]);
+			this[timer$3] = void 0;
 		}
 	}
 	clearAllTimers() {
@@ -5370,9 +5402,6 @@ var RTCPeerConnectionController = class extends Destroyable {
 	negotiationEnded() {
 		this._isNegotiating$.next(false);
 	}
-	restarIce() {
-		this.peerConnection?.restartIce();
-	}
 	/**
 	* Trigger an ICE restart through the existing negotiation pipeline.
 	*
@@ -5412,7 +5441,10 @@ var RTCPeerConnectionController = class extends Destroyable {
 			if (policyChanged) this.restoreIceTransportPolicy();
 			throw error;
 		}
-		if (policyChanged) this.restoreIceTransportPolicy();
+		if (policyChanged) (0, rxjs.firstValueFrom)((0, rxjs.race)(this._iceGatheringState$.pipe((0, rxjs.filter)((state) => state === "complete"), (0, rxjs.take)(1)), (0, rxjs.timer)(ICE_GATHERING_COMPLETE_TIMEOUT_MS).pipe((0, rxjs.map)(() => "timeout")))).then(() => this.restoreIceTransportPolicy()).catch((error) => {
+			logger$15.warn("[RTCPeerConnectionController] Error waiting for ICE gathering to complete:", error);
+			this.restoreIceTransportPolicy();
+		});
 	}
 	restoreIceTransportPolicy() {
 		try {
@@ -6584,11 +6616,11 @@ var RTCStatsMonitor = class extends Destroyable {
 		let availableOutgoingBitrate;
 		report.forEach((stat) => {
 			if (isInboundRtpStat(stat)) if (stat.kind === "audio") {
-				audioPacketsReceived += stat.packetsReceived ?? this.lastAudioPacketsReceived;
+				audioPacketsReceived += stat.packetsReceived ?? 0;
 				audioPacketsLost += stat.packetsLost ?? 0;
 				audioJitter = Math.max(audioJitter, (stat.jitter ?? 0) * 1e3);
 			} else {
-				videoPacketsReceived += stat.packetsReceived ?? this.lastVideoPacketsReceived;
+				videoPacketsReceived += stat.packetsReceived ?? 0;
 				videoPacketsLost += stat.packetsLost ?? 0;
 			}
 			if (isCandidatePairStat(stat) && stat.state === "succeeded" && stat.nominated) {
@@ -7636,10 +7668,10 @@ var WebRTCCall = class extends Destroyable {
 					try {
 						if (this.vertoManager.requestIceRestartAll) await this.vertoManager.requestIceRestartAll(relayOnly);
 						else await this.vertoManager.requestIceRestart?.(relayOnly);
-						return true;
 					} catch {
 						return false;
 					}
+					return this.waitForPeerConnectionConnected();
 				},
 				disableVideo: () => {
 					try {
@@ -7731,6 +7763,27 @@ var WebRTCCall = class extends Destroyable {
 		}
 	}
 	/**
+	* Wait for the underlying RTCPeerConnection to reach 'connected' after
+	* triggering an ICE restart. Resolves true on success, false on failure
+	* or if the state doesn't transition within the configured timeout.
+	*
+	* Polls connectionState directly because the recovery manager already
+	* wraps this call in its own withTimeout(); a separate listener-based
+	* implementation would race the outer timeout in subtle ways.
+	*/
+	async waitForPeerConnectionConnected() {
+		const pc = this.rtcPeerConnection;
+		if (!pc) return false;
+		const deadline = Date.now() + PEER_CONNECTION_RECOVERY_WAIT_MS;
+		while (true) {
+			const state = pc.connectionState;
+			if (state === "connected") return true;
+			if (state === "failed" || state === "closed") return false;
+			if (Date.now() >= deadline) return false;
+			await new Promise((resolve) => setTimeout(resolve, PEER_CONNECTION_RECOVERY_POLL_MS));
+		}
+	}
+	/**
 	* @internal Stop and destroy resilience subsystems (on disconnect/destroy).
 	* Clears references so they can be re-created on reconnect.
 	*/
@@ -7867,8 +7920,13 @@ var WebRTCCall = class extends Destroyable {
 		const cached = this._customSubscriptions.get(eventType);
 		if (cached) return cached;
 		const filtered$ = this.callSessionEvents$.pipe((0, rxjs.filter)((event) => event.event_type === eventType), (0, rxjs.map)((event) => JSON.parse(JSON.stringify(event))), (0, rxjs.takeUntil)(this._destroyed$));
+		this._sendVertoSubscribe(eventType).then(() => {
+			this._customSubscriptions.set(eventType, filtered$);
+		}, (error) => {
+			this._customSubscriptions.delete(eventType);
+			logger$11.warn(`[Call] verto.subscribe for '${eventType}' failed, not caching:`, error);
+		});
 		this._customSubscriptions.set(eventType, filtered$);
-		this._sendVertoSubscribe(eventType);
 		return filtered$;
 	}
 	get webrtcMessages$() {
@@ -7994,26 +8052,21 @@ var WebRTCCall = class extends Destroyable {
 	}
 	/**
 	* @internal Send a verto.subscribe message to add an event type to the
-	* server's subscription list for this call. Best-effort — failures are
-	* logged but don't prevent the filtered observable from being returned.
-	*/
-	_sendVertoSubscribe(eventType) {
-		try {
-			const message = VertoSubscribe({
-				sessid: this.id,
-				eventChannel: [eventType]
-			});
-			const params = {
-				callID: this.id,
-				node_id: this.vertoManager.nodeId ?? "",
-				message
-			};
-			this.clientSession.execute(WebrtcVerto(params)).catch((error) => {
-				logger$11.warn(`[Call] verto.subscribe for '${eventType}' failed (non-fatal):`, error);
-			});
-		} catch (error) {
-			logger$11.warn(`[Call] Failed to send verto.subscribe for '${eventType}':`, error);
-		}
+	* server's subscription list for this call. Returns the underlying RPC
+	* promise so callers can decide whether to cache the observable on success
+	* or retry on failure.
+	*/
+	async _sendVertoSubscribe(eventType) {
+		const message = VertoSubscribe({
+			sessid: this.id,
+			eventChannel: [eventType]
+		});
+		const params = {
+			callID: this.id,
+			node_id: this.vertoManager.nodeId ?? "",
+			message
+		};
+		await this.clientSession.execute(WebrtcVerto(params));
 	}
 };
 
@@ -8030,11 +8083,21 @@ function inferCallErrorKind(error) {
 	if (error instanceof require_operators.WebSocketConnectionError || error instanceof require_operators.TransportConnectionError) return "network";
 	return "internal";
 }
+/** JSON-RPC error codes that ClientSessionManager treats as recoverable at the
+* session level. Surfacing one of these against an in-flight call should not
+* destroy the call, because the session will reauthenticate and any pending
+* RPC can then be retried. */
+const RECOVERABLE_RPC_CODES = new Set([
+	RPC_ERROR_REQUESTER_VALIDATION_FAILED,
+	RPC_ERROR_AUTHENTICATION_FAILED,
+	RPC_ERROR_INVALID_PARAMS
+]);
 /** Determines whether an error should be fatal (destroy the call). */
 function isFatalError(error) {
 	if (error instanceof require_operators.VertoPongError) return false;
 	if (error instanceof require_operators.MediaTrackError) return false;
 	if (error instanceof require_operators.RPCTimeoutError) return false;
+	if (error instanceof require_operators.JSONRPCError && RECOVERABLE_RPC_CODES.has(error.code)) return false;
 	return true;
 }
 /**
@@ -8469,10 +8532,10 @@ var PendingRPC = class PendingRPC {
 			}
 			let isSettled = false;
 			const subscription = (0, rxjs.race)(responses$.pipe((0, rxjs.filter)((result) => result.id === request.id), (0, rxjs.take)(1)), new rxjs.Observable((subscriber) => {
-				const timer$2 = setTimeout(() => {
+				const timer$3 = setTimeout(() => {
 					subscriber.error(new require_operators.RPCTimeoutError(request.id, timeoutMs));
 				}, timeoutMs);
-				return () => clearTimeout(timer$2);
+				return () => clearTimeout(timer$3);
 			}), signal ? new rxjs.Observable((subscriber) => {
 				const abortHandler = () => {
 					subscriber.error(new DOMException("The operation was aborted", "AbortError"));
@@ -8537,7 +8600,7 @@ var ClientSessionManager = class extends Destroyable {
 		this.attachManager = attachManager;
 		this.dpopManager = dpopManager;
 		this.callCreateTimeout = 6e3;
-		this.agent = `signalwire-typescript-sdk/1.0.0`;
+		this.agent = `signalwire-js/4.0.0`;
 		this.eventAcks = true;
 		this.authorizationState$ = this.createReplaySubject(1);
 		this.connectVersion = {
@@ -8871,7 +8934,6 @@ var ClientSessionManager = class extends Destroyable {
 			displayDirection: invite.display_direction,
 			userVariables: invite.userVariables
 		});
-		await (0, rxjs.firstValueFrom)(callSession.status$);
 		this._calls$.next({
 			[`${callSession.id}`]: callSession,
 			...this._calls$.value
@@ -8892,7 +8954,7 @@ var ClientSessionManager = class extends Destroyable {
 			logger$8.debug(`[Session] Verto attach for existing call ${callID}, deferring to per-call handler`);
 			return;
 		}
-		const storedOptions = this.attachManager.consumePendingAttachment(callID);
+		const storedOptions = await this.attachManager.consumePendingAttachment(callID);
 		logger$8.debug(`[Session] Creating reattached call for callID: ${callID}`);
 		const callSession = await this.createCall({
 			nodeId: attach.node_id,
@@ -8904,7 +8966,6 @@ var ClientSessionManager = class extends Destroyable {
 			reattach: true,
 			...storedOptions
 		});
-		await (0, rxjs.firstValueFrom)(callSession.status$);
 		this._calls$.next({
 			[`${callSession.id}`]: callSession,
 			...this._calls$.value
@@ -9623,10 +9684,9 @@ var WebSocketController = class WebSocketController extends Destroyable {
 		else this._status$.next("disconnected");
 	}
 	reconnect() {
-		if (this.shouldReconnect) {
-			this._status$.next("reconnecting");
-			this.scheduleReconnection();
-		} else this._status$.next("disconnected");
+		this.shouldReconnect = true;
+		this._status$.next("reconnecting");
+		this.scheduleReconnection();
 	}
 	send(data) {
 		if (this._status$.value === "connected" && this.socket?.readyState === 1) {
@@ -10185,6 +10245,7 @@ var SignalWire = class extends Destroyable {
 	* `'reconnecting'`, `'disconnecting'`, or `'disconnected'`.
 	*/
 	async connect() {
+		await this.teardownTransportAndSession();
 		try {
 			const subscriber = this._subscriber$.value;
 			if (!subscriber) throw new require_operators.UnexpectedError("Subscriber not initialized before connect");
@@ -10416,10 +10477,30 @@ var SignalWire = class extends Destroyable {
 			this._refreshTimerId = void 0;
 		}
 		this._diagnosticsCollector?.record("connection", "disconnected");
-		await this._clientSession.disconnect();
-		this._clientSession.destroy();
+		await this.teardownTransportAndSession();
 		this._isConnected$.next(false);
 	}
+	/**
+	* Tear down the current transport / session / attach manager. Safe to call
+	* when nothing has been initialized yet (e.g. first connect()).
+	*/
+	async teardownTransportAndSession() {
+		const session = this._clientSession;
+		const transport = this._transport;
+		if (session) {
+			try {
+				await session.disconnect();
+			} catch (error) {
+				logger$1.warn("[SignalWire] Error disconnecting previous session:", error);
+			}
+			session.destroy();
+		}
+		if (transport) transport.destroy();
+		this._clientSession = void 0;
+		this._publicSession = void 0;
+		this._transport = void 0;
+		this._attachManager = void 0;
+	}
 	async waitAuthentication() {
 		await (0, rxjs.firstValueFrom)(this.ready$.pipe((0, rxjs.filter)((ready$1) => ready$1 === true)));
 	}
@@ -10439,22 +10520,27 @@ var SignalWire = class extends Destroyable {
 				params: {}
 			}));
 			this._isRegistered$.next(true);
+			return;
 		} catch (error) {
+			if (!this._deps.credential.token) {
+				this._errors$.next(error instanceof Error ? error : new Error(String(error), { cause: error }));
+				throw error;
+			}
 			logger$1.debug("[SignalWire] Failed to register subscriber, trying reauthentication...");
-			if (this._deps.credential.token) this._clientSession.reauthenticate(this._deps.credential.token).then(async () => {
+			try {
+				await this._clientSession.reauthenticate(this._deps.credential.token);
 				logger$1.debug("[SignalWire] Reauthentication successful, retrying register()");
 				await this._transport.execute(RPCExecute({
 					method: "subscriber.online",
 					params: {}
 				}));
 				this._isRegistered$.next(true);
-			}).catch((reauthError) => {
+			} catch (reauthError) {
 				logger$1.error("[SignalWire] Reauthentication failed during register():", reauthError);
 				const registerError = new require_operators.InvalidCredentialsError("Failed to register subscriber, and reauthentication attempt also failed. Please check your credentials.", { cause: reauthError instanceof Error ? reauthError : new Error(String(reauthError), { cause: reauthError }) });
 				this._errors$.next(registerError);
-			});
-			this._errors$.next(error instanceof Error ? error : new Error(String(error), { cause: error }));
-			throw error;
+				throw registerError;
+			}
 		}
 	}
 	/**