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

package/dist/index.cjs

@@ -1,4 +1,4 @@
-const require_operators = require('./operators-BJ6QW1VP.cjs');
+const require_operators = require('./operators-IoitK-As.cjs');
 let jwt_decode = require("jwt-decode");
 let rxjs = require("rxjs");
 let uuid = require("uuid");
@@ -2589,6 +2589,12 @@ const RPCReauthenticate = (params) => {
 
 //#endregion
 //#region src/core/RPCMessages/RPCPing.ts
+const RPCPing = () => {
+	return buildRPCRequest({
+		method: "signalwire.ping",
+		params: { timestamp: Date.now() / 1e3 }
+	});
+};
 const RPCPingResponse = (id, timestamp) => {
 	return makeRPCResponse({
 		id,
@@ -6451,6 +6457,7 @@ var WebRTCVertoManager = class extends VertoManager {
 		this._signalingStatus$ = this.createReplaySubject(1);
 		this._screenShareStatus$ = this.createBehaviorSubject("none");
 		this._rtcPeerConnectionsMap = /* @__PURE__ */ new Map();
+		this._lastVertoPings = /* @__PURE__ */ new Map();
 		this._legErrors$ = this.createSubject();
 		this._nodeId$ = this.createBehaviorSubject(options.nodeId ?? null);
 		this.onError = options.onError;
@@ -6566,9 +6573,13 @@ var WebRTCVertoManager = class extends VertoManager {
 			this.applyServerMediaParams(rtcPeerConnController, audio, video);
 		});
 		this.subscribeTo(this.vertoPing$, (vertoPing) => {
+			this._lastVertoPings.set(vertoPing.callID, vertoPing);
 			this.attachManager.refresh(this.buildAttachableCall());
 			this.sendVertoPong(vertoPing);
 		});
+		this.subscribeTo(this.webRtcCallSession.clientSession.authenticated$.pipe((0, rxjs.skip)(1), (0, rxjs.filter)(Boolean)), () => {
+			this._lastVertoPings.forEach((vertoPing) => void this.sendVertoPong(vertoPing));
+		});
 	}
 	/**
 	* An auxiliary-leg failure must never destroy the call; main-leg and
@@ -9908,6 +9919,8 @@ var ClientSessionManager = class extends Destroyable {
 		this._errors$ = this.createReplaySubject(1);
 		this._authState$ = this.createBehaviorSubject({ kind: "unauthenticated" });
 		this._wasClientBound = false;
+		this._lastFreshConnectReminted = false;
+		this._remintBeforeNextFreshConnect = false;
 		this._userInfo$ = this.createBehaviorSubject(null);
 		this._calls$ = this.createBehaviorSubject({});
 		this._iceServers$ = this.createBehaviorSubject([]);
@@ -10103,13 +10116,27 @@ var ClientSessionManager = class extends Destroyable {
 		await (0, rxjs.firstValueFrom)(this.authenticated$.pipe((0, rxjs.takeUntil)(this.destroyed$), (0, rxjs.filter)(Boolean), (0, rxjs.take)(1), (0, rxjs.timeout)({ first: 15e3 })));
 	}
 	async handleAuthenticationError(error) {
+		if (error instanceof require_operators.TransportConnectionError) {
+			logger$9.debug("[Session] Socket closed during authentication, waiting for reconnect");
+			return;
+		}
 		logger$9.error("Authentication error:", error);
 		const isRecoverableAuthError$1 = error instanceof require_operators.JSONRPCError && (error.code === require_operators.RPC_ERROR_REQUESTER_VALIDATION_FAILED || error.code === require_operators.RPC_ERROR_INVALID_PARAMS || error.code === require_operators.RPC_ERROR_AUTHENTICATION_FAILED);
 		const hasStoredState = await (0, rxjs.firstValueFrom)(this.authorizationState$.pipe((0, rxjs.take)(1))) !== void 0;
 		if (isRecoverableAuthError$1 && hasStoredState) {
 			logger$9.debug("[Session] Recoverable auth error — cleaning up stored state and reconnecting fresh");
 			await this.discardResumeStateAndReconnect();
-		} else this._errors$.next(error);
+		} else if (isRecoverableAuthError$1 && this.onBeforeReconnect && !this._lastFreshConnectReminted) {
+			logger$9.debug("[Session] Fresh connect refused — re-minting the credential and retrying once");
+			this._remintBeforeNextFreshConnect = true;
+			this.transport.reconnect();
+		} else {
+			this._errors$.next(error);
+			if (isRecoverableAuthError$1) {
+				this.transport.disconnect();
+				this.onAuthenticationRejected?.();
+			}
+		}
 	}
 	/**
 	* Clear the resume state (authorization_state + protocol) and ask the
@@ -10201,6 +10228,7 @@ var ClientSessionManager = class extends Destroyable {
 	}
 	async authenticate() {
 		logger$9.debug("[Session] Starting authentication process");
+		this._lastFreshConnectReminted = false;
 		const persistedParams = await (0, rxjs.firstValueFrom)((0, rxjs.combineLatest)({
 			protocol: this.transport.protocol$,
 			authorization_state: this.authorizationState$
@@ -10217,8 +10245,11 @@ var ClientSessionManager = class extends Destroyable {
 		else {
 			const credential = this.getCredential();
 			const credentialExpired = credential.expiry_at !== void 0 && credential.expiry_at <= Date.now() + require_operators.CREDENTIAL_EXPIRY_SKEW_MS;
-			if (this.onBeforeReconnect && (this.clientBound || credentialExpired)) {
+			const remint = this.clientBound || credentialExpired || this._remintBeforeNextFreshConnect;
+			this._remintBeforeNextFreshConnect = false;
+			if (this.onBeforeReconnect && remint) {
 				logger$9.debug("[Session] Refreshing credentials before fresh connect");
+				this._lastFreshConnectReminted = true;
 				await this.onBeforeReconnect();
 			}
 		}
@@ -10242,7 +10273,9 @@ var ClientSessionManager = class extends Destroyable {
 				protocol: persistedParams.protocol
 			} : {}
 		});
-		const response = await (0, rxjs.lastValueFrom)((0, rxjs.from)(this.transport.execute(rpcConnectRequest)).pipe(require_operators.throwOnRPCError(), (0, rxjs.map)((res) => res.result), (0, rxjs.filter)(isRPCConnectResult), (0, rxjs.tap)(() => {
+		if (this.transport.connectionStatus !== "connected") throw new require_operators.TransportConnectionError("WebSocket closed during authentication");
+		const socketClosed$ = this.transport.connectionStatus$.pipe((0, rxjs.skip)(1), (0, rxjs.filter)((status) => status === "reconnecting" || status === "disconnected"), (0, rxjs.take)(1), (0, rxjs.switchMap)(() => (0, rxjs.throwError)(() => new require_operators.TransportConnectionError("WebSocket closed during authentication"))));
+		const response = await (0, rxjs.lastValueFrom)((0, rxjs.race)((0, rxjs.from)(this.transport.execute(rpcConnectRequest)), socketClosed$).pipe(require_operators.throwOnRPCError(), (0, rxjs.map)((res) => res.result), (0, rxjs.filter)(isRPCConnectResult), (0, rxjs.tap)(() => {
 			logger$9.debug("[Session] Response passed filter, processing authentication result");
 		}), (0, rxjs.take)(1), (0, rxjs.catchError)((err) => {
 			logger$9.error("[Session] Authentication RPC failed:", err);
@@ -10257,6 +10290,7 @@ var ClientSessionManager = class extends Destroyable {
 		this._authorization$.next(response.authorization);
 		if (response.authorization.cnf?.jkt) this._wasClientBound = true;
 		this._iceServers$.next(response.ice_servers ?? []);
+		this.transport.setAuthenticated();
 		this._authState$.next({ kind: "authenticated" });
 		logger$9.debug("[Session] Authentication completed successfully");
 	}
@@ -11449,6 +11483,7 @@ var WebSocketController = class WebSocketController extends Destroyable {
 	}
 	handleClose(_event) {
 		this.clearConnectionTimeout();
+		this.messageQueue = [];
 		if (this.shouldReconnect) {
 			this._status$.next("reconnecting");
 			this.scheduleReconnection();
@@ -11518,6 +11553,9 @@ var WebSocketController = class WebSocketController extends Destroyable {
 function isSignalwirePingRequest(value) {
 	return isJSONRPCRequest(value) && value.method === "signalwire.ping";
 }
+function isSignalwireConnectRequest(value) {
+	return isJSONRPCRequest(value) && value.method === "signalwire.connect";
+}
 
 //#endregion
 //#region src/managers/TransportManager.ts
@@ -11531,6 +11569,10 @@ var TransportManager = class extends Destroyable {
 		this.protocol$ = this.createReplaySubject(1);
 		this.isConnecting = false;
 		this.isConnected = false;
+		this.socketStatus = "disconnected";
+		this.sessionAuthenticated = false;
+		this.heldRequests = [];
+		this.serverPingWatch = 0;
 		this.ackEvent = () => {
 			return (0, rxjs.tap)((message) => {
 				if (isSignalwireRequest(message)) try {
@@ -11546,6 +11588,7 @@ var TransportManager = class extends Destroyable {
 				if (isSignalwirePingRequest(message)) {
 					try {
 						logger$2.debug("[Transport] Received ping, sending pong", { pingId: message.id });
+						if (this.sessionAuthenticated) this.armServerPingWatchdog();
 						this.send(RPCPingResponse(message.id));
 					} catch (error) {
 						logger$2.error("[Transport] Failed to send ping response:", error);
@@ -11583,6 +11626,14 @@ var TransportManager = class extends Destroyable {
 		this.subscribeTo(this._webSocketConnections.errors$, (error) => {
 			this.onError?.(error);
 		});
+		this.subscribeTo(this._webSocketConnections.status$, (status) => {
+			this.socketStatus = status;
+			if (status !== "connected") {
+				this.sessionAuthenticated = false;
+				this.clearServerPingWatchdog();
+			}
+			if (status === "disconnected") this.heldRequests = [];
+		});
 		this.initialized$ = (0, rxjs.defer)(() => (0, rxjs.from)(this._init())).pipe((0, rxjs.shareReplay)(1), (0, rxjs.takeUntil)(this.destroyed$));
 		this._jsonRPCMessage$ = this._webSocketConnections.incomingMessages$.pipe((0, rxjs.map)((event) => {
 			try {
@@ -11611,6 +11662,9 @@ var TransportManager = class extends Destroyable {
 	get connectionStatus$() {
 		return this._webSocketConnections.status$;
 	}
+	get connectionStatus() {
+		return this.socketStatus;
+	}
 	async connect() {
 		if (this.isConnecting || this.isConnected) {
 			logger$2.warn("[Transport] Already connecting or connected");
@@ -11655,16 +11709,45 @@ var TransportManager = class extends Destroyable {
 	}
 	async execute(request, options) {
 		this.send(request);
-		return new PendingRPC(request, this._jsonRPCResponse$, options).promise;
+		const pending = new PendingRPC(request, this._jsonRPCResponse$, options).promise;
+		pending.catch(() => {
+			this.heldRequests = this.heldRequests.filter((held) => held.id !== request.id);
+		});
+		return pending;
 	}
 	send(message) {
 		const payload = JSON.stringify(message);
+		if (isJSONRPCResponse(message)) {
+			if (this.socketStatus !== "connected") {
+				logger$2.debug("[Transport] Dropping response while disconnected", { id: message.id });
+				return;
+			}
+		} else if (!this.sessionAuthenticated && !isSignalwireConnectRequest(message)) {
+			this.heldRequests.push({
+				id: message.id,
+				payload
+			});
+			return;
+		}
 		this._outgoingMessages$.next(payload);
 	}
+	/**
+	* Called by the session when signalwire.connect succeeds on the current
+	* socket. Sends the requests held since the socket opened, in order.
+	*/
+	setAuthenticated() {
+		if (this.socketStatus !== "connected") return;
+		this.sessionAuthenticated = true;
+		this.armServerPingWatchdog();
+		const held = this.heldRequests;
+		this.heldRequests = [];
+		held.forEach(({ payload }) => this._outgoingMessages$.next(payload));
+	}
 	disconnect() {
 		logger$2.debug("[Transport] Disconnecting");
 		this.isConnected = false;
 		this.isConnecting = false;
+		this.clearServerPingWatchdog();
 		this._webSocketConnections.disconnect();
 	}
 	destroy() {
@@ -11673,6 +11756,28 @@ var TransportManager = class extends Destroyable {
 		super.destroy();
 		this._webSocketConnections.destroy();
 	}
+	armServerPingWatchdog() {
+		this.clearServerPingWatchdog();
+		const watch = this.serverPingWatch;
+		this.serverPingTimer = setTimeout(() => void this.probeServer(watch), require_operators.SERVER_PING_TIMEOUT_MS);
+	}
+	/** Bumps the watch so a probe still in flight no longer acts on its result. */
+	clearServerPingWatchdog() {
+		clearTimeout(this.serverPingTimer);
+		this.serverPingTimer = void 0;
+		this.serverPingWatch += 1;
+	}
+	async probeServer(watch) {
+		logger$2.debug(`[Transport] No signalwire.ping for ${require_operators.SERVER_PING_TIMEOUT_MS}ms, probing the server`);
+		try {
+			await this.execute(RPCPing(), { timeoutMs: require_operators.SERVER_PING_PROBE_TIMEOUT_MS });
+			if (watch === this.serverPingWatch) this.armServerPingWatchdog();
+		} catch (error) {
+			if (watch !== this.serverPingWatch) return;
+			logger$2.warn("[Transport] Server did not answer the ping probe, replacing the socket", error);
+			this.reconnect();
+		}
+	}
 	async _loadProtocolFromStorage() {
 		try {
 			const storedProtocol = await this.storage.getItem(this.protocolKey);
@@ -12198,6 +12303,7 @@ var SignalWire = class extends Destroyable {
 			this.persistClientBoundMarker(Boolean(authorization?.cnf?.jkt));
 		});
 		await this._clientSession.connect();
+		this._clientSession.onAuthenticationRejected = () => void this.disconnect();
 		await this._refreshCoordinator?.activate(this._deps.user, this._clientSession);
 		this.subscribeTo(this._clientSession.authenticated$.pipe((0, rxjs.skip)(1), (0, rxjs.filter)(Boolean)), async () => {
 			try {
@@ -12377,7 +12483,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.3" });
+			this._diagnosticsCollector = new DiagnosticsCollector({ sdkVersion: "4.0.0-rc.5" });
 		} catch (error) {
 			logger$1.warn("[SignalWire] Failed to initialize DiagnosticsCollector:", error);
 		}
@@ -12931,7 +13037,7 @@ var StaticCredentialProvider = class {
 /**
 * Library version from package.json, injected at build time.
 */
-const version = "4.0.0-rc.3";
+const version = "4.0.0-rc.5";
 /**
 * Flag indicating the library has been loaded and is ready to use.
 * For UMD builds: `window.SignalWire.ready`
@@ -12953,7 +13059,7 @@ const ready = true;
 */
 const emitReadyEvent = () => {
 	if (typeof window !== "undefined") {
-		const event = new CustomEvent("signalwire:js:ready", { detail: { version: "4.0.0-rc.3" } });
+		const event = new CustomEvent("signalwire:js:ready", { detail: { version: "4.0.0-rc.5" } });
 		window.dispatchEvent(event);
 	}
 };