@unboundcx/video-sdk-client 1.1.0 → 2.0.0

package/VideoMeetingClient.js

@@ -28,6 +28,11 @@ export class VideoMeetingClient extends EventEmitter {
 	 * @param {Object} options
 	 * @param {string} [options.serverUrl] - WebSocket server URL (optional if using joinFromApiResponse)
 	 * @param {boolean} [options.debug=false] - Enable debug logging
+	 * @param {Object} [options.sdk] - UnboundSDK instance, injected by
+	 *   `sdk.video.createMeetingClient()`. Required for transparent reassignment
+	 *   recovery (calls `sdk.video.joinRoom()`) and for `endSession()` to invoke
+	 *   `sdk.video.endSession()`. Without it, consumers must handle both paths
+	 *   themselves.
 	 */
 	constructor(options = {}) {
 		super();
@@ -39,6 +44,15 @@ export class VideoMeetingClient extends EventEmitter {
 		this.debug = options.debug;
 		this.isGuest = false;
 		this.inWaitingRoom = false;
+		this.sdk = options.sdk || null;
+
+		// Reassignment recovery state. Attempt window is 60s; cap at 3 attempts.
+		// Backoff schedule: 500ms, 2s, 5s. Counter resets once a connection has
+		// stayed up for >60s (see _onReassignmentStableConnect).
+		this._reassignmentAttempts = []; // timestamps (Date.now()) of recent attempts
+		this._reassignmentInFlight = false;
+		this._reassignmentStableTimer = null;
+		this._lastJoinArgs = null; // args used by consumer to call sdk.video.joinRoom()
 
 		// Managers will be initialized when we have connection info
 		this.connection = null;
@@ -51,16 +65,19 @@ export class VideoMeetingClient extends EventEmitter {
 			this._initializeManagers(options.serverUrl);
 		}
 
-		this.logger.info('VideoMeetingClient initialized');
+		this.logger.info('VideoMeetingClient initialized', { hasSdk: !!this.sdk });
 	}
 
 	/**
 	 * Initialize managers with server URL
 	 * @private
+	 * @param {string} serverUrl
+	 * @param {string} [namespace] - Socket.IO namespace path, e.g. `/video`
 	 */
-	_initializeManagers(serverUrl) {
+	_initializeManagers(serverUrl, namespace = null) {
 		this.connection = new ConnectionManager({
 			serverUrl,
+			namespace,
 			debug: this.debug,
 		});
 
@@ -83,6 +100,15 @@ export class VideoMeetingClient extends EventEmitter {
 
 		// Proxy manager events to SDK events
 		this._setupEventProxies();
+
+		// When mediasoup detects its transports are stale after a long disconnect,
+		// re-run the room.join flow to get fresh transport options + producer list
+		// from the server. This keeps media working across network blips >30s.
+		this.mediasoup.on('transports:recreated-needed', () => {
+			this._rejoinRoomForTransportRecreation().catch((err) => {
+				this.logger.error('Rejoin for transport recreation failed', err);
+			});
+		});
 	}
 
 	/**
@@ -94,6 +120,15 @@ export class VideoMeetingClient extends EventEmitter {
 		this.connection.on('connected', () => {
 			this._setState('connected');
 			this.emit('connected');
+
+			// On Socket.IO reconnect (not initial connect), check whether the
+			// WebRTC transports died during the disconnect window. If the state
+			// has been bad for >10s, mediasoup will emit transports:recreated-needed.
+			if (this.mediasoup && (this.mediasoup.sendTransport || this.mediasoup.recvTransport)) {
+				this.mediasoup.recreateStaleTransports().catch((err) => {
+					this.logger.error('recreateStaleTransports threw', err);
+				});
+			}
 		});
 
 		this.connection.on('disconnected', (data) => {
@@ -105,6 +140,14 @@ export class VideoMeetingClient extends EventEmitter {
 			this.emit('error', error);
 		});
 
+		// Server signaled the assigned pod is stale — re-fetch joinRoom and reconnect.
+		this.connection.on('reassignmentRequired', ({ code }) => {
+			this.logger.warn('Reassignment required', { code });
+			this._handleReassignment(code).catch((err) => {
+				this.logger.error('Reassignment handler threw', err);
+			});
+		});
+
 		// Local media events
 		this.localMedia.on('stream:added', (data) => {
 			this.emit('local-stream:added', data);
@@ -304,52 +347,83 @@ export class VideoMeetingClient extends EventEmitter {
 	async joinFromApiResponse(joinResponse, options = {}) {
 		this.logger.info('Joining from API response');
 
-		try {
-			// Extract data from API response
-			const { server, authorization, videoRoom, participant } = joinResponse;
+		// Store args used to obtain this response. If a reassignment is required
+		// later, we replay these against sdk.video.joinRoom() to get a fresh
+		// assignment without the consumer having to wire anything up.
+		if (options.joinRoomArgs !== undefined) {
+			this._lastJoinArgs = options.joinRoomArgs;
+		}
 
-			if (!server?.url || !server?.socketPort) {
-				throw new Error('Invalid join response: missing server info');
+		try {
+			const { videoRoom, participant } = joinResponse;
+
+			// Support both the new shape (connectionInfo.socket) and the legacy
+			// shape (top-level server + authorization) during the rollout.
+			// Legacy path is removed once every app1-api replica returns the new
+			// shape in staging/prod.
+			const connectionInfo = joinResponse.connectionInfo;
+			const socketInfo = connectionInfo?.socket;
+			const legacyServer = joinResponse.server;
+
+			let socketUrl;
+			let socketNamespace;
+			let authData;
+			let authorization;
+
+			if (socketInfo?.url) {
+				socketUrl = socketInfo.url;
+				socketNamespace = socketInfo.namespace || '/video';
+				authData = {
+					...socketInfo.auth,
+					roomId: videoRoom.id,
+					participantId: participant.id,
+				};
+				authorization = connectionInfo.authorization || null;
+			} else if (legacyServer?.url && legacyServer?.socketPort) {
+				// Legacy per-pod-ingress path. Remove once centralized signaling
+				// is fully deployed.
+				socketUrl = `https://${legacyServer.url}:${legacyServer.socketPort}`;
+				socketNamespace = null;
+				authorization = joinResponse.authorization;
+				authData = {
+					accountNamespace: authorization?.namespace,
+					roomId: videoRoom.id,
+					participantId: participant.id,
+				};
+			} else {
+				throw new Error('Invalid join response: missing connectionInfo.socket and legacy server info');
 			}
 
-			// Store join data for later use
+			// Store join data for later use (including reassignment replay)
 			this.joinData = {
 				videoRoom,
 				participant,
-				server,
-				authorization
+				connectionInfo: connectionInfo || null,
+				server: legacyServer || null,
+				authorization,
 			};
 
 			// Detect if this is a guest (no host privileges)
 			this.isGuest = !participant.isHost && !participant.isModerator;
 
-			// Build server URL - use https:// (not wss://) to allow Socket.io to handle upgrade
-			// This ensures cookies are sent during the HTTP handshake for authentication
-			const serverUrl = `https://${server.url}:${server.socketPort}`;
-
-			this.logger.info('Connecting to video server:', serverUrl);
+			this.logger.info('Connecting to video server:', { socketUrl, socketNamespace });
 
 			// Initialize managers if not already done
 			if (!this.connection) {
-				this._initializeManagers(serverUrl);
+				this._initializeManagers(socketUrl, socketNamespace);
 			}
 
-			// Connect with authorization (matches old videoCreateSocket.js format)
-			// NOTE: Using cookie-based auth, so only send namespace, roomId, participantId
-			// The HTTP cookie set by api.video.joinRoom() handles authentication
 			this._setState('connecting');
 
-			const authData = {
-				namespace: authorization.namespace,
-				roomId: videoRoom.id,
-				participantId: participant.id
-			};
-
 			this.logger.info('Connecting with auth (cookie-based):', authData);
 			await this.connection.connect(authData);
 
 			this._setState('connected');
 
+			// Connection succeeded. If it stays up >60s, reset the reassignment
+			// attempt counter so the next reassignment cycle starts fresh.
+			this._armReassignmentStableTimer();
+
 			// Setup remote media listeners and room event listeners
 			this.logger.info('Setting up event listeners');
 			this.remoteMedia._setupServerListeners();
@@ -1207,4 +1281,228 @@ export class VideoMeetingClient extends EventEmitter {
 		}
 		return await this.remoteMedia.retryConsumeProducer(producerId, participantId);
 	}
+
+	// ========== Session Lifecycle ==========
+
+	/**
+	 * End the meeting session server-side. Clears the videoAuthToken cookie
+	 * and invalidates the token row so a stale cookie can't be replayed.
+	 *
+	 * Intended to be called on `leave()`, on a page `beforeunload`, or when the
+	 * consumer surfaces an "already joined in another tab" UX and wants to
+	 * clear the incumbent session before retrying. Safe to call from
+	 * `fetch({ keepalive: true })` during unload.
+	 *
+	 * Delegates to `sdk.video.endSession(roomId)` if an SDK was injected via
+	 * constructor options; otherwise this is a no-op (consumer must clear the
+	 * cookie through its own plumbing).
+	 *
+	 * @param {Object} [options]
+	 * @param {string} [options.roomId] - Override. Defaults to the current room.
+	 * @returns {Promise<void>}
+	 */
+	async endSession(options = {}) {
+		const roomId = options.roomId || this.currentRoomId || this.joinData?.videoRoom?.id;
+		if (!roomId) {
+			this.logger.warn('endSession: no roomId available');
+			return;
+		}
+		if (!this.sdk?.video?.endSession) {
+			this.logger.warn('endSession: sdk not injected — consumer must clear session cookie manually');
+			return;
+		}
+		try {
+			await this.sdk.video.endSession(roomId);
+			this.logger.info('Session ended', { roomId });
+		} catch (err) {
+			this.logger.error('endSession failed', err);
+		}
+	}
+
+	// ========== Long-Disconnect Transport Recreation ==========
+
+	/**
+	 * Re-run the `room.join` flow after mediasoup wiped stale transports.
+	 * The server responds with fresh media.routerCapabilities + media.transports;
+	 * we reuse the existing loadDevice / transport listener plumbing so producers
+	 * and consumers get re-wired.
+	 *
+	 * Consumer must re-publish local streams (camera/microphone) after this —
+	 * producers died with the old transports.
+	 * @private
+	 */
+	async _rejoinRoomForTransportRecreation() {
+		if (!this.joinData || !this.connection) {
+			this.logger.warn('Cannot rejoin for transport recreation: no joinData or connection');
+			return;
+		}
+		this.logger.info('Re-emitting room.join to recreate transports after long disconnect');
+
+		// Reset the transports promise — _setupMediaEventListeners() creates it
+		// via a fresh media.transports listener in the join flow.
+		this._setupMediaEventListeners();
+
+		// Also need a fresh routerCapabilities listener since device must be
+		// (re-)loaded. mediasoup.loadDevice() is idempotent only if device
+		// isn't already loaded; after cleanup it should be safe to reload.
+		this.connection.emit('room.join', {});
+
+		try {
+			if (!this.mediasoup.device.loaded) {
+				await this.mediasoup.loadDevice();
+			}
+			await this._waitForTransports();
+			this.emit('transports:recreated');
+			this.logger.info('Transport recreation complete');
+		} catch (err) {
+			this.logger.error('Transport recreation failed', err);
+			this.emit('error', {
+				code: 'transport_recreation_failed',
+				message: err.message,
+			});
+		}
+	}
+
+	// ========== Reassignment Recovery ==========
+
+	/**
+	 * Arm the stable-connect timer. If the current connection stays up for >60s,
+	 * clear the reassignment attempt counter so the next cycle starts fresh.
+	 * @private
+	 */
+	_armReassignmentStableTimer() {
+		if (this._reassignmentStableTimer) {
+			clearTimeout(this._reassignmentStableTimer);
+		}
+		this._reassignmentStableTimer = setTimeout(() => {
+			if (this._reassignmentAttempts.length > 0) {
+				this.logger.info('Connection stable >60s; resetting reassignment attempt counter');
+				this._reassignmentAttempts = [];
+			}
+			this._reassignmentStableTimer = null;
+		}, 60_000);
+	}
+
+	/**
+	 * Handle a reassignmentRequired signal from the ConnectionManager.
+	 * Caps at 3 attempts in a 60s window with backoff 500ms, 2s, 5s.
+	 * @private
+	 */
+	async _handleReassignment(code) {
+		if (this._reassignmentInFlight) {
+			this.logger.warn('Reassignment already in flight; ignoring duplicate signal');
+			return;
+		}
+		this._reassignmentInFlight = true;
+
+		try {
+			// Prune attempts older than 60s
+			const now = Date.now();
+			const windowStart = now - 60_000;
+			this._reassignmentAttempts = this._reassignmentAttempts.filter(ts => ts > windowStart);
+
+			const attemptIndex = this._reassignmentAttempts.length;
+			if (attemptIndex >= 3) {
+				this.logger.error('Reassignment cap reached (3 in 60s); emitting reassignment_exhausted');
+				this.emit('error', {
+					code: 'reassignment_exhausted',
+					message: 'Reassignment attempts exhausted',
+					triggeredBy: code,
+				});
+				return;
+			}
+
+			this._reassignmentAttempts.push(now);
+
+			const backoffs = [500, 2000, 5000];
+			const delay = backoffs[attemptIndex];
+			this.logger.info(`Reassignment attempt ${attemptIndex + 1}/3 in ${delay}ms (code=${code})`);
+
+			await new Promise((resolve) => setTimeout(resolve, delay));
+
+			if (!this.sdk?.video?.joinRoom || !this._lastJoinArgs) {
+				this.logger.error('Cannot reassign: sdk or last joinRoom args missing');
+				this.emit('error', {
+					code: 'reassignment_exhausted',
+					message: 'Reassignment plumbing missing (no sdk or joinRoomArgs)',
+					triggeredBy: code,
+				});
+				return;
+			}
+
+			// Teardown current media state. The old pod's mediasoup Router is
+			// gone (or the token was rejected); we re-run the full join flow.
+			await this._teardownForReassignment();
+
+			// Fetch a fresh assignment.
+			const args = Array.isArray(this._lastJoinArgs)
+				? this._lastJoinArgs
+				: [this._lastJoinArgs];
+			const response = await this.sdk.video.joinRoom(...args);
+
+			// Re-run the join flow with the fresh response.
+			await this.joinFromApiResponse(response, { joinRoomArgs: this._lastJoinArgs });
+
+			this.emit('reassigned', { code, attempt: attemptIndex + 1 });
+			this.logger.info('Reassignment succeeded', { attempt: attemptIndex + 1 });
+
+		} catch (err) {
+			this.logger.error('Reassignment failed', err);
+			// Don't count fetch/connect failures — they'll trigger another
+			// reassignmentRequired or a terminal error on their own.
+		} finally {
+			this._reassignmentInFlight = false;
+		}
+	}
+
+	/**
+	 * Tear down state before reconnecting on reassignment. Media is
+	 * unrecoverable (mediasoup Router died with the pod), so we clean up
+	 * transports, producers, consumers, local device tracks, and the old
+	 * Socket.IO handle. Consumer re-publishes camera/mic after the `reassigned`
+	 * event fires — matches the plan's "Media state lost (unavoidable)" stance
+	 * for pod death.
+	 * @private
+	 */
+	async _teardownForReassignment() {
+		try {
+			if (this.localMedia) {
+				await this.localMedia.cleanup();
+			}
+		} catch (err) {
+			this.logger.warn('LocalMedia cleanup threw during reassignment', err);
+		}
+		try {
+			if (this.mediasoup) {
+				await this.mediasoup.cleanup();
+			}
+		} catch (err) {
+			this.logger.warn('Mediasoup cleanup threw during reassignment', err);
+		}
+		try {
+			if (this.remoteMedia) {
+				await this.remoteMedia.cleanup();
+			}
+		} catch (err) {
+			this.logger.warn('RemoteMedia cleanup threw during reassignment', err);
+		}
+		try {
+			if (this.connection) {
+				await this.connection.disconnect();
+			}
+		} catch (err) {
+			this.logger.warn('Connection disconnect threw during reassignment', err);
+		}
+
+		// Null out managers so _initializeManagers runs again with the new URL.
+		this.connection = null;
+		this.mediasoup = null;
+		this.localMedia = null;
+		this.remoteMedia = null;
+
+		if (this._reassignmentStableTimer) {
+			clearTimeout(this._reassignmentStableTimer);
+			this._reassignmentStableTimer = null;
+		}
+	}
 }

package/managers/ConnectionManager.js

@@ -3,6 +3,11 @@ import { EventEmitter } from '../utils/EventEmitter.js';
 import { Logger } from '../utils/Logger.js';
 import { ConnectionError, TimeoutError } from '../utils/errors.js';
 
+// Server-side rejection codes that mean "this token/room/pod assignment is
+// stale and the client must re-fetch a fresh assignment via sdk.video.joinRoom".
+// Emitted by app1-socket's authorizeVideoSocketConnection middleware.
+const REASSIGNMENT_ERROR_CODES = new Set(['pod_reassign_required', 'room_mismatch']);
+
 /**
  * Manages Socket.io connection and signaling with the video server
  *
@@ -11,17 +16,26 @@ import { ConnectionError, TimeoutError } from '../utils/errors.js';
  * - 'disconnected' - Disconnected from server
  * - 'error' - Connection error
  * - 'message' - Received message from server
+ * - 'reassignmentRequired' - Server signaled the room's pod assignment is
+ *   stale (pod_reassign_required or room_mismatch). Consumer (VideoMeetingClient)
+ *   re-fetches joinRoom() and reconnects transparently.
  */
 export class ConnectionManager extends EventEmitter {
 	/**
 	 * @param {Object} options
-	 * @param {string} options.serverUrl - WebSocket server URL
+	 * @param {string} options.serverUrl - WebSocket server URL. If a namespace
+	 *   is needed (e.g. `/video`), pass it via `options.namespace` rather than
+	 *   embedding it in `serverUrl`.
+	 * @param {string} [options.namespace] - Socket.IO namespace path, e.g.
+	 *   `/video`. Appended to `serverUrl` when constructing the io() call.
+	 *   Comes from the API's `connectionInfo.socket.namespace` response field.
 	 * @param {boolean} options.debug - Enable debug logging
 	 */
 	constructor(options) {
 		super();
 
 		this.serverUrl = options.serverUrl;
+		this.namespace = options.namespace || null;
 		this.logger = new Logger('SDK:ConnectionManager', options.debug);
 		this.socket = null;
 		this.isConnected = false;
@@ -44,22 +58,35 @@ export class ConnectionManager extends EventEmitter {
 
 		return new Promise((resolve, reject) => {
 			try {
-				// Match the old working videoCreateSocket.js pattern exactly
-				// Keep it simple: just withCredentials and auth
+				// Normalize the handshake auth field. The server-side middleware
+				// in app1-socket expects `accountNamespace` (disambiguates from
+				// Socket.IO's own `/video` namespace concept). Older callers may
+				// still pass the field as `namespace`; translate transparently.
+				const normalizedAuth = { ...auth };
+				if (normalizedAuth.namespace !== undefined && normalizedAuth.accountNamespace === undefined) {
+					normalizedAuth.accountNamespace = normalizedAuth.namespace;
+					delete normalizedAuth.namespace;
+				}
+
 				const socketOptions = {
 					withCredentials: true,
-					auth,
+					auth: normalizedAuth,
 				};
 
-				console.log('ConnectionManager :: Auth object being sent:', auth);
-				console.log('ConnectionManager :: Full socket options:', socketOptions);
-
-				this.logger.info('Creating socket.io connection with options:', {
-					serverUrl: this.serverUrl,
-					...socketOptions
+				// Build the connection URL. Socket.IO reads the namespace from
+				// the URL path, so for the `/video` namespace we append it to
+				// the base server URL.
+				const connectionUrl = this.namespace
+					? `${this.serverUrl}${this.namespace}`
+					: this.serverUrl;
+
+				this.logger.info('Creating socket.io connection', {
+					connectionUrl,
+					namespace: this.namespace,
+					authKeys: Object.keys(normalizedAuth),
 				});
 
-				this.socket = io(this.serverUrl, socketOptions);
+				this.socket = io(connectionUrl, socketOptions);
 
 				this.logger.info('Socket.io instance created, waiting for connect event');
 
@@ -79,7 +106,23 @@ export class ConnectionManager extends EventEmitter {
 				});
 
 				this.socket.on('connect_error', (error) => {
-					this.logger.error('Connection error:', error);
+					// Socket.IO surfaces server-side middleware rejections as
+					// connect_error with the Error's message set to the code
+					// we called next(new Error(code)) with on the server.
+					const errorCode = error?.data?.code || error?.message;
+
+					this.logger.error('Connection error:', error, { errorCode });
+
+					if (REASSIGNMENT_ERROR_CODES.has(errorCode)) {
+						// Stop Socket.IO from auto-retrying — the token/pod
+						// assignment is stale and will reject every time.
+						// VideoMeetingClient handles the re-join flow.
+						this.socket?.disconnect();
+						this.emit('reassignmentRequired', { code: errorCode });
+						reject(new ConnectionError(`Reassignment required: ${errorCode}`, { code: errorCode }));
+						return;
+					}
+
 					this.reconnectAttempts++;
 
 					const connectionError = new ConnectionError(

package/managers/MediasoupManager.js

@@ -36,6 +36,14 @@ export class MediasoupManager extends EventEmitter {
 		// Initialize stats collector
 		this.statsCollector = new StatsCollector(this.logger);
 		this.virtualBackgroundStore = null; // Will be set externally
+
+		// Timestamps for tracking transport ICE failure duration. Used by
+		// recreateStaleTransports() on Socket.IO reconnect to decide whether
+		// a network blip was long enough (>10s) to kill WebRTC state, in
+		// which case we must recreate transports rather than expect ICE to
+		// recover on its own.
+		this._sendFailedAt = null;
+		this._recvFailedAt = null;
 	}
 
 	/**
@@ -253,6 +261,12 @@ export class MediasoupManager extends EventEmitter {
 		transport.on('connectionstatechange', (state) => {
 			this.logger.info('Send transport state:', state);
 
+			if (state === 'failed' || state === 'disconnected') {
+				if (!this._sendFailedAt) this._sendFailedAt = Date.now();
+			} else if (state === 'connected' || state === 'completed') {
+				this._sendFailedAt = null;
+			}
+
 			if (state === 'failed' || state === 'closed') {
 				this.emit('transport:closed', { direction: 'send', id: transport.id, state });
 			}
@@ -303,12 +317,82 @@ export class MediasoupManager extends EventEmitter {
 		transport.on('connectionstatechange', (state) => {
 			this.logger.info('Receive transport state:', state);
 
+			if (state === 'failed' || state === 'disconnected') {
+				if (!this._recvFailedAt) this._recvFailedAt = Date.now();
+			} else if (state === 'connected' || state === 'completed') {
+				this._recvFailedAt = null;
+			}
+
 			if (state === 'failed' || state === 'closed') {
 				this.emit('transport:closed', { direction: 'recv', id: transport.id, state });
 			}
 		});
 	}
 
+	/**
+	 * After Socket.IO reconnects, check whether the underlying WebRTC
+	 * transports have been in a `failed`/`disconnected` state long enough
+	 * (>10s) that ICE won't recover on its own. If so, close both transports
+	 * and signal the consumer to re-run the `room.join` flow (which yields
+	 * fresh routerCapabilities + transport options + producer list from the
+	 * server).
+	 *
+	 * Without this, a long network blip leaves the client with a live
+	 * Socket.IO connection but dead WebRTC media — audio and video look
+	 * broken to the user even though signaling is fine.
+	 *
+	 * @returns {boolean} true if transports were recreated
+	 */
+	async recreateStaleTransports() {
+		const STALE_THRESHOLD_MS = 10_000;
+		const now = Date.now();
+
+		const sendStale = this._sendFailedAt && (now - this._sendFailedAt) > STALE_THRESHOLD_MS;
+		const recvStale = this._recvFailedAt && (now - this._recvFailedAt) > STALE_THRESHOLD_MS;
+
+		if (!sendStale && !recvStale) {
+			return false;
+		}
+
+		this.logger.warn('Transports stale after reconnect — recreating', {
+			sendFailedAt: this._sendFailedAt,
+			recvFailedAt: this._recvFailedAt,
+			now,
+		});
+
+		// Stop stats; close producers, consumers, transports.
+		this.statsCollector.stopAll();
+
+		for (const [type, producer] of this.producers) {
+			try { producer.close(); } catch (err) { this.logger.error('closing producer', type, err); }
+		}
+		this.producers.clear();
+
+		for (const [id, consumer] of this.consumers) {
+			try { consumer.close(); } catch (err) { this.logger.error('closing consumer', id, err); }
+		}
+		this.consumers.clear();
+
+		if (this.sendTransport) {
+			try { this.sendTransport.close(); } catch (err) { this.logger.error('closing sendTransport', err); }
+			this.sendTransport = null;
+		}
+		if (this.recvTransport) {
+			try { this.recvTransport.close(); } catch (err) { this.logger.error('closing recvTransport', err); }
+			this.recvTransport = null;
+		}
+
+		this._sendFailedAt = null;
+		this._recvFailedAt = null;
+
+		// Consumer (VideoMeetingClient) reacts to this and drives the
+		// re-join — it owns the room.join emission + the _transportsPromise
+		// wiring.
+		this.emit('transports:recreated-needed');
+
+		return true;
+	}
+
 	/**
 	 * Produce media (send to server)
 	 * @param {MediaStreamTrack} track - Media track to produce

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@unboundcx/video-sdk-client",
-	"version": "1.1.0",
+	"version": "2.0.0",
 	"description": "Framework-agnostic WebRTC video meeting SDK powered by mediasoup",
 	"type": "module",
 	"main": "index.js",
@@ -11,7 +11,7 @@
 		"./utils/*": "./utils/*.js"
 	},
 	"scripts": {
-		"test": "echo \"Error: no test specified\" && exit 1"
+		"test": "node --test 'test/*.test.js'"
 	},
 	"keywords": [
 		"webrtc",