@signalwire/js 4.0.0-dev-20260305000713 → 4.0.0-dev-20260310150416

package/dist/browser.mjs

@@ -6915,7 +6915,7 @@ var require_startWith = /* @__PURE__ */ __commonJSMin(((exports) => {
 	var concat_1$2 = require_concat$1();
 	var args_1$2 = require_args();
 	var lift_1$14 = require_lift();
-	function startWith() {
+	function startWith$1() {
 		var values = [];
 		for (var _i = 0; _i < arguments.length; _i++) values[_i] = arguments[_i];
 		var scheduler = args_1$2.popScheduler(values);
@@ -6923,7 +6923,7 @@ var require_startWith = /* @__PURE__ */ __commonJSMin(((exports) => {
 			(scheduler ? concat_1$2.concat(values, source, scheduler) : concat_1$2.concat(values, source)).subscribe(subscriber);
 		});
 	}
-	exports.startWith = startWith;
+	exports.startWith = startWith$1;
 }));
 
 //#endregion
@@ -9122,6 +9122,15 @@ var JSONRPCError = class extends Error {
 		this.name = "JSONRPCError";
 	}
 };
+var RPCError = class extends Error {
+	constructor(code, requestId, message, data, options) {
+		super(message, options);
+		this.code = code;
+		this.requestId = requestId;
+		this.data = data;
+		this.name = "RPCError";
+	}
+};
 var InvalidParams = class extends Error {
 	constructor(message, options) {
 		super(message, options);
@@ -9660,7 +9669,7 @@ var PreferencesContainer = class PreferencesContainer {
 			skipDeviceMonitoring: false,
 			savePreferences: false
 		};
-		this.receiveVideo = true;
+		this.receiveVideo = false;
 		this.receiveAudio = true;
 		this.preferredAudioInput = null;
 		this.preferredAudioOutput = null;
@@ -12630,12 +12639,53 @@ var CallEventsManager = class extends Destroyable {
 
 //#endregion
 //#region src/helpers/SDPHelper.ts
+/** Valid SDP direction attribute values. */
+const SDP_DIRECTIONS = new Set([
+	"sendrecv",
+	"sendonly",
+	"recvonly",
+	"inactive"
+]);
 /**
-* SDPHelper - Utility functions for SDP (Session Description Protocol) parsing and validation.
+* Extracts the media directions (audio/video) from an SDP string.
+*
+* Parses each media section (`m=audio` / `m=video`) and reads the `a=` direction
+* attribute (`sendrecv`, `sendonly`, `recvonly`, `inactive`).
+* If no explicit direction attribute is found for a media section, defaults to `sendrecv`
+* per RFC 4566.
+*
+* @param sdp - The SDP string to parse
+* @returns The extracted audio and video directions
 *
-* This module provides helper functions to analyze and validate SDP content,
-* particularly for ICE candidate validation in WebRTC connections.
+* @example
+* ```typescript
+* const sdp = `v=0\r\nm=audio 9 UDP/TLS/RTP/SAVPF 111\r\na=sendrecv\r\nm=video 9 UDP/TLS/RTP/SAVPF 96\r\na=recvonly`;
+* extractMediaDirectionsFromSDP(sdp);
+* // { audio: 'sendrecv', video: 'recvonly' }
+* ```
 */
+function extractMediaDirectionsFromSDP(sdp) {
+	const result = {
+		audio: "inactive",
+		video: "inactive"
+	};
+	if (!sdp) return result;
+	const lines = sdp.split(/\r?\n/);
+	let currentMediaKind = null;
+	let currentDirection = null;
+	for (const line of lines) if (line.startsWith("m=")) {
+		if (currentMediaKind) result[currentMediaKind] = currentDirection ?? "sendrecv";
+		if (line.startsWith("m=audio")) currentMediaKind = "audio";
+		else if (line.startsWith("m=video")) currentMediaKind = "video";
+		else currentMediaKind = null;
+		currentDirection = null;
+	} else if (currentMediaKind && line.startsWith("a=")) {
+		const attr = line.substring(2).trim();
+		if (SDP_DIRECTIONS.has(attr)) currentDirection = attr;
+	}
+	if (currentMediaKind) result[currentMediaKind] = currentDirection ?? "sendrecv";
+	return result;
+}
 /**
 * Validates that an SDP string has at least one non-host ICE candidate
 * for each media section (m= line).
@@ -12938,6 +12988,15 @@ var LocalStreamController = class extends Destroyable {
 		track.addEventListener("ended", this.mediaTrackEndedHandler);
 	}
 	/**
+	* Update the controller options (e.g., when media overrides are applied).
+	*/
+	updateOptions(options) {
+		this.options = {
+			...this.options,
+			...options
+		};
+	}
+	/**
 	* Stop all local tracks and clean up.
 	*/
 	stopAllTracks() {
@@ -13281,6 +13340,7 @@ var RTCPeerConnectionController = class extends Destroyable {
 		this._initialized$ = this.createReplaySubject(1);
 		this._remoteDescription$ = this.createReplaySubject(1);
 		this._remoteStream$ = this.createBehaviorSubject(null);
+		this._remoteOfferMediaDirections = null;
 		this.deviceController = deviceController ?? {};
 		this.id = options.callId ?? v4_default();
 		this._type = remoteSessionDescription ? "answer" : "offer";
@@ -13288,10 +13348,19 @@ var RTCPeerConnectionController = class extends Destroyable {
 			type: "offer",
 			sdp: remoteSessionDescription
 		} : void 0;
+		this._remoteOfferMediaDirections = remoteSessionDescription ? extractMediaDirectionsFromSDP(remoteSessionDescription) : null;
+		const offerDefaults = this._remoteOfferMediaDirections ? {
+			audio: this._remoteOfferMediaDirections.audio.includes("recv"),
+			video: this._remoteOfferMediaDirections.video.includes("recv"),
+			receiveAudio: this._remoteOfferMediaDirections.audio.includes("send"),
+			receiveVideo: this._remoteOfferMediaDirections.video.includes("send")
+		} : {};
 		this.options = {
-			receiveAudio: options.receiveAudio ?? PreferencesContainer.instance.receiveAudio,
-			receiveVideo: options.receiveVideo ?? PreferencesContainer.instance.receiveVideo,
-			...options
+			...options,
+			audio: options.audio ?? offerDefaults.audio,
+			video: options.video ?? offerDefaults.video,
+			receiveAudio: options.receiveAudio ?? offerDefaults.receiveAudio ?? PreferencesContainer.instance.receiveAudio,
+			receiveVideo: options.receiveVideo ?? offerDefaults.receiveVideo ?? PreferencesContainer.instance.receiveVideo
 		};
 		this.localStreamController = new LocalStreamController({
 			propose: this.propose,
@@ -13458,12 +13527,12 @@ var RTCPeerConnectionController = class extends Destroyable {
 			default: return {
 				...options,
 				offerToReceiveAudio: true,
-				offerToReceiveVideo: Boolean(this.inputVideoDeviceConstraints)
+				offerToReceiveVideo: this.options.receiveVideo ?? Boolean(this.inputVideoDeviceConstraints)
 			};
 		}
 	}
 	get answerOptions() {
-		return {};
+		return { iceRestart: this.firstSDPExchangeCompleted ? true : void 0 };
 	}
 	/**
 	* Initialize the RTCPeerConnection and setup event listeners.
@@ -13498,11 +13567,15 @@ var RTCPeerConnectionController = class extends Destroyable {
 				});
 				await this.updateSelectedInputDevice(kind, deviceInfo);
 			});
-			await this.setupTrackHandling();
-			this._initialized$.next(true);
 			if (this.type === "answer" && this.sdpInit) {
+				await this.setupRemoteTracks();
+				this._initialized$.next(true);
 				this.setupEventListeners();
-				await this.handleOfferReceived();
+				this._isNegotiating$.next(true);
+				await this._setRemoteDescription(this.sdpInit);
+			} else {
+				await this.setupTrackHandling();
+				this._initialized$.next(true);
 			}
 		} catch (error) {
 			logger$11.error("[RTCPeerConnectionController] Initialization error:", error);
@@ -13600,6 +13673,35 @@ var RTCPeerConnectionController = class extends Destroyable {
 			default:
 		}
 	}
+	/**
+	* Accept an inbound call by creating the SDP answer.
+	* Optionally override media options before the answer is generated.
+	* Must be called after initialization for inbound (answer-type) connections.
+	*/
+	async acceptInbound(mediaOverrides) {
+		if (mediaOverrides) {
+			const { audio, video, receiveAudio, receiveVideo } = mediaOverrides;
+			this.options = {
+				...this.options,
+				...audio !== void 0 ? { audio } : {},
+				...video !== void 0 ? { video } : {},
+				...receiveAudio !== void 0 ? { receiveAudio } : {},
+				...receiveVideo !== void 0 ? { receiveVideo } : {}
+			};
+			this.transceiverController?.updateOptions({
+				receiveAudio: this.receiveAudio,
+				receiveVideo: this.receiveVideo
+			});
+			this.localStreamController.updateOptions({
+				inputAudioDeviceConstraints: this.inputAudioDeviceConstraints,
+				inputVideoDeviceConstraints: this.inputVideoDeviceConstraints
+			});
+		}
+		await this.setupLocalTracks();
+		const { answerOptions } = this;
+		logger$11.debug("[RTCPeerConnectionController] Creating inbound answer with options:", answerOptions);
+		await this.createAnswer(answerOptions);
+	}
 	async handleOfferReceived() {
 		if (!this.sdpInit) throw new DependencyError("SDP initialization parameters are not set");
 		this._isNegotiating$.next(true);
@@ -13820,7 +13922,7 @@ var RTCPeerConnectionController = class extends Destroyable {
 		});
 	}
 	get mediaDirections() {
-		return this.transceiverController?.getMediaDirections() ?? {
+		return this.transceiverController?.getMediaDirections() ?? this._remoteOfferMediaDirections ?? {
 			audio: "inactive",
 			video: "inactive"
 		};
@@ -14151,6 +14253,36 @@ var WebRTCVertoManager = class extends VertoManager {
 		this.subscribeTo(rtcPeerConnController.errors$, (error) => {
 			this.onError?.(error);
 		});
+		if (options.initOffer) this.handleInboundAnswer(rtcPeerConnController);
+	}
+	async handleInboundAnswer(rtcPeerConnController) {
+		logger$10.debug("[WebRTCManager] Waiting for inbound call to be accepted or rejected");
+		const vertoByeOrAccepted = await (0, import_cjs$10.firstValueFrom)((0, import_cjs$10.race)(this.vertoBye$, this.webRtcCallSession.answered$).pipe((0, import_cjs$10.takeUntil)(this.destroyed$))).catch(() => null);
+		if (vertoByeOrAccepted === null) {
+			logger$10.debug("[WebRTCManager] Inbound answer handler aborted (destroyed).");
+			return;
+		}
+		if (isVertoByeMessage(vertoByeOrAccepted)) {
+			logger$10.info("[WebRTCManager] Inbound call ended by remote before answer.");
+			this.callSession?.destroy();
+		} else if (!vertoByeOrAccepted) {
+			logger$10.info("[WebRTCManager] Inbound call rejected by user.");
+			try {
+				await this.bye("USER_BUSY");
+			} finally {
+				this._signalingStatus$.next("disconnected");
+				this.callSession?.destroy();
+			}
+		} else {
+			logger$10.debug("[WebRTCManager] Inbound call accepted, creating SDP answer");
+			const answerOptions = this.webRtcCallSession.answerMediaOptions;
+			try {
+				await rtcPeerConnController.acceptInbound(answerOptions);
+			} catch (error) {
+				logger$10.error("[WebRTCManager] Error creating inbound answer:", error);
+				this.onError?.(error instanceof Error ? error : new Error(String(error), { cause: error }));
+			}
+		}
 	}
 	setupVertoAttachHandler() {
 		this.subscribeTo(this.vertoAttach$, async (vertoAttach) => {
@@ -14168,7 +14300,7 @@ var WebRTCVertoManager = class extends VertoManager {
 		});
 	}
 	initObservables(rtcPeerConnController) {
-		this.mediaDirections$ = rtcPeerConnController.connectionState$.pipe((0, import_cjs$10.filter)((state) => state === "connected"), (0, import_cjs$10.takeUntil)(this.destroyed$), (0, import_cjs$10.map)(() => rtcPeerConnController.mediaDirections));
+		this.mediaDirections$ = rtcPeerConnController.connectionState$.pipe((0, import_cjs$10.filter)((state) => state === "connected"), (0, import_cjs$10.map)(() => rtcPeerConnController.mediaDirections), (0, import_cjs$10.startWith)(rtcPeerConnController.mediaDirections), (0, import_cjs$10.takeUntil)(this.destroyed$));
 		this.localStream$ = rtcPeerConnController.localStream$.pipe(filterNull(), (0, import_cjs$10.takeUntil)(this.destroyed$));
 		this.remoteStream$ = rtcPeerConnController.remoteStream$.pipe(filterNull(), (0, import_cjs$10.takeUntil)(this.destroyed$));
 	}
@@ -14850,10 +14982,15 @@ var WebRTCCall = class extends Destroyable {
 	async sendDigits(dtmf) {
 		return this.vertoManager.sendDigits(dtmf);
 	}
-	/** Accepts an inbound call. */
-	answer() {
+	/** Accepts an inbound call, optionally overriding media options for the answer. */
+	answer(options) {
+		this._answerMediaOptions = options;
 		this._answered$.next(true);
 	}
+	/** Media options provided when answering. Used internally by the VertoManager. */
+	get answerMediaOptions() {
+		return this._answerMediaOptions;
+	}
 	/** Rejects an inbound call. */
 	reject() {
 		this._answered$.next(false);
@@ -15292,9 +15429,15 @@ var PendingRPC = class PendingRPC {
 				return () => signal.removeEventListener("abort", abortHandler);
 			}) : import_cjs$6.NEVER).subscribe({
 				next: (response) => {
-					logger$7.debug(`[PendingRPC(${this.id}) request:${request.id}] Resolving promise with response:`, response);
 					isSettled = true;
-					resolve(response);
+					if (response.error) {
+						const rpcError = new RPCError(response.error.code, request.id, response.error.message, response.error.data);
+						logger$7.debug(`[PendingRPC(${this.id}) request:${request.id}] Rejecting promise with RPC error:`, rpcError);
+						reject(rpcError);
+					} else {
+						logger$7.debug(`[PendingRPC(${this.id}) request:${request.id}] Resolving promise with response:`, response);
+						resolve(response);
+					}
 					subscription.unsubscribe();
 				},
 				error: (error) => {
@@ -16343,7 +16486,12 @@ var SignalWire = class extends Destroyable {
 		this._subscriber$.next(new Subscriber(this._deps.http));
 		if (!this._options.skipConnection) await this.connect();
 		if (!this._options.reconnectAttachedCalls && this._attachManager) await this._attachManager.flush();
-		if (!this._options.skipRegister) this.register();
+		if (!this._options.skipRegister) try {
+			await this.register();
+		} catch (error) {
+			logger$1.error("[SignalWire] Registration failed:", error);
+			this._errors$.next(error instanceof Error ? error : new Error(String(error), { cause: error }));
+		}
 		this.handleAttachments();
 	}
 	async handleAttachments() {
@@ -16506,8 +16654,22 @@ var SignalWire = class extends Destroyable {
 			}));
 			this._isRegistered$.next(true);
 		} catch (error) {
-			logger$1.error("[SignalWire] Failed to register subscriber:", 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 () => {
+				logger$1.debug("[SignalWire] Reauthentication successful, retrying register()");
+				await this._transport.execute(RPCExecute({
+					method: "subscriber.online",
+					params: {}
+				}));
+				this._isRegistered$.next(true);
+			}).catch((reauthError) => {
+				logger$1.error("[SignalWire] Reauthentication failed during register():", reauthError);
+				const registerError = new 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);
+				throw registerError;
+			});
 			this._errors$.next(error instanceof Error ? error : new Error(String(error), { cause: error }));
+			throw error;
 		}
 	}
 	/** Unregisters the subscriber, going offline for inbound calls. */