@reactoo/watchtogether-sdk-js 2.7.97 → 2.8.0-beta.1

package/src/modules/wt-room-sfu.js

@@ -0,0 +1,3692 @@
+// Watch together janus webrtc library
+
+import adapter from 'webrtc-adapter';
+import emitter from './wt-emitter';
+import {decodeJanusDisplay, generateUUID, maxJitter, median, wait} from "../models/utils";
+
+class Room {
+
+	static noop() {
+
+	}
+
+	constructor(debug) {
+		this.debug = debug;
+		this.sessions = [];
+		this.safariVp8 = false;
+		this.browser = adapter.browserDetails.browser;
+		this.browserDetails = adapter.browserDetails;
+		this.webrtcSupported = Room.isWebrtcSupported();
+		this.safariVp8TestPromise = Room.testSafariVp8();
+		this.safariVp8 = null;
+		this.safariVp8TestPromise.then(safariVp8 => {
+			this.safariVp8 = safariVp8;
+		})
+
+		this._log = Room.noop;
+		if (this.debug) {
+			this.#enableDebug();
+		}
+
+		// Let's get it started
+		this.whenInitialized = this.initialize();
+	}
+
+	#enableDebug() {
+		this._log = console.log.bind(console);
+	}
+
+	initialize() {
+		return this.safariVp8TestPromise
+			.then(() => this);
+	}
+
+	createSession(constructId = null, type = 'reactooroom', options = {}) {
+		return new RoomSession(constructId, type, {debug: this.debug, ...options});
+	}
+
+	static testSafariVp8() {
+		return new Promise(resolve => {
+			if (adapter.browserDetails.browser === 'safari' &&
+				adapter.browserDetails.version >= 605) {
+				if (RTCRtpSender && RTCRtpSender.getCapabilities && RTCRtpSender.getCapabilities("video") &&
+					RTCRtpSender.getCapabilities("video").codecs && RTCRtpSender.getCapabilities("video").codecs.length) {
+					var isVp8 = false;
+					for (var i in RTCRtpSender.getCapabilities("video").codecs) {
+						var codec = RTCRtpSender.getCapabilities("video").codecs[i];
+						if (codec && codec.mimeType && codec.mimeType.toLowerCase() === "video/vp8") {
+							isVp8 = true;
+							break;
+						}
+					}
+					resolve(isVp8);
+				} else {
+					// We do it in a very ugly way, as there's no alternative...
+					// We create a PeerConnection to see if VP8 is in an offer
+					var testpc = new RTCPeerConnection({}, {});
+					testpc.createOffer({offerToReceiveVideo: true}).then(function (offer) {
+						let result = offer.sdp.indexOf("VP8") !== -1;
+						testpc.close();
+						testpc = null;
+						resolve(result);
+					});
+				}
+			} else resolve(false);
+		});
+	}
+
+	static isWebrtcSupported() {
+		return window.RTCPeerConnection !== undefined && window.RTCPeerConnection !== null &&
+			navigator.mediaDevices !== undefined && navigator.mediaDevices !== null &&
+			navigator.mediaDevices.getUserMedia !== undefined && navigator.mediaDevices.getUserMedia !== null;
+	}
+}
+
+class RoomSession {
+
+	static noop() {
+
+	}
+
+	static randomString(len) {
+		var charSet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+		var randomString = '';
+		for (var i = 0; i < len; i++) {
+			var randomPoz = Math.floor(Math.random() * charSet.length);
+			randomString += charSet.substring(randomPoz, randomPoz + 1);
+		}
+		return randomString;
+	}
+
+	static sessionTypes =  {
+		'reactooroom': 'janus.plugin.reactooroom',
+	}
+
+	static userRoleSubscriptionRules = {
+		participant: {
+			"watchparty": ['participant', 'talkback'],
+			"studio": ['participant', 'talkback', 'host', 'observer'],
+			"commentary": ['participant', 'talkback', 'host'],
+			"intercom": ['host', 'talkback', 'observer', 'observerSolo1', 'observerSolo2', 'observerSolo3', 'observerSolo4', 'observerSolo5'],
+			"videowall": ['host', 'talkback', 'observer', 'observerSolo1', 'observerSolo2', 'observerSolo3', 'observerSolo4', 'observerSolo5'],
+			"videowall-queue": ['host', 'talkback', 'observer', 'observerSolo1', 'observerSolo2', 'observerSolo3', 'observerSolo4', 'observerSolo5'],
+			"videowall-queue-video": ['host', 'talkback', 'observer', 'observerSolo1', 'observerSolo2', 'observerSolo3', 'observerSolo4', 'observerSolo5']
+		},
+		monitor: {
+			"watchparty": ['participant', 'host'],
+			"studio": ['participant', 'host', 'observer'],
+			"commentary": ['participant', 'host'],
+			"intercom": ['host', 'participant'],
+			"videowall": ['host', 'participant'],
+			"videowall-queue": ['host', 'participant'],
+			"videowall-queue-video": ['host', 'participant'],
+		},
+		talkback: {
+			"watchparty": ['participant', 'host', 'talkback'],
+			"studio": ['participant', 'host', 'observer', 'talkback'],
+			"commentary": ['host', 'participant', 'talkback'],
+			"intercom": ['host', 'participant', 'talkback'],
+			"videowall": ['host', 'participant', 'talkback'],
+			"videowall-queue": ['host', 'participant', 'talkback'],
+			"videowall-queue-video": ['host', 'participant', 'talkback'],
+		},
+		observer: {
+			"watchparty": ['participant'],
+			"studio": ['participant'],
+			"commentary": ['participant'],
+			"intercom": ['participant'],
+			"videowall": ['participant'],
+			"videowall-queue": ['participant'],
+			"videowall-queue-video": ['participant'],
+		},
+		observerSolo1: {
+			"watchparty": ['participant'],
+			"studio": ['participant'],
+			"commentary": ['participant'],
+			"intercom": ['participant'],
+			"videowall": ['participant'],
+			"videowall-queue": ['participant'],
+			"videowall-queue-video": ['participant'],
+		},
+		observerSolo2: {
+			"watchparty": ['participant'],
+			"studio": ['participant'],
+			"commentary": ['participant'],
+			"intercom": ['participant'],
+			"videowall": ['participant'],
+			"videowall-queue": ['participant'],
+			"videowall-queue-video": ['participant'],
+		},
+		observerSolo3: {
+			"watchparty": ['participant'],
+			"studio": ['participant'],
+			"commentary": ['participant'],
+			"intercom": ['participant'],
+			"videowall": ['participant'],
+			"videowall-queue": ['participant'],
+			"videowall-queue-video": ['participant'],
+		},
+		observerSolo4: {
+			"watchparty": ['participant'],
+			"studio": ['participant'],
+			"commentary": ['participant'],
+			"intercom": ['participant'],
+			"videowall": ['participant'],
+			"videowall-queue": ['participant'],
+			"videowall-queue-video": ['participant'],
+		},
+		observerSolo5: {
+			"watchparty": ['participant'],
+			"studio": ['participant'],
+			"commentary": ['participant'],
+			"intercom": ['participant'],
+			"videowall": ['participant'],
+			"videowall-queue": ['participant'],
+			"videowall-queue-video": ['participant'],
+		},
+		host: {
+			"watchparty": [],
+			"studio": [],
+			"commentary": [],
+			"intercom": [],
+			"videowall": [],
+			"videowall-queue": [],
+			"videowall-queue-video": [],
+		},
+		companionTV: {},
+		companionPhone: {},
+	};
+
+	#publisherHandle = null;
+	#subscriberHandle = null;
+	#subscriberJoinPromise = null;
+
+	// Configuration for simulcast quality selection
+	#rtcStatsConfig = {
+		// Network thresholds
+		packetLossThreshold: 3.0,       // Percentage of packet loss to trigger downgrade
+		jitterBufferThreshold: 100,     // ms of jitter buffer delay to trigger downgrade
+		roundTripTimeThreshold: 250,    // ms of RTT to trigger downgrade
+		frameDropRateThreshold: 5,      // Percentage of frame drops to trigger downgrade
+		freezeLengthThreshold: 0.7, 		// 70% of freeze time for current monitored period
+		// Hysteresis to prevent rapid switching (ms)
+		switchCooldown: 15000, // Min time between switches
+		switchCooldownForFreeze: 3000,
+		historySize: 60000,           // Ms of history to keep
+		badBandwidthThresholdMultiplier: 0.8,  // 80% of required bitrate
+		// Stability thresholds
+		stableNetworkTime: 10000, 	   // Time in ms to consider network stable
+	};
+
+
+	constructor(constructId = null, type = 'reactooroom', options = {}) {
+
+		Object.assign(this, emitter());
+		this.options = {...options};
+		this.defaultDataChannelLabel = 'JanusDataChannel'
+		this.server = null;
+		this.iceServers = null;
+		this.token = null;
+		this.roomId = null;
+		this.pin = null;
+		this.userId = null;
+		this.initialBitrate = 0;
+		this.enableDtx = false;
+		this.simulcast = false;
+
+		this.defaultSimulcastSettings = {
+			"default" : {
+				mode: "controlled", // controlled, manual, browserControlled
+				defaultSubstream: 0, // 2 lowest quality, 0 highest quality
+				bitrates: [
+					{
+						"rid": "l",
+						"active": true,
+						"maxBitrate": 180000,
+						"maxFramerate": 20,
+						"scaleResolutionDownBy": 3.3333333333333335,
+						"priority": "low"
+					},
+					{
+						"rid": "m",
+						"active": true,
+						"maxBitrate": 500000,
+						"maxFramerate": 25,
+						"scaleResolutionDownBy": 1.3333333333333335,
+						"priority": "low"
+					},
+					{
+						"rid": "h",
+						"active": true,
+						"maxBitrate": 2000000,
+						"maxFramerate": 30,
+						"priority": "low"
+					}
+				]
+			},
+		};
+		this.recordingFilename = null;
+		this.pluginName = RoomSession.sessionTypes[type];
+		this.id = null;
+		this.privateId = null;
+		this.handleId = null;
+		this.constructId = constructId || RoomSession.randomString(16);
+		this.sessionId = null;
+		this.apisecret = null;
+		this.ws = null;
+
+		// helper flags
+
+		this.isSupposeToBeConnected = false;
+		this.isConnecting = false;
+		this.isEstablishingConnection = false;
+		this.isDisconnecting = false;
+		this.isConnected = false;
+		this.isPublished = false;
+
+		this.isMuted = [];
+
+		this.requestMuteStatusTimeoutId = null;
+		this.requestMuteStatusTimeout = 100;
+		this._statsInterval = 3000;
+		this._statsIntervalId = null;
+		this._sendMessageTimeout = 10000;
+		this._keepAlivePeriod = 25000;
+		this._longPollTimeout = 60000;
+		this._maxev = 10;
+		this._keepAliveId = null;
+		this._restrictSubscribeToUserIds = []; // all if empty
+		this._talkIntercomChannels = ['participants'];
+		this._listenIntercomChannels = ['participants'];
+		this._roomType = 'watchparty';
+		this._isDataChannelOpen = false;
+		this._abortController = null;
+
+		this.userRoleSubscriptionRules = {
+			...RoomSession.userRoleSubscriptionRules,
+			...(this.options.userRoleSubscriptionRules || {})
+		}
+
+		this._log = RoomSession.noop;
+		if (this.options.debug) {
+			this.#enableDebug();
+		}
+
+	}
+
+	#httpAPICall = function(url, options) {
+		return new Promise((resolve, reject) => {
+			const xhr = new XMLHttpRequest();
+
+			xhr.open(options.verb || 'POST', url);
+
+			// Set default headers
+			xhr.setRequestHeader('Accept', 'application/json, text/plain, */*');
+			if (options.verb === "POST") {
+				xhr.setRequestHeader('Content-Type', 'application/json');
+			}
+
+			// Handle credentials
+			if (options.withCredentials) {
+				xhr.withCredentials = true;
+			}
+
+			// Set timeout if specified
+			if (options.timeout) {
+				xhr.timeout = options.timeout;
+			}
+
+			// Setup handlers
+			xhr.onload = function() {
+				if (xhr.status >= 200 && xhr.status < 300) {
+					let response;
+					try {
+						response = JSON.parse(xhr.responseText);
+					} catch(e) {
+						if (options.error) {
+							options.error('Invalid JSON', xhr.responseText);
+						}
+						reject('Invalid JSON');
+						return;
+					}
+					if (options.success) {
+						options.success(response);
+					}
+					resolve(response);
+				} else {
+					let errorText = xhr.statusText || 'HTTP Error';
+					if (options.error) {
+						options.error(errorText, xhr.responseText);
+					}
+					reject(errorText);
+				}
+			};
+
+			xhr.onerror = function() {
+				let errorText = 'Network error';
+				if (options.error) {
+					options.error(errorText, 'Is the server down?');
+				}
+				reject(errorText);
+			};
+
+			xhr.ontimeout = function() {
+				let errorText = 'Request timed out';
+				if (options.error) {
+					options.error(errorText, 'Is the server down?');
+				}
+				reject(errorText);
+			};
+
+			// Send request
+			try {
+				if (options.body) {
+					xhr.send(JSON.stringify(options.body));
+				} else {
+					xhr.send();
+				}
+			} catch(e) {
+				if (options.error) {
+					options.error('Error sending request', e);
+				}
+				reject(e);
+			}
+		});
+	}
+
+	#cacheAttendee(attendee) {
+		if(this.#subscriberHandle) {
+			this.#subscriberHandle.webrtcStuff.userIdToDisplay[attendee.id] = attendee.display;
+		}
+	};
+	
+	#removeAttendeeFromCache(id) {
+		if(this.#subscriberHandle) {
+			delete this.#subscriberHandle.webrtcStuff.userIdToDisplay[id];
+		}
+	}
+
+	#getCachedAttendeeIds() {
+		return Object.keys(this.#subscriberHandle?.webrtcStuff?.userIdToDisplay || {});
+	}
+
+	#getDisplayById(id) {
+		return this.#subscriberHandle.webrtcStuff.userIdToDisplay[id];
+	}
+
+	#emitLocalFeedUpdate({feedRemoval = false, addingTrack = false, removingTrack = false, track = null, source = null, mid = null} = {}) {
+
+		if(!this.id) {
+			// we're not connected probably at all
+			return;
+		}
+
+		const eventName = !feedRemoval ? 'addLocalParticipant' : 'removeLocalParticipant';
+		const streamMap = this.#getStreamMapForFeed(this.id);
+
+		const sourceTrackIds = streamMap[source] ?? [];
+		const sourceRelatedTracks = this.#publisherHandle?.webrtcStuff?.tracks?.filter(t => sourceTrackIds.includes(t.id)) ?? [];
+
+		const tracks = this.#publisherHandle?.webrtcStuff?.tracks ?? [];
+
+		this.emit(eventName, {
+			tid: generateUUID(),
+			id: this.id,
+			constructId: this.constructId,
+			userId: decodeJanusDisplay(this.userId)?.userId,
+			fullUserId: this.display,
+			role: decodeJanusDisplay(this.display)?.role,
+			track: track,
+			source: source,
+			adding: addingTrack,
+			removing: removingTrack,
+			streamMap: streamMap,
+			sourceRelatedTracks: sourceRelatedTracks,
+			tracks: tracks.map(t=>t),
+			hasAudioTrack: !!tracks.find(track => track.kind === 'audio'),
+			hasVideoTrack: !!tracks.find(track => track.kind === 'video'),
+		});
+	}
+
+	#emitRemoteFeedUpdate(mid, {feedRemoval = false, addingTrack = false, removingTrack = false, track = null, source = null, attendee = null} = {}) {
+
+		const transceiverData = this.#getTransceiverDataByMid(mid);
+
+		if(transceiverData) {
+
+			const id = transceiverData.feed_id;
+			const display = transceiverData.feed_display;
+			const parsedDisplay = decodeJanusDisplay(display);
+			let description = {};
+			try {
+				description = JSON.parse(transceiverData.feed_description);
+			} catch (e) {}
+
+			if(!this.#shouldEmitFeedUpdate(parsedDisplay)) {
+				this._log('Not emitting feed update for', display, 'because of subscription rules');
+				// we don't want to emit this event
+				return;
+			}
+
+			const source = description.source;
+			const role = parsedDisplay?.role;
+			const userId = parsedDisplay?.userId;
+			const eventName = this.#getParticipantEventName(!feedRemoval, role);
+			const streamMap = this.#getStreamMapForFeed(id);
+
+			const sourceTrackIds = streamMap[source] ?? [];
+			const sourceRelatedTracks = this.#subscriberHandle?.webrtcStuff?.tracks?.filter(t => sourceTrackIds.includes(t.id)) ?? [];
+
+			const trackIds = Object.keys(streamMap).reduce((acc, key) => {
+				streamMap[key].forEach(trackId => {
+					if (!acc.includes(trackId)) {
+						acc.push(trackId);
+					}
+				});
+				return acc;
+			}, []);
+
+			const tracks = this.#subscriberHandle?.webrtcStuff?.tracks?.filter(t => trackIds.includes(t.id)) ?? [];
+
+			this.emit(eventName, {
+				tid: generateUUID(),
+				id,
+				userId,
+				role,
+				fullUserId: display,
+				constructId: this.constructId,
+				track: track,
+				source: source,
+				adding: addingTrack,
+				removing: removingTrack,
+				streamMap,
+				sourceRelatedTracks,
+				tracks,
+				hasAudioTrack: !!tracks.find(track => track.kind === 'audio'),
+				hasVideoTrack: !!tracks.find(track => track.kind === 'video'),
+
+			});
+
+		} else if(attendee) {
+
+			const id = attendee.id;
+			const display = this.#getDisplayById(id);
+			const parsedDisplay = decodeJanusDisplay(display);
+
+			if(!this.#shouldEmitFeedUpdate(parsedDisplay)) {
+				this._log('Not emitting feed update for', display, 'because of subscription rules');
+				// we don't want to emit this event
+				return;
+			}
+
+			const role = parsedDisplay?.role;
+			const userId = parsedDisplay?.userId;
+			const streamMap = this.#getStreamMapForFeed(id);
+			const eventName = this.#getParticipantEventName(!feedRemoval, role);
+
+			this.emit(eventName, {
+				tid: generateUUID(),
+				id,
+				userId,
+				role,
+				fullUserId: display,
+				constructId: this.constructId,
+				track: null,
+				source: null,
+				adding: false,
+				removing: false,
+				streamMap,
+				sourceRelatedTracks: [],
+				tracks: [],
+				hasAudioTrack: false,
+				hasVideoTrack: false,
+			});
+		}
+
+		// ask for current mute status to each participant
+
+		clearTimeout(this.requestMuteStatusTimeoutId);
+		this.requestMuteStatusTimeoutId = setTimeout(() => {
+			if(this.isConnected) {
+				this.emit('requestMuteStatus')
+			}
+		}, this.requestMuteStatusTimeout)
+
+	}
+
+	#emitRemoteTrackMuted(mid, {track, muted} = {}) {
+
+		const transceiverData = this.#getTransceiverDataByMid(mid);
+
+		if(transceiverData) {
+
+			const id = transceiverData.feed_id;
+			const display = transceiverData.feed_display;
+			const parsedDisplay = decodeJanusDisplay(display);
+			let description = {};
+			try {
+				description = JSON.parse(transceiverData.feed_description);
+			} catch (e) {}
+
+			const source = description.source;
+			const role = parsedDisplay?.role;
+			const userId = parsedDisplay?.userId;
+			const streamMap = this.#getStreamMapForFeed(id);
+
+			this.emit('remoteTrackMuted', {
+				tid: generateUUID(),
+				id,
+				userId,
+				role,
+				mid,
+				fullUserId: display,
+				constructId: this.constructId,
+				streamMap,
+				source,
+				kind: track.kind,
+				track:track,
+				muted
+			});
+		}
+	}
+
+	#getStreamMapForFeed(id) {
+		if (id === this.id) {
+			return this.#publisherHandle?.webrtcStuff?.streamMap?.[id] || {};
+		}
+		else {
+			return this.#subscriberHandle?.webrtcStuff?.streamMap?.[id] || {};
+		}
+	}
+
+	#isSubscribedToMid(id, mid) {
+		if(this.#subscriberHandle) {
+			return !!this.#subscriberHandle.webrtcStuff.subscribeMap?.[id]?.[mid]
+		}
+		return false;
+	}
+
+	#addToSubscribeMap(id, mid) {
+		if(this.#subscriberHandle) {
+			this.#subscriberHandle.webrtcStuff.subscribeMap[id] = this.#subscriberHandle.webrtcStuff.subscribeMap[id] || {};
+			this.#subscriberHandle.webrtcStuff.subscribeMap[id][mid] = true;
+		}
+	}
+
+	#removeFromSubscribeMap(id, mid) {
+		if(this.#subscriberHandle) {
+			if(id && !mid) {
+				delete this.#subscriberHandle.webrtcStuff.subscribeMap[id];
+			}
+			else if(id && mid && this.#subscriberHandle.webrtcStuff.subscribeMap[id]) {
+				delete this.#subscriberHandle.webrtcStuff.subscribeMap[id][mid];
+			}
+		}
+	}
+
+	// will subscribe to all relevant participants
+
+	async #updateSubscriptions() {
+
+		// no subscriber handle, we create one and subscribe to relevant participants
+
+		if(!this.#subscriberJoinPromise) {
+			await this.#joinAsSubscriber(this.roomId,  this.pin, this.userId);
+		}
+
+		else {
+
+			// we have a subscriber handle, we need to check if we need to update subscriptions
+			// if subscriber handle is not ready yet, we wait for it to be ready
+			// if it fails, we try to create a new one
+			// if it succeeds, we check if we need to update subscriptions
+
+			try {
+				await this.#subscriberJoinPromise;
+			} catch (e) {
+				await this.#joinAsSubscriber(this.roomId,  this.pin, this.userId);
+				return;
+			}
+
+			const handle = this.#subscriberHandle;
+			const subscribedTo = handle.webrtcStuff.subscribeMap || {};
+			const publishers = handle.webrtcStuff.availablePublishers;
+			const subscribe = [];
+			const unsubscribe = [];
+			const flatSourceMap = [];
+
+			for (let index in publishers) {
+				if(publishers[index]["dummy"])
+					continue;
+
+				let userId = publishers[index]["display"];
+				let id = publishers[index]["id"];
+				let streams = publishers[index]["streams"] || [];
+				let description = {};
+
+				try {
+					const dString = streams.find(s => !!s.description)?.description;
+					if(dString) {
+						description = JSON.parse(dString);
+					}
+				} catch (e) {}
+
+				this._log('Remote publisher: ', id, userId, streams, description);
+
+				for (let i in streams) {
+					const track = streams[i];
+					const mid = track.mid; // source.mid
+					flatSourceMap.push({id: id, mid: mid});
+
+					const isSubscribed = this.#isSubscribedToMid(id, mid);
+
+					if(track.disabled) {
+						if(isSubscribed) {
+							unsubscribe.push({feed: id, mid: mid});
+							this.#removeFromSubscribeMap(id, mid);
+						}
+						continue;
+					}
+
+					if(!this.#shouldSubscribeParticipant(id, userId, description)) {
+						if(isSubscribed) {
+							unsubscribe.push({feed: id, mid: mid});
+							this.#removeFromSubscribeMap(id, mid);
+						}
+						continue;
+					}
+
+					if(!isSubscribed) {
+						subscribe.push({feed: id, mid: mid});
+						this.#addToSubscribeMap(id, mid);
+					}
+				}
+			}
+
+			// check if we're subscribed to any mid that is no longer available in sources
+
+			Object.keys(subscribedTo).forEach(id => {
+				const mids = Object.keys(subscribedTo[id]);
+				for(let mid of mids) {
+					if(!flatSourceMap.find(s => s.id === id && s.mid === mid)) {
+						unsubscribe.push({feed: id, mid});
+						this.#removeFromSubscribeMap(id, mid);
+					}
+				}
+			})
+
+			if(subscribe.length || unsubscribe.length) {
+				await this.sendMessage(handle.handleId, {
+					body: {
+						"request": "update",
+						...(subscribe.length ? {subscribe}: {}),
+						...(unsubscribe.length ? {unsubscribe}: {})
+					}
+				});
+			}
+		}
+	}
+
+	#updatePublishersStreamMap() {
+		if(this.#subscriberHandle) {
+			let handle = this.#subscriberHandle;
+			handle.webrtcStuff.streamMap = {};
+			handle.webrtcStuff.transceiverMap.forEach(tItem => {
+				if(tItem.type === 'data') {
+					return;
+				}
+				if(tItem.active === false) {
+					return;
+				}
+				const id = tItem.feed_id;
+				const source = JSON.parse(tItem.feed_description)?.source;
+
+				if(!handle.webrtcStuff.streamMap[id]) {
+					handle.webrtcStuff.streamMap[id] = {};
+				}
+
+				if(!handle.webrtcStuff.streamMap[id][source]) {
+					handle.webrtcStuff.streamMap[id][source] = [];
+				}
+				let trackId = handle.webrtcStuff.pc.getTransceivers().find(t => t.mid === tItem.mid)?.receiver?.track?.id;
+
+				if(trackId) {
+					handle.webrtcStuff.streamMap[id][source].push(trackId);
+				}
+			})
+		}
+	}
+
+	#updateAvailablePublishersTrackData(newPublishers, removedPublisher) {
+		if(this.#subscriberHandle) {
+			for(let publisher of newPublishers) {
+				const publisherIndex = this.#subscriberHandle.webrtcStuff.availablePublishers.findIndex(p => p.id === publisher.id);
+
+				if(publisherIndex > -1) {
+					this.#subscriberHandle.webrtcStuff.availablePublishers.splice(publisherIndex, 1, publisher);
+				}
+				else {
+					this.#subscriberHandle.webrtcStuff.availablePublishers.push(publisher);
+				}
+
+			}
+			if(removedPublisher !== undefined) {
+				this.#subscriberHandle.webrtcStuff.availablePublishers = this.#subscriberHandle.webrtcStuff.availablePublishers.filter(p => p.id !== removedPublisher);
+			}
+		}
+	}
+
+	#getTransceiverDataByMid(mid) {
+		return this.#subscriberHandle.webrtcStuff.transceiverMap.find(t => t.mid === mid);
+	}
+
+	// this is done
+	// feed_id === id of participant
+
+	#updateTransceiverMap(handleId, streams = []) {
+		this._log('Updating current transceiver map', 'Is me: ' + handleId === this.#publisherHandle.handleId, handleId, streams);
+		let handle = this.#getHandle(handleId);
+		if (!handle) {
+			this.emit('error', {
+				type: 'warning',
+				id: 1,
+				message: 'id non-existent',
+				data: [handleId, 'updateTransceiverMap']
+			});
+			return;
+		}
+		let config = handle.webrtcStuff;
+
+		// we need to add new transceivers, update existing transceivers, remove transceivers that are not in streams anymore
+		const mids = []
+		for(let stream of streams) {
+			mids.push(stream.mid);
+			const index = config.transceiverMap.findIndex(t => t.mid === stream.mid);
+			if(index > -1) {
+				config.transceiverMap[index] = {...config.transceiverMap[index], ...stream};
+			}
+			else {
+				config.transceiverMap.push(stream);
+			}
+		}
+		config.transceiverMap = config.transceiverMap.filter(t => mids.includes(t.mid));
+	}
+
+	#getParticipantEventName(adding = true,participantRole) {
+		if(adding) {
+			switch (participantRole) {
+				case 'participant':
+					return 'addRemoteParticipant';
+				case 'talkback':
+					return 'addRemoteTalkback';
+				case 'monitor':
+					return 'addRemoteTalkback';
+				case 'observer':
+				case 'observerSolo1':
+				case 'observerSolo2':
+				case 'observerSolo3':
+				case 'observerSolo4':
+				case 'observerSolo5':
+					return 'addRemoteObserver';
+				case 'host':
+					return 'addRemoteInstructor';
+				case 'companionTV':
+					return 'addRemoteCompanionTV';
+				case 'companionPhone':
+					return 'addRemoteCompanionPhone';
+				default:
+					return 'addRemoteParticipant';
+			}
+		}
+		else {
+			switch (participantRole) {
+				case 'participant':
+					return 'removeRemoteParticipant';
+				case 'talkback':
+					return 'removeRemoteTalkback';
+				case 'monitor':
+					return 'removeRemoteTalkback';
+				case 'observer':
+				case 'observerSolo1':
+				case 'observerSolo2':
+				case 'observerSolo3':
+				case 'observerSolo4':
+				case 'observerSolo5':
+					return 'removeRemoteObserver';
+				case 'host':
+					return 'removeRemoteInstructor';
+				case 'companionTV':
+					return 'removeRemoteCompanionTV';
+				case 'companionPhone':
+					return 'removeRemoteCompanionPhone';
+				default:
+					return 'removeRemoteParticipant';
+			}
+		}
+	}
+
+	async sendMessage(handleId, message = {body: 'Example Body'}, dontWait = false, dontResolveOnAck = false, retry = 0) {
+		return this.#send({
+			"janus": "message",
+			"handle_id": handleId,
+			...message
+		}, dontWait, dontResolveOnAck, retry)
+			.then(json => {
+				if (json && json["janus"] === "success") {
+					let plugindata = json["plugindata"] || {};
+					let data = plugindata["data"];
+					return Promise.resolve(data);
+				}
+				return Promise.resolve();
+			})
+			.catch(json => {
+				if (json && json["error"]) {
+					return Promise.reject({type: 'warning', id: 2, message: 'sendMessage failed', data: json["error"]})
+				} else {
+					return Promise.reject({type: 'warning', id: 3, message: 'sendMessage failed', data: json});
+				}
+			})
+	}
+
+	async #sendHTTP(request = {}, ignoreResponse = false, dontResolveOnAck = false, retry = 0) {
+		let transaction = RoomSession.randomString(12);
+		let requestData = {
+			...request,
+			transaction,
+			token: this.token,
+			...((this.sessionId && {'session_id': this.sessionId}) || {}),
+			...((this.apisecret && {'apisecret': this.apisecret}) || {})
+		};
+		this._log(requestData);
+		return this.#httpAPICall(this.server, {body:requestData})
+			.then(json => {
+				if(json['janus'] !== 'success' && json['janus'] !== 'ack') {
+					// not a success not an ack ... should be error
+					return Promise.reject(json["error"])
+				}
+				return json;
+			})
+	}
+
+	async #sendWebsockets(request = {}, ignoreResponse = false, dontResolveOnAck = false, retry = 0) {
+		let transaction = RoomSession.randomString(12);
+		let requestData = {
+			...request,
+			transaction,
+			token: this.token,
+			...((this.sessionId && {'session_id': this.sessionId}) || {}),
+			...((this.apisecret && {'apisecret': this.apisecret}) || {})
+		};
+		this._log(requestData);
+		const op = () => new Promise((resolve, reject) => {
+			let messageTimeoutId = null;
+			let abortResponse = () => {
+				this._abortController.signal.removeEventListener('abort', abortResponse);
+				clearTimeout(messageTimeoutId);
+				this.ws.removeEventListener('message', parseResponse);
+				reject({type: 'warning', id: 4, message: 'connection cancelled'})
+			};
+
+			let parseResponse = (event) => {
+				let json = JSON.parse(event.data);
+				let r_transaction = json['transaction'];
+				if (r_transaction === transaction && (!dontResolveOnAck || json['janus'] !== 'ack')) {
+					clearTimeout(messageTimeoutId);
+					this._abortController.signal.removeEventListener('abort', abortResponse);
+					this.ws.removeEventListener('message', parseResponse);
+					if (json['janus'] === 'error') {
+						if (json?.error?.code == 403) {
+							this.disconnect();
+						}
+						reject({type: 'error', id: 5, message: 'send failed', data: json, requestData});
+					} else {
+						resolve(json);
+					}
+				}
+			};
+
+			if (ignoreResponse) {
+				if (this.ws && this.ws.readyState === 1) {
+					this.ws.send(JSON.stringify(requestData));
+				}
+				resolve();
+			} else {
+				if (this.ws && this.ws.readyState === 1) {
+					this.ws.addEventListener('message', parseResponse);
+					messageTimeoutId = setTimeout(() => {
+						this.ws.removeEventListener('message', parseResponse);
+						this._abortController.signal.removeEventListener('abort', abortResponse);
+						reject({type: 'warning', id: 6, message: 'send timeout', data: requestData});
+					}, this._sendMessageTimeout);
+					this._abortController.signal.addEventListener('abort', abortResponse);
+					this.ws.send(JSON.stringify(requestData));
+				} else {
+					reject({type: 'warning', id: 7, message: 'No connection to WebSockets', data: requestData});
+				}
+			}
+		})
+
+		return op().catch(e => {
+			if (e.id === 17) {
+				return Promise.reject(e);
+			}
+			else if(e.id === 29 && retry > 0) {
+				return wait(this._sendMessageTimeout).then(() => this.#send(request, ignoreResponse, dontResolveOnAck, retry - 1));
+			}
+			else if(retry > 0) {
+				return this.#send(request, ignoreResponse, dontResolveOnAck, retry - 1);
+			}
+			else {
+				return Promise.reject(e);
+			}
+		})
+	}
+
+	async #send(request = {}, ignoreResponse = false, dontResolveOnAck = false, retry = 0) {
+		if(this.useWebsockets) {
+			return this.#sendWebsockets(request, ignoreResponse, dontResolveOnAck, retry);
+		}
+		else {
+			return this.#sendHTTP(request, ignoreResponse, dontResolveOnAck, retry)
+		}
+	}
+
+	#longPoll() {
+
+		if(!this.isSupposeToBeConnected) {
+			return;
+		}
+
+		let longpoll = this.server + "/" + this.sessionId + "?rid=" + new Date().getTime();
+		if(this._maxev)
+			longpoll = longpoll + "&maxev=" + this._maxev;
+		if(this.token)
+			longpoll = longpoll + "&token=" + encodeURIComponent(this.token);
+		if(this.apisecret)
+			longpoll = longpoll + "&apisecret=" + encodeURIComponent(this.apisecret);
+
+		this.#httpAPICall(longpoll, {
+			verb: 'GET',
+			timeout: this._longPollTimeout
+		})
+			.then(this.#handleWsEvents.bind(this))
+			.catch(() => {
+				this.#longPoll();
+			})
+	}
+
+	#connectionClosed() {
+
+		if (!this.isConnected || this.isConnecting || this.isDisconnecting) {
+			return;
+		}
+
+		this.#reconnect()
+			.catch(e => {
+				if(e.type !== 'warning') {
+					this.disconnect();
+				}
+				this.emit('error', e)
+			});
+	}
+
+	#wipeListeners() {
+		if (this.ws) {
+			this.ws.removeEventListener('close', this.__connectionClosedBoundFn);
+			this.ws.removeEventListener('message', this.__handleWsEventsBoundFn);
+		}
+	}
+
+	#startKeepAlive() {
+		this.#send({"janus": "keepalive"})
+			.then(json => {
+				if (json["janus"] !== 'ack') {
+					this.emit('error', {
+						type: 'warning',
+						id: 8,
+						message: 'keepalive response suspicious',
+						data: json["janus"]
+					});
+				}
+			})
+			.catch((e) => {
+				this.emit('error', {type: 'warning', id: 9, message: 'keepalive dead', data: e});
+				this.#connectionClosed();
+			});
+
+		this._keepAliveId = setTimeout(() => {
+			this.#startKeepAlive();
+		}, this._keepAlivePeriod);
+	}
+
+	#stopKeepAlive() {
+		clearTimeout(this._keepAliveId);
+	}
+
+	#handleWsEvents(event, skipPoll = false) {
+
+		// we have a response from long poll, that means we need to run it again
+		if(!this.useWebsockets && !skipPoll) {
+			this.#longPoll();
+		}
+
+		if(!this.useWebsockets && skipPoll) {
+			// we need to fire those events into the wild
+			this.emit('longPollEvent', event);
+		}
+
+		if(Array.isArray(event)) {
+			event.forEach(ev => this.#handleWsEvents({data:ev}, true));
+			return;
+		}
+
+		let json = typeof event.data === 'string'
+			? JSON.parse(event.data)
+			: event.data;
+
+		var sender = json["sender"];
+		var type = json["janus"];
+
+		let handle = this.#getHandle(sender);
+		if (!handle) {
+			return;
+		}
+
+		if (type === "trickle") {
+			let candidate = json["candidate"];
+			let config = handle.webrtcStuff;
+			if (config.pc && config.remoteSdp) {
+
+				if (!candidate || candidate.completed === true) {
+					config.pc.addIceCandidate(null).catch((e) => {
+						this._log('Error adding null candidate', e);
+					});
+				} else {
+					config.pc.addIceCandidate(candidate).catch((e) => {
+						this._log('Error adding candidate', e);
+					});
+				}
+			} else {
+				if (!config.candidates) {
+					config.candidates = [];
+				}
+				config.candidates.push(candidate);
+			}
+		} else if (type === "webrtcup") {
+			//none universal
+		} else if (type === "hangup") {
+			this._log('hangup on', handle.handleId, handle.handleId === this.#publisherHandle.handleId, json);
+			if(this.#getHandle(handle.handleId)) {
+				this.#cleanupHandle(handle.handleId, true).catch(() => {});
+			}
+		} else if (type === "detached") {
+			this._log('detached on', handle.handleId, handle.handleId === this.#publisherHandle.handleId, json);
+			if(this.#getHandle(handle.handleId)) {
+				this.#destroyHandle(handle.handleId).catch(() => {});
+			}
+		} else if (type === "media") {
+			this._log('Media event:', handle.handleId, json["type"], json["receiving"], json["mid"]);
+		} else if (type === "slowlink") {
+			this._log('Slowlink', handle.handleId, json["uplink"], json["lost"], json["mid"]);
+		} else if (type === "event") {
+			//none universal
+		} else if (type === 'timeout') {
+			this._log('WebSockets Gateway timeout', json);
+			this.ws.close(3504, "Gateway timeout");
+		} else if (type === 'success' || type === 'error') {
+			// we're capturing those elsewhere
+		} else {
+			this._log(`Unknown event: ${type} on session: ${this.sessionId}`);
+		}
+
+
+		// LOCAL
+
+		if (sender === this.#publisherHandle.handleId) {
+			if (type === "event") {
+
+				var plugindata = json["plugindata"] || {};
+				var msg = plugindata["data"] || {};
+				var jsep = json["jsep"];
+				let result = msg["result"] || null; // related to streaming plugin
+				let event = msg["videoroom"] || null;
+				let attendees = msg["attendees"] ?? [];
+				let list = msg["publishers"] || [];
+				let leaving = msg["leaving"];
+				let kicked = msg["kicked"];
+				let substream = msg["substream"];
+				let temporal = msg["temporal"] ?? msg["temporal_layer"];
+				let spatial = msg["spatial_layer"];
+				let joining = msg["joining"];
+				let unpublished = msg["unpublished"];
+				let error = msg["error"];
+
+				if (event === "joined") {
+
+					this.id = msg["id"];
+					this.privateId = msg["private_id"];
+					this.isConnected = true;
+					
+					this._log('We have successfully joined Room',msg);
+					this.emit('joined', true, this.constructId);
+					// initial events
+
+					attendees.forEach((attendee) => {
+						this.#cacheAttendee(attendee);
+						this.#emitRemoteFeedUpdate(null, {attendee});
+					})
+
+					list.forEach((publisher) => {
+						this.#cacheAttendee(publisher);
+						this.#emitRemoteFeedUpdate(null, {attendee: publisher});
+					});
+
+					// end of initial events
+					this.#emitLocalFeedUpdate();
+					this.#updateAvailablePublishersTrackData(list);
+					this.#updateSubscriptions()
+						.catch((e) => {
+							this._log(e);
+						});
+					
+				}
+				else if (event === "event") {
+
+					if(substream !== undefined && substream !== null) {
+						this._log('Substream event:', substream, sender);
+					}
+
+					if(temporal !== undefined && temporal !== null) {
+						this._log('Temporal event:', temporal);
+					}
+
+					if (msg["streams"] !== undefined && msg["streams"] !== null) {
+						this._log('Got my own streams back', msg["streams"]);
+						this.#updateTransceiverMap(handle.handleId, msg["streams"]);
+					}
+
+					this.#updateAvailablePublishersTrackData(list);
+					this.#updateSubscriptions()
+						.catch((e) => {
+							this._log(e);
+						});
+
+
+					if (leaving === 'ok') {
+						this._log('leaving', this.#publisherHandle.handleId, 'this is us');
+						
+						this.#emitLocalFeedUpdate({feedRemoval: true});
+
+						if (msg['reason'] === 'kicked') {
+							this.emit('kicked');
+							this.disconnect().catch(() => {});
+						}
+					} else if (leaving) {
+
+						this._log('leaving', leaving);
+						this.#updateAvailablePublishersTrackData([], leaving);
+						this.#updateSubscriptions()
+							.catch((e) => {
+									this._log(e);
+								});
+
+						this.#emitRemoteFeedUpdate(null, {feedRemoval: true, attendee: {id:leaving}});
+						this.#removeAttendeeFromCache(leaving);
+					}
+
+					if (unpublished === 'ok') {
+						this._log('unpublished', this.#publisherHandle.handleId, 'this is us');
+						this.#cleanupHandle(this.#publisherHandle.handleId, true).catch(() => {});
+
+					} else if (unpublished) {
+						this._log('unpublished', unpublished);
+						this.#updateAvailablePublishersTrackData([], unpublished);
+						this.#updateSubscriptions()
+							.catch((e) => {
+								this._log(e);
+							});
+					}
+
+					if(kicked === 'ok') {
+						// this case shouldn't exist
+					} else if(kicked) {
+						this._log('kicked', kicked);
+						this.#updateAvailablePublishersTrackData([], kicked);
+						this.#updateSubscriptions()
+							.catch((e) => {
+								this._log(e);
+							});
+					}
+
+					if(joining) {
+						this.#cacheAttendee(joining);
+						this.#emitRemoteFeedUpdate(null, {attendee: joining});
+					}
+
+					if (error) {
+						this.emit('error', {
+							type: 'error',
+							id: 10,
+							message: 'local participant error',
+							data: [sender, msg]
+						});
+					}
+				}
+
+				if (jsep !== undefined && jsep !== null) {
+					this.#webrtcPeer(this.#publisherHandle.handleId, jsep)
+						.catch(err => {
+							this.emit('error', err);
+						});
+				}
+			}
+			else if (type === "webrtcup") {
+
+				if(this.simulcast) {
+					return;
+				}
+
+				this._log('Configuring bitrate: ' + this.initialBitrate);
+				if (this.initialBitrate > 0) {
+					this.sendMessage(this.#publisherHandle.handleId, {
+						"body": {
+							"request": "configure",
+							"bitrate": this.initialBitrate
+						}
+					}).catch(() => null)
+				}
+			}
+		}
+
+		//REMOTE
+
+		else {
+
+			let plugindata = json["plugindata"] || {};
+			let msg = plugindata["data"] || {};
+			let jsep = json["jsep"];
+			let event = msg["videoroom"];
+			let error = msg["error"];
+			let substream = msg["substream"];
+			let temporal = msg["temporal"] ?? msg["temporal_layer"];
+			let spatial = msg["spatial_layer"];
+			let mid = msg["mid"];
+
+			if(substream !== undefined && substream !== null) {
+				this._log('Substream: ', sender, mid, substream);
+				this.#setSelectedSubstream(sender, mid, substream);
+				this.requestKeyFrame(sender, mid);
+			}
+
+			if(temporal !== undefined && temporal !== null) {
+				this._log('Temporal: ', temporal);
+				this.#setSelectedTemporal(sender, mid, temporal);
+			}
+
+			if(type === "webrtcup") {
+				this.requestKeyFrame(handle.handleId);
+			}
+
+			if (event === "updated") {
+				this._log('Remote has updated tracks', msg);
+			}
+
+			if (event === "attached") {
+				this._log('Subscriber handle successfuly created', msg);
+			}
+
+			if(msg["streams"]) {
+				this.#updateTransceiverMap(handle.handleId, msg["streams"]);
+			}
+
+			if (error) {
+				this.emit('error', {type: 'warning', id: 11, message: 'remote participant error', data: [sender, msg]});
+			}
+
+			if (jsep) {
+				this.#publishRemote(handle.handleId, jsep)
+					.catch(err => {
+						this.emit('error', err);
+					});
+			}
+		}
+	}
+
+	#handleDataChannelEvents(handleId, type, data) {
+
+		let handle = this.#getHandle(handleId);
+
+		if (type === 'state') {
+			this._log(` - Data channel status - `, `UID: ${handleId}`, `STATUS: ${JSON.stringify(data)}`)
+			if (handle) {
+				let config = handle.webrtcStuff;
+				config.dataChannelOpen = this.defaultDataChannelLabel === data?.label && data?.state === 'open';
+			}
+
+			if (handleId === this.#publisherHandle.handleId && this.defaultDataChannelLabel === data?.label) {
+				this._isDataChannelOpen = data?.state === 'open';
+				this.emit('dataChannel', data?.state === 'open');
+			}
+		}
+
+		if (type === 'error') {
+
+			this.emit('error', {
+				type: 'warning',
+				id: 12,
+				message: 'data event warning',
+				data: [handleId, data]
+			});
+
+			if (handle) {
+				let config = handle.webrtcStuff;
+				if(this.defaultDataChannelLabel === data.label) {
+					config.dataChannelOpen = false;
+				}
+			}
+			if (handleId === this.#publisherHandle.handleId && this.defaultDataChannelLabel === data.label) {
+				this._isDataChannelOpen = false;
+				this.emit('dataChannel', false);
+			}
+		}
+
+		if (handleId === this.#publisherHandle.handleId && type === 'message') {
+
+			let d = null;
+
+			try {
+				d = JSON.parse(data)
+			} catch (e) {
+				this.emit('error', {type: 'warning', id: 13, message: 'data message parse error', data: [handleId, e]});
+				return;
+			}
+			this.emit('data', d);
+		}
+
+	}
+
+	async #createHandle() {
+		return this.#send({
+			"janus": "attach",
+			"plugin": this.pluginName,
+		}).then(json => {
+			let handleId = json.data["id"];
+			return {
+				handleId,
+				webrtcStuff: {
+					mySdp: null,
+					mediaConstraints: null,
+					pc: null,
+					dataChannelOpen: false,
+					dataChannel: null,
+					dtmfSender: null,
+					trickle: true,
+					iceDone: false,
+					isIceRestarting: false,
+					tracks: [],
+					stream: new MediaStream(), // for publisher handle only
+					mids: {},
+					userIdToDisplay: {}, // userId to display
+					transceiverMap: [], // got from msg["streams"]
+					streamMap: {}, // id to sources to mids?
+					availablePublishers: [],
+					subscribeMap: [], // subscribed to [id][mid]
+					stats: {},
+					currentLayers : new Map(),
+					qualityHistory : new Map(),
+					lastSwitchTime : new Map(),
+				}
+			};
+		})
+	}
+
+	async #destroyHandle(handleId, detachRequest = true) {
+		if(handleId) {
+			let handle = this.#getHandle(handleId);
+			if (handle) {
+
+				await this.#cleanupHandle(handleId);
+
+				if(detachRequest) {
+					await this.#send({
+						"janus": "detach",
+						"handle_id": handleId
+					}, true)
+				}
+
+				if (handleId === this.#publisherHandle?.handleId) {
+					this.#publisherHandle = null;
+				}
+				else if (handleId === this.#subscriberHandle?.handleId) {
+					this.#subscriberHandle = null;
+				}
+			}
+		}
+	}
+
+	async #cleanupHandle(handleId, hangupRequest = false) {
+
+		let handle = this.#getHandle(handleId);
+
+		if(hangupRequest) {
+			await this.#send({"janus": "hangup", "handle_id": handleId,}, true)
+		}
+
+		try {
+			if (handle.webrtcStuff.stream) {
+				if(!this.isConnecting) {
+					handle.webrtcStuff.stream?.getTracks().forEach(track => track.stop());
+				}
+				else {
+					handle.webrtcStuff.stream?.getTracks().forEach(track => track.onended = null);
+				}
+			}
+			if(handle.webrtcStuff?.tracks?.length > 0) {
+				handle.webrtcStuff.tracks.forEach(track => {
+					if (track) {
+						track.stop();
+						track.onended = null;
+					}
+				});
+			}
+		} catch (e) {
+			// Do nothing
+		}
+
+		if(handle.webrtcStuff.stream) {
+			handle.webrtcStuff.stream.onremovetrack = null;
+			handle.webrtcStuff.stream = null;
+		}
+
+		if (handle.webrtcStuff.dataChannel) {
+			Object.keys(handle.webrtcStuff.dataChannel).forEach(label => {
+				handle.webrtcStuff.dataChannel[label].onmessage = null;
+				handle.webrtcStuff.dataChannel[label].onopen = null;
+				handle.webrtcStuff.dataChannel[label].onclose = null;
+				handle.webrtcStuff.dataChannel[label].onerror = null;
+			})
+		}
+		if (handle.webrtcStuff.pc) {
+			handle.webrtcStuff.pc.onicecandidate = null;
+			handle.webrtcStuff.pc.ontrack = null;
+			handle.webrtcStuff.pc.ondatachannel = null;
+			handle.webrtcStuff.pc.onconnectionstatechange = null;
+			handle.webrtcStuff.pc.oniceconnectionstatechange = null;
+		}
+		try {
+			handle.webrtcStuff.pc.close();
+		} catch (e) {
+
+		}
+		handle.webrtcStuff = {
+			mySdp: null,
+			mediaConstraints: null,
+			pc: null,
+			dataChannelOpen: false,
+			dataChannel: null,
+			dtmfSender: null,
+			trickle: true,
+			iceDone: false,
+			isIceRestarting: false,
+			tracks: [],
+			stream: new MediaStream(), // for publisher handle only
+			mids: {},
+			userIdToDisplay: {}, // userId to display
+			transceiverMap: [], // got from msg["streams"]
+			streamMap: {}, // id to sources to mids?
+			availablePublishers: [],
+			subscribeMap: [], // subscribed to [id][mid]
+			stats: {},
+			currentLayers : new Map(),
+			qualityHistory : new Map(),
+			lastSwitchTime : new Map(),
+		}
+
+		if(this.#publisherHandle && handleId === this.#publisherHandle.handleId) {
+			this.#emitLocalFeedUpdate({feedRemoval: true});
+		}
+		else if(this.#subscriberHandle && handleId === this.#subscriberHandle.handleId) {
+			[...this.#getCachedAttendeeIds()].forEach(id => {
+				this.#emitRemoteFeedUpdate(null, {feedRemoval: true, attendee: {id}});
+				this.#removeAttendeeFromCache(id);
+			})
+		}
+
+	}
+	
+	async #joinAsPublisher(roomId, pin, userId, display) {
+		return this.sendMessage(this.#publisherHandle.handleId, {
+			body: {
+				"request": "join", "room": roomId, "pin": pin, "ptype": "publisher", "display": display, ...(this.webrtcVersion > 1000 ? {id: userId} : {})
+			}
+		}, false, true)
+	}
+
+	async #joinAsSubscriber(roomId, pin, userId) {
+
+		const publishers = this.#subscriberHandle.webrtcStuff.availablePublishers;
+
+		if(!publishers.length) {
+			return Promise.reject('no streams to subscribe to');
+		}
+
+		if(this.#subscriberJoinPromise) {
+			return this.#subscriberJoinPromise;
+		}
+
+		let res_streams = [];
+		for (let f in publishers) {
+
+			if(publishers[f]["dummy"])
+				continue;
+
+			let userId = publishers[f]["display"];
+			let streams = publishers[f]["streams"] || [];
+			let id = publishers[f]["id"];
+			let description = {};
+
+			try {
+				const dString = streams.find(s => !!s.description)?.description;
+				if(dString) {
+					description = JSON.parse(dString);
+				}
+			} catch (e) {}
+
+			this._log('Remote publisher: ', id, userId, streams, description);
+
+			for (let i in streams) {
+				const track = streams[i];
+				const mid = track.mid; // source.mid
+				if(track.disabled) {
+					continue;
+				}
+
+				if(!this.#shouldSubscribeParticipant(id, userId, description)) {
+					continue;
+				}
+
+				if(!this.#isSubscribedToMid(id, mid)) {
+					res_streams.push({
+						feed: id,	// This is mandatory
+						mid: mid
+					});
+					this.#addToSubscribeMap(id, mid);
+				}
+			}
+		}
+
+		if(!res_streams.length) {
+			return Promise.reject('no streams to subscribe to');
+		}
+
+		this.#subscriberJoinPromise = this.sendMessage(this.#subscriberHandle.handleId, {
+			body: {
+				"request": "join",
+				"room": roomId,
+				"ptype": "subscriber",
+				"use_msid": true,
+				"private_id": this.privateId,
+				streams: res_streams,
+				...(this.webrtcVersion > 1000 ? {id: userId} : {}),
+				pin: pin
+			}
+		}, false, true)
+			.catch((e) => {
+				this._log(e);
+				this.#subscriberJoinPromise = null;
+				return Promise.reject(e);
+			})
+
+		return this.#subscriberJoinPromise;
+	}
+
+	async #leaveRoom(dontWait = false) {
+		return this.isConnected
+			? this.sendMessage(this.#publisherHandle.handleId, {body: {"request": "leave"}}, dontWait)
+				.finally(() => {
+					this.isConnected = false;
+					this.emit('joined', false);
+				})
+			: Promise.resolve();
+	}
+
+	async #webSocketConnection(reclaim = false)  {
+
+		if(this.isEstablishingConnection) {
+			return Promise.reject({type: 'warning', id: 14, message: 'connection already in progress'});
+		}
+
+		this.isEstablishingConnection = true;
+
+		if (this.ws) {
+			this.#wipeListeners();
+			if (this.ws.readyState === 1) {
+				this.ws.close();
+			}
+		}
+
+		this.#stopKeepAlive();
+
+		return new Promise((resolve, reject) => {
+
+			this.__connectionClosedBoundFn = this.#connectionClosed.bind(this);
+			this.__handleWsEventsBoundFn = this.#handleWsEvents.bind(this);
+
+			let abortConnect = () => {
+				this._abortController.signal.removeEventListener('abort', abortConnect);
+				this.ws.removeEventListener('close', this.__connectionClosedBoundFn);
+				this.ws.removeEventListener('message', this.__handleWsEventsBoundFn);
+				this.ws.onopen = null;
+				this.ws.onerror = null;
+				reject({type: 'warning', id: 15, message: 'Connection cancelled'});
+			};
+
+			this.ws = new WebSocket(this.server, 'janus-protocol');
+			this.ws.addEventListener('close', this.__connectionClosedBoundFn);
+			this.ws.addEventListener('message', this.__handleWsEventsBoundFn);
+
+			this.ws.onopen = () => {
+				this._abortController.signal.removeEventListener('abort', abortConnect);
+				if(!reclaim) {
+					this.#send({"janus": "create"})
+						.then(json => {
+							this.sessionId = json["session_id"] ? json["session_id"] : json.data["id"];
+							this.#startKeepAlive();
+							resolve(this);
+						})
+						.catch(error => {
+							reject({type: error?.type === 'warning' ? 'warning' : 'error', id: 16, message: 'connection error', data: error})
+						})
+						.finally(() => {
+							this.isEstablishingConnection = false;
+						});
+				}
+				else {
+					this.#send({"janus": "claim"})
+						.then(json => {
+							this.sessionId = json["session_id"] ? json["session_id"] : json.data["id"];
+							this.#startKeepAlive();
+							resolve(json);
+						})
+						.catch(error => {
+							reject({type: 'error', id: 17, message: 'reconnection error', data: error})
+						})
+						.finally(() => {
+							this.isEstablishingConnection = false;
+						});
+				}
+			};
+
+			this.ws.onerror = (e) => {
+				this._abortController.signal.removeEventListener('abort', abortConnect);
+				reject({type: 'error', id: 18, message: 'ws connection error', data: e});
+			}
+
+			this._abortController.signal.addEventListener('abort', abortConnect);
+
+		});
+	}
+
+	async #httpConnection(reclaim = false) {
+
+		if(this.isEstablishingConnection) {
+			this.emit('error',  {type: 'warning', id: 19, message: 'connection already in progress'});
+			return;
+		}
+
+		this.isEstablishingConnection = true;
+
+		// usable when switching from ws to http
+		if (this.ws) {
+			this.#wipeListeners();
+			if (this.ws.readyState === 1) {
+				this.ws.close();
+			}
+		}
+
+		this.#stopKeepAlive();
+
+		if(!reclaim) {
+			return this.#send({"janus": "create"})
+				.then(json => {
+					this.sessionId = json["session_id"] ? json["session_id"] : json.data["id"];
+					this.#startKeepAlive();
+					this.#longPoll();
+					return this;
+				})
+				.catch(error => {
+					return Promise.reject({type: error?.type === 'warning' ? 'warning' : 'error', id: 20, message: 'connection error', data: error})
+				})
+				.finally(() => {
+					this.isEstablishingConnection = false;
+				});
+		}
+		else {
+			return this.#send({"janus": "claim"})
+				.then(json => {
+					this.sessionId = json["session_id"] ? json["session_id"] : json.data["id"];
+					this.#startKeepAlive();
+					this.#longPoll();
+					return this;
+				})
+				.catch(error => {
+					return Promise.reject({type: 'error', id: 21, message: 'reconnection error', data: error})
+				})
+				.finally(() => {
+					this.isEstablishingConnection = false;
+				});
+		}
+	}
+
+	async #waitForConnectEvent() {
+		return new Promise((resolve, reject) => {
+			let timeoutId = null;
+			if(this.isConnected) {
+				return resolve();
+			}
+			const cleanup = () => {
+				clearTimeout(timeoutId);
+				this.off('joined', _resolve);
+				this._abortController.signal.removeEventListener('abort', _rejectAbort);
+			}
+			let _resolve = () => {
+				cleanup();
+				resolve();
+			}
+			let _rejectAbort = () => {
+				cleanup();
+				reject({type: 'warning', id: 43, message: 'Connection cancelled'})
+			}
+			let _rejectTimeout = () => {
+				cleanup();
+				reject({type: 'warning', id: 44, message: 'Connection timeout'})
+			}
+			this.once('joined', _resolve);
+			timeoutId = setTimeout(_rejectTimeout, 10000)
+			this._abortController.signal.addEventListener('abort', _rejectAbort);
+		})
+	}
+
+	async #reconnect() {
+
+		if (this.isConnecting) {
+			return Promise.reject({type: 'warning', id: 22, message: 'connection already in progress'});
+		}
+
+		this.isConnecting = true;
+
+		if(this.useWebsockets) {
+			try {
+				await this.#webSocketConnection(true)
+			}
+			finally {
+				this.isConnecting = false;
+			}
+		}
+		else {
+			try {
+				await this.#httpConnection(true)
+			}
+			finally {
+				this.isConnecting = false;
+			}
+		}
+	}
+
+	async connect(
+		roomId,
+		pin,
+		server,
+		protocol,
+		iceServers,
+		token,
+		display,
+		userId,
+		webrtcVersion = 0,
+		initialBitrate = 0,
+		recordingFilename,
+		simulcast = false,
+		simulcastSettings = this.defaultSimulcastSettings,
+		enableDtx = false
+	) {
+
+		this.isSupposeToBeConnected = true;
+
+		if (this.isConnecting) {
+			this.emit('error',  {type: 'warning', id: 23, message: 'connection already in progress'});
+			return
+		}
+
+		if(this.isConnected) {
+			await this.disconnect();
+		}
+
+		this._abortController = new AbortController();
+
+		this.sessionId = null;
+		this.server = server;
+		this.protocol = protocol;
+		this.iceServers = iceServers;
+		this.token = token;
+		this.roomId = roomId;
+		this.pin = pin;
+		this.id = null;
+		this.display = display;
+		this.userId = userId;
+		this.webrtcVersion = webrtcVersion;
+		this.initialBitrate = initialBitrate;
+		this.recordingFilename = recordingFilename;
+		this.enableDtx = enableDtx;
+		this.simulcast = simulcast;
+		this.simulcastSettings = structuredClone(simulcastSettings);
+		this.useWebsockets = this.protocol === 'ws' || this.protocol === 'wss';
+
+		// fixing wrong order
+		Object.keys(this.simulcastSettings).forEach(source => {
+			const wrongOrder = this.simulcastSettings[source].bitrates[0].rid === 'l';
+			if(wrongOrder) {
+				this.simulcastSettings[source].bitrates = this.simulcastSettings[source].bitrates.reverse();
+				this.simulcastSettings[source].defaultSubstream = 2 - this.simulcastSettings[source].defaultSubstream
+			}
+		})
+
+		this.isConnecting = true;
+		this.emit('joining', true);
+
+		try {
+
+			if(this.useWebsockets) {
+				await this.#webSocketConnection(false);
+			}
+			else {
+				await this.#httpConnection(false);
+			}
+
+			this.#publisherHandle = await this.#createHandle();
+			this.handleId = this.#publisherHandle.handleId;
+
+			this.#subscriberHandle = await this.#createHandle();
+
+			await this.#joinAsPublisher(this.roomId,  this.pin, this.userId, this.display);
+			await this.#waitForConnectEvent();
+
+		} catch (error) {
+			this.emit('error', error);
+		} finally {
+			this.isConnecting = false;
+			this.emit('joining', false);
+		}
+
+		this.#enableStatsWatch();
+	}
+
+	async disconnect() {
+
+		this.isSupposeToBeConnected = false;
+
+		if (this.isDisconnecting) {
+			return
+		}
+
+		this.#disableStatsWatch();
+
+		this._abortController?.abort?.();
+		this.isDisconnecting = true;
+		this.#stopKeepAlive();
+		let isConnected = this.isConnected;
+
+		if(this.#publisherHandle) {
+			this.#emitLocalFeedUpdate({feedRemoval: true});
+		}
+
+		if(this.#subscriberHandle) {
+			[...this.#getCachedAttendeeIds()].forEach(id => {
+				this.#emitRemoteFeedUpdate(null, {feedRemoval: true, attendee: {id}});
+				this.#removeAttendeeFromCache(id);
+			})
+		}
+
+		await this.#destroyHandle(this.#publisherHandle?.handleId, false);
+		await this.#destroyHandle(this.#subscriberHandle?.handleId, false);
+		
+		this.#wipeListeners();
+		if (this.ws && this.ws.readyState === 1) {
+			await this.#send({"janus": "destroy"}, true);
+			this.ws.close();
+		}
+
+		this.#subscriberJoinPromise = null;
+		this.sessionId = null;
+		this.isPublished = false;
+		this.isConnected = false;
+		this.isDisconnecting = false;
+		this.emit('publishing', false);
+		this.emit('published', false);
+		this.emit('joining', false);
+		this.emit('joined', false);
+		this.emit('disconnect', isConnected);
+
+	}
+
+	async destroy() {
+		return this.disconnect()
+			.then(() => {
+				this.clear();
+				return true;
+			});
+	}
+
+	#enableDebug() {
+		this._log = console.log.bind(console);
+	}
+
+	#getHandle(handleId, rfid = null, userId = null, fullUserId = null) {
+
+		if(handleId === this.#subscriberHandle?.handleId) {
+			return this.#subscriberHandle;
+		}
+		
+		if(handleId === this.#publisherHandle?.handleId) {
+			return this.#publisherHandle;
+		}
+		
+		return null;
+	}
+
+
+	#findSimulcastConfig(source, settings) {
+		return Object.keys(settings).reduce((acc, key) => {
+			if(settings[source]) {
+				return settings[source];
+			} else if(source.indexOf(key.match(/\*(.*?)\*/)?.[1]) > -1) {
+				return settings[key];
+			} else return acc;
+		}, settings['default']);
+	}
+
+	#sendTrickleCandidate(handleId, candidate) {
+		return this.#send({
+			"janus": "trickle",
+			"candidate": candidate,
+			"handle_id": handleId
+		}, false, false, 5)
+	}
+
+	#webrtc(handleId, enableOntrack = false, enableOnnegotiationneeded = false) {
+
+		let handle = this.#getHandle(handleId);
+		if (!handle) {
+			this.emit('error', {
+				type: 'error',
+				id: 24,
+				message: 'id non-existent',
+				data: [handleId, 'create rtc connection']
+			});
+			return;
+		}
+
+		let config = handle.webrtcStuff;
+		if (!config.pc) {
+			let pc_config = {"iceServers": this.iceServers, "iceTransportPolicy": 'all', "bundlePolicy": undefined};
+
+			pc_config["sdpSemantics"] = "unified-plan";
+
+			let pc_constraints = {};
+
+			if (adapter.browserDetails.browser === "edge") {
+				// This is Edge, enable BUNDLE explicitly
+				pc_config.bundlePolicy = "max-bundle";
+			}
+
+			// pc_config.bundlePolicy = 'balanced';
+			// pc_config.iceTransportPolicy = 'relay';
+			// pc_config.rtcpMuxPolicy = "negotiate";
+
+			this._log('new RTCPeerConnection', pc_config, pc_constraints);
+
+			config.pc = new RTCPeerConnection(pc_config, pc_constraints);
+
+			if(enableOnnegotiationneeded) {
+				config.pc.onnegotiationneeded = async () => {
+					try {
+						this._log('Starting negotiation from onnegotiationneeded');
+
+						// Create an offer
+						const jsep = await this.#createAO('offer', handle.handleId, false);
+
+						if (!jsep) {
+							return null;
+						}
+
+						//HOTFIX: Temporary fix for Safari 13
+						if (jsep.sdp && jsep.sdp.indexOf("\r\na=ice-ufrag") === -1) {
+							jsep.sdp = jsep.sdp.replace("\na=ice-ufrag", "\r\na=ice-ufrag");
+						}
+
+						let descriptions = [];
+						let transceivers = config.pc.getTransceivers();
+						Object.keys(config.streamMap[this.id]).forEach(source => {
+							const simulcastConfigForSource = this.#findSimulcastConfig(source, this.simulcastSettings);
+							config.streamMap[this.id][source].forEach(trackId => {
+								let t = transceivers.find(transceiver => transceiver.sender.track && transceiver.sender.track.id === trackId)
+								if(t) {
+									descriptions.push({mid: t.mid, description: JSON.stringify({source, simulcastBitrates: simulcastConfigForSource?.bitrates, intercomGroups: this._talkIntercomChannels})});
+								}
+							})
+						});
+
+						// Send the offer to the server
+						await this.sendMessage(handle.handleId, {
+							body: {
+								"request": "configure",
+								"audio": !!(config.stream && config.stream.getAudioTracks().length > 0),
+								"video": !!(config.stream && config.stream.getVideoTracks().length > 0),
+								"data": true,
+								descriptions: descriptions,
+								...(this.recordingFilename ? {filename: this.recordingFilename} : {}),
+							},
+							jsep
+						});
+
+						// The answer will be processed by #handleWsEvents, so we don't need to do anything else here
+					} catch (error) {
+						this._log('Error during negotiation:', error);
+					}
+				};
+			}
+
+			config.pc.onconnectionstatechange = () => {
+				
+				if (config.pc.connectionState === 'failed') {
+					this._log('onconnectionstatechange: connectionState === failed');
+					this.#iceRestart(handleId);
+				}
+				this.emit('connectionState', [handleId, handleId === this.#publisherHandle?.handleId, config.pc.connectionState]);
+			};
+			
+			config.pc.oniceconnectionstatechange = () => {
+				if (config.pc.iceConnectionState === 'failed') {
+					this._log('oniceconnectionstatechange: iceConnectionState === failed');
+					this.#iceRestart(handleId);
+				}
+				this.emit('iceState', [handleId, handleId === this.#publisherHandle?.handleId, config.pc.iceConnectionState]);
+			};
+			config.pc.onicecandidate = (event) => {
+				if (event.candidate == null || (adapter.browserDetails.browser === 'edge' && event.candidate.candidate.indexOf('endOfCandidates') > 0)) {
+					config.iceDone = true;
+					this.#sendTrickleCandidate(handleId, {"completed": true})
+						.catch(e => {
+							this.emit('error', e);
+						});
+				} else {
+					// JSON.stringify doesn't work on some WebRTC objects anymore
+					// See https://code.google.com/p/chromium/issues/detail?id=467366
+					var candidate = {
+						"candidate": event.candidate.candidate,
+						"sdpMid": event.candidate.sdpMid,
+						"sdpMLineIndex": event.candidate.sdpMLineIndex
+					};
+
+					this.#sendTrickleCandidate(handleId, candidate)
+						.catch(e => {
+							this.emit('error', e);
+						});
+				}
+			};
+
+			if (enableOntrack) {
+				config.pc.ontrack = (event) => {
+
+					if(!event.streams)
+						return;
+
+					if(!event.streams?.[0]?.onremovetrack) {
+						
+						event.streams[0].onremovetrack = (ev) => {
+
+							this._log('Remote track removed', ev);
+
+							const trackIndex = config?.tracks?.findIndex(t => t.id === ev.track.id);
+							if(trackIndex > -1) {
+								config.tracks.splice(trackIndex, 1);
+							}
+
+							// check if handle still exists
+							if(!this.#getHandle(handle.handleId)) {
+								return;
+							}
+
+							this.#updatePublishersStreamMap();
+
+							let transceiver = config.pc?.getTransceivers()?.find(
+								t => t.receiver.track === ev.track);
+
+							let mid = transceiver?.mid || ev.track.id;
+
+							// transceiver may not exist already
+							if(mid === ev.target.id && config.mids?.[event.track.id]) {
+								mid = config.mids[event.track.id];
+							}
+
+							this.#emitRemoteFeedUpdate(mid, {
+								removingTrack: true,
+								track: ev.track,
+							});
+
+							delete config.mids[ev.track.id];
+
+						};
+					}
+
+					if (event.track) {
+
+						this._log('Remote track added', event.track, event.streams[0]);
+						
+						config.tracks.push(event.track);
+						
+						this.#updatePublishersStreamMap();
+
+						let mid = event.transceiver ? event.transceiver.mid : event.track.id;
+						config.mids[event.track.id] = event.transceiver.mid
+
+						if(event.track.kind === 'video') {
+							this.requestKeyFrame(handle.handleId, mid);
+						}
+
+						this.#emitRemoteFeedUpdate(mid, {
+							addingTrack: true,
+							track: event.track
+						});
+
+						if (event.track.onended)
+							return;
+
+						event.track.onended = (ev) => {
+							this._log('Remote track ended', ev);
+
+							const trackIndex = config?.tracks?.findIndex(t => t.id === ev.target.id);
+
+							if(trackIndex > -1) {
+								config.tracks.splice(trackIndex, 1);
+							}
+
+							// check if handle still exists
+							if(!this.#getHandle(handle.handleId)) {
+								return;
+							}
+
+							this.#updatePublishersStreamMap();
+
+							let transceiver = config.pc?.getTransceivers()?.find(t => t.receiver.track === ev.target);
+							let mid = transceiver?.mid || ev.target.id;
+
+							// transceiver may not exist already
+							if(mid === ev.target.id && config.mids?.[event.track.id]) {
+								mid = config.mids[event.track.id];
+							}
+
+							this.#emitRemoteFeedUpdate(mid, {
+								removingTrack: true,
+								track: ev.target
+							});
+
+							delete config.mids[event.track.id];
+
+						};
+
+						event.track.onmute = (ev) => {
+							this._log('Remote track muted');
+
+							let transceiver = config.pc.getTransceivers().find(
+								t => t.receiver.track === ev.target);
+							let mid = transceiver.mid || ev.target.id;
+
+							this.#emitRemoteTrackMuted(mid, {track:ev.target, muted: true});
+						};
+
+						event.track.onunmute = (ev) => {
+							this._log('Remote track unmuted');
+
+							let transceiver = config.pc.getTransceivers().find(
+								t => t.receiver.track === ev.target);
+							let mid = transceiver.mid || ev.target.id;
+
+							this.#emitRemoteTrackMuted(mid, {track:ev.target, muted: false});
+						};
+					}
+				};
+			}
+		}
+
+		if (!config.dataChannel || !config.dataChannelOpen) {
+
+			config.dataChannel = {};
+
+			var onDataChannelMessage = (event) => {
+				this.#handleDataChannelEvents(handleId, 'message', event.data);
+			};
+			var onDataChannelStateChange = (event) => {
+				let label = event.target.label;
+				let protocol = event.target.protocol;
+				let state = config.dataChannel[label] ? config.dataChannel[label].readyState : "null";
+				this.#handleDataChannelEvents(handleId, 'state', {state, label} );
+			};
+			var onDataChannelError = (error) => {
+				this.#handleDataChannelEvents(handleId, 'error', {label: error?.channel?.label, error});
+			};
+
+			const createDataChannel = (label, protocol, incoming) => {
+				let options =  {ordered: true};
+				if(!incoming) {
+					if(protocol) {
+						options = {...options, protocol}
+					}
+					config.dataChannel[label] = config.pc.createDataChannel(label, options);
+				}
+				else {
+					config.dataChannel[label] = incoming;
+				}
+
+				config.dataChannel[label].onmessage = onDataChannelMessage;
+				config.dataChannel[label].onopen = onDataChannelStateChange;
+				config.dataChannel[label].onclose = onDataChannelStateChange;
+				config.dataChannel[label].onerror = onDataChannelError;
+			}
+
+			createDataChannel(this.defaultDataChannelLabel, null,  null);
+			
+			config.pc.ondatachannel = function (event) {
+				createDataChannel(event.channel.label, event.channel.protocol, event.channel)
+			};
+		}
+	}
+
+	#webrtcPeer(handleId, jsep) {
+
+		let handle = this.#getHandle(handleId);
+		if (!handle) {
+			return Promise.reject({type: 'warning', id: 25, message: 'id non-existent', data: [handleId, 'rtc peer']});
+		}
+
+		var config = handle.webrtcStuff;
+
+		if (jsep !== undefined && jsep !== null) {
+			if (config.pc === null) {
+				this._log("No PeerConnection: if this is an answer, use createAnswer and not #webrtcPeer");
+				return Promise.resolve(null);
+			}
+
+			return config.pc.setRemoteDescription(jsep)
+				.then(() => {
+					config.remoteSdp = jsep.sdp;
+					// Any trickle candidate we cached?
+					if (config.candidates && config.candidates.length > 0) {
+						for (var i = 0; i < config.candidates.length; i++) {
+							var candidate = config.candidates[i];
+							if (!candidate || candidate.completed === true) {
+								config.pc.addIceCandidate(null).catch((e) => {
+									this._log('Error adding null candidate', e);
+								});;
+							} else {
+								config.pc.addIceCandidate(candidate).catch((e) => {
+									this._log('Error adding candidate', e);
+								});
+							}
+						}
+						config.candidates = [];
+					}
+					// Done
+					return true;
+				})
+				.catch((e) => {
+					return Promise.reject({type: 'warning', id: 26, message: 'rtc peer', data: [handleId, e]});
+				});
+		} else {
+			return Promise.reject({type: 'warning', id: 27, message: 'rtc peer', data: [handleId, 'invalid jsep']});
+		}
+	}
+
+	#iceRestart(handleId) {
+
+		let handle = this.#getHandle(handleId);
+		if (!handle) {
+			return;
+		}
+		var config = handle.webrtcStuff;
+
+		// Already restarting;
+		if (config.isIceRestarting) {
+			return;
+		}
+
+		config.isIceRestarting = true;
+
+		// removing this so we can cache ice candidates again
+		config.remoteSdp = null;
+
+		if (this.#publisherHandle.handleId === handleId) {
+			this._log('Performing local ICE restart');
+			let hasAudio = !!(config.stream && config.stream.getAudioTracks().length > 0);
+			let hasVideo = !!(config.stream && config.stream.getVideoTracks().length > 0);
+			this.#createAO('offer', handleId, true )
+				.then((jsep) => {
+					if (!jsep) {
+						return null;
+					}
+					return this.sendMessage(handleId, {
+						body: {"request": "configure", "keyframe": true, "audio": hasAudio, "video": hasVideo, "data": true, ...(this.recordingFilename ? {filename: this.recordingFilename} : {})},
+						jsep
+					}, false, false, 5);
+				})
+				.then(r => {
+					config.isIceRestarting = false;
+					this._log('ICE restart success');
+				})
+				.catch((e) => {
+					config.isIceRestarting = false;
+					this.emit('error', {type: 'error', id: 28, message: 'iceRestart failed', data: e});
+				});
+		} else {
+			this._log('Performing remote ICE restart', handleId);
+			return this.sendMessage(handleId, {
+				body: {"request": "configure", "restart": true}
+			}, false, false, 5).then(() => {
+			}).then(() => {
+				config.isIceRestarting = false;
+				this._log('ICE restart success');
+			}).catch(() => {
+				config.isIceRestarting = false;
+			});
+		}
+	}
+
+	#setupTransceivers(handleId, [audioSend, audioRecv, videoSend, videoRecv, audioTransceiver = null, videoTransceiver = null]) {
+		//TODO: this should be refactored to use handle's trackMap so we dont have to pass any parameters
+
+		let handle = this.#getHandle(handleId);
+		if (!handle) {
+			return null;
+		}
+		let config = handle.webrtcStuff;
+
+		const setTransceiver = (transceiver, send, recv, kind = 'audio') => {
+			if (!send && !recv) {
+				// disabled: have we removed it?
+				if (transceiver) {
+					if (transceiver.setDirection) {
+						transceiver.setDirection("inactive");
+					} else {
+						transceiver.direction = "inactive";
+					}
+				}
+			} else {
+				if (send && recv) {
+					if (transceiver) {
+						if (transceiver.setDirection) {
+							transceiver.setDirection("sendrecv");
+						} else {
+							transceiver.direction = "sendrecv";
+						}
+					}
+				} else if (send && !recv) {
+					if (transceiver) {
+						if (transceiver.setDirection) {
+							transceiver.setDirection("sendonly");
+						} else {
+							transceiver.direction = "sendonly";
+						}
+					}
+				} else if (!send && recv) {
+					if (transceiver) {
+						if (transceiver.setDirection) {
+							transceiver.setDirection("recvonly");
+						} else {
+							transceiver.direction = "recvonly";
+						}
+					} else {
+						// In theory, this is the only case where we might not have a transceiver yet
+						config.pc.addTransceiver(kind, {direction: "recvonly"});
+					}
+				}
+			}
+		}
+
+		// if we're passing any transceivers, we work only on them, doesn't matter if one of them is null
+		if(audioTransceiver || videoTransceiver) {
+			if(audioTransceiver) {
+				setTransceiver(audioTransceiver, audioSend, audioRecv, 'audio');
+			}
+			if(videoTransceiver) {
+				setTransceiver(videoTransceiver, videoSend, videoRecv, 'video');
+			}
+		}
+		// else we work on all transceivers
+		else {
+			let transceivers = config.pc.getTransceivers();
+			if (transceivers && transceivers.length > 0) {
+				for (let i in transceivers) {
+					let t = transceivers[i];
+					if (
+						(t.sender && t.sender.track && t.sender.track.kind === "audio") ||
+						(t.receiver && t.receiver.track && t.receiver.track.kind === "audio")
+					) {
+						setTransceiver(t, audioSend, audioRecv, 'audio');
+					}
+					if (
+						(t.sender && t.sender.track && t.sender.track.kind === "video") ||
+						(t.receiver && t.receiver.track && t.receiver.track.kind === "video")
+					) {
+						setTransceiver(t, videoSend, videoRecv, 'video');
+					}
+				}
+			}
+		}
+	}
+
+	#createAO(type = 'offer', handleId, iceRestart = false, ) {
+
+		let handle = this.#getHandle(handleId);
+		if (!handle) {
+			return Promise.reject({
+				type: 'warning',
+				id: 29,
+				message: 'id non-existent',
+				data: [handleId, 'createAO', type]
+			});
+		}
+
+		let methodName = null;
+		if (type === 'offer') {
+			methodName = 'createOffer'
+		} else {
+			methodName = 'createAnswer'
+		}
+
+		let config = handle.webrtcStuff;
+		let mediaConstraints = {};
+
+		if (iceRestart) {
+			mediaConstraints["iceRestart"] = true;
+		}
+
+		return config.pc[methodName](mediaConstraints)
+			.then( (response) => {
+
+				// if type offer and its me and we want dtx we mungle the sdp
+				if(handleId === this.#publisherHandle.handleId && type === 'offer' && this.enableDtx) {
+					// enable DTX
+					response.sdp = response.sdp.replace("useinbandfec=1", "useinbandfec=1;usedtx=1")
+				}
+
+				config.mySdp = response.sdp;
+				let _p = config.pc.setLocalDescription(response)
+					.catch((e) => {
+						return Promise.reject({
+							type: 'warning',
+							id: 30,
+							message: 'setLocalDescription',
+							data: [handleId, e]
+						})
+					});
+				config.mediaConstraints = mediaConstraints;
+				if (!config.iceDone && !config.trickle) {
+					// Don't do anything until we have all candidates
+					return Promise.resolve(null);
+				}
+
+				// JSON.stringify doesn't work on some WebRTC objects anymore
+				// See https://code.google.com/p/chromium/issues/detail?id=467366
+				var jsep = {
+					"type": response.type,
+					"sdp": response.sdp
+				};
+
+				if(response.e2ee)
+					jsep.e2ee = true;
+				if(response.rid_order === "hml" || response.rid_order === "lmh")
+					jsep.rid_order = response.rid_order;
+				if(response.force_relay)
+					jsep.force_relay = true;
+
+				return _p.then(() => jsep)
+			}, (e) => {
+				return Promise.reject({type: 'warning', id: 31, message: methodName, data: [handleId, e]})
+			});
+
+	}
+	
+	#publishRemote(handleId, jsep) {
+		let handle = this.#getHandle(handleId);
+		if (!handle) {
+			return Promise.reject({
+				type: 'warning',
+				id: 32,
+				message: 'id non-existent',
+				data: [handleId, 'publish remote participant']
+			})
+		}
+
+		this.#webrtc(handleId, true, false);
+
+		let config = handle.webrtcStuff;
+
+		if (jsep) {
+			return config.pc.setRemoteDescription(jsep)
+				.then(() => {
+					config.remoteSdp = jsep.sdp;
+					// Any trickle candidate we cached?
+					if (config.candidates && config.candidates.length > 0) {
+						for (var i = 0; i < config.candidates.length; i++) {
+							var candidate = config.candidates[i];
+							if (!candidate || candidate.completed === true) {
+								// end-of-candidates
+								config.pc.addIceCandidate(null).catch(e => {
+									this._log('Error adding null candidate', e);
+								});
+							} else {
+								// New candidate
+								config.pc.addIceCandidate(candidate).catch(e => {
+									this._log('Error adding candidate', e);
+								});
+							}
+						}
+						config.candidates = [];
+					}
+
+					this.#setupTransceivers(handleId, [false, true, false, true]);
+
+					// Create the answer now
+					return this.#createAO('answer', handleId, false)
+						.then(_jsep => {
+							if (!_jsep) {
+								this.emit('error', {
+									type: 'warning',
+									id: 33,
+									message: 'publish remote participant',
+									data: [handleId, 'no jsep']
+								});
+								return Promise.resolve();
+							}
+							return this.sendMessage(handleId, {
+								"body": {"request": "start", ...(this.roomId && {"room": this.roomId}), ...(this.pin && {pin: this.pin})},
+								"jsep": _jsep
+							});
+						})
+				}, (e) => Promise.reject({
+					type: 'warning',
+					id: 34,
+					message: 'setRemoteDescription',
+					data: [handleId, e]
+				}));
+
+		} else {
+			return Promise.resolve();
+		}
+
+	}
+	
+	#republishOnTrackEnded(source) {
+		let handle = this.#publisherHandle;
+		if (!handle) {
+			return;
+		}
+		let config = handle.webrtcStuff;
+		if (!config.stream) {
+			return;
+		}
+		let sourceTrackIds = (config.streamMap[this.id][source] || []);
+		let remainingTracks = [];
+		for(let i = 0; i < sourceTrackIds.length; i++) {
+			let foundTrack = config.tracks.find(t => t.id === sourceTrackIds[i]);
+			if(foundTrack) {
+				remainingTracks.push(foundTrack);
+			}
+		}
+		if (remainingTracks.length) {
+			let stream = new MediaStream();
+			remainingTracks.forEach(track => stream.addTrack(track));
+			return this.publishLocal(stream, source);
+		}
+		else {
+			return this.publishLocal(null, source);
+		}
+	};
+	
+	async publishLocal(stream = null, source = 'camera0') {
+
+		if(!this.isConnected || this.isDisconnecting) {
+			return {
+				type: 'warning',
+				id: 35,
+				message: 'Either not connected or disconnecting',
+			}
+		}
+
+		if(stream?.getVideoTracks()?.length > 1) {
+			return {
+				type: 'warning',
+				id: 36,
+				message: 'multiple video tracks not supported',
+				data: null
+			}
+		}
+
+		if(stream?.getAudioTracks()?.length > 1) {
+			return {
+				type: 'warning',
+				id: 37,
+				message: 'multiple audio tracks not supported',
+				data: null
+			}
+		}
+
+		let handle = this.#publisherHandle;
+		if (!handle) {
+			return {
+				type: 'error',
+				id: 38,
+				message: 'no local handle, connect before publishing',
+				data: null
+			}
+		}
+
+		this.emit('publishing', true);
+
+		this.#webrtc(handle.handleId, false, true);
+
+		let config = handle.webrtcStuff;
+
+		if (!config.stream) {
+			config.stream = new MediaStream();
+		}
+
+		let transceivers = config.pc.getTransceivers();
+		let existingTracks = [...(config.streamMap?.[this.id]?.[source] || [])];
+
+		if(stream?.getTracks().length) {
+			if(!config.streamMap[this.id]) {
+				config.streamMap[this.id] = {};
+			}
+			config.streamMap[this.id][source] = stream?.getTracks()?.map(track => track.id) || [];
+		} else {
+			if(config.streamMap[this.id]) {
+				delete config.streamMap[this.id][source];
+			}
+		}
+
+		// remove old audio track related to this source
+		let oldAudioStreamIndex = config?.tracks?.findIndex(track => track.kind === 'audio' && existingTracks.includes(track.id));
+		let oldAudioStream = config?.tracks[oldAudioStreamIndex];
+		if (oldAudioStream) {
+			try {
+				oldAudioStream.stop();
+
+			} catch (e) {
+				this._log(e);
+			}
+			config.stream.removeTrack(oldAudioStream);
+			config?.tracks.splice(oldAudioStreamIndex, 1);
+		}
+
+		// remove old video track related to this source
+		let oldVideoStreamIndex = config?.tracks?.findIndex(track => track.kind === 'video' && existingTracks.includes(track.id));
+		let oldVideoStream = config?.tracks[oldVideoStreamIndex];
+		if (oldVideoStream) {
+			try {
+				oldVideoStream.stop();
+			} catch (e) {
+				this._log(e);
+			}
+
+			config.stream.removeTrack(oldVideoStream);
+			config?.tracks.splice(oldVideoStreamIndex, 1);
+		}
+
+		const simulcastConfigForSource = this.#findSimulcastConfig(source, this.simulcastSettings);
+		let audioTrackReplacePromise = Promise.resolve();
+		let videoTrackReplacePromise = Promise.resolve();
+
+		let audioTransceiver = null;
+		let videoTransceiver = null;
+		let replaceAudio = stream?.getAudioTracks()?.length;
+		let replaceVideo = stream?.getVideoTracks()?.length;
+
+		for(const transceiver of transceivers) {
+			if(['sendonly', 'sendrecv'].includes(transceiver.currentDirection) && transceiver.sender?.track?.kind === 'audio' && existingTracks.includes(transceiver.sender?.track?.id)) {
+				audioTransceiver = transceiver;
+			}
+			else if(['sendonly', 'sendrecv'].includes(transceiver.currentDirection) && transceiver.sender?.track?.kind === 'video' && existingTracks.includes(transceiver.sender?.track?.id)) {
+				videoTransceiver = transceiver;
+			}
+
+			// Reusing existing transceivers
+			// TODO: if we start using different codecs for different sources, we need to check for that here
+
+			else if(transceiver.currentDirection === 'inactive' && transceiver.sender?.getParameters()?.codecs?.find(c => c.mimeType.indexOf('audio') > -1) && replaceAudio && !audioTransceiver) {
+				audioTransceiver = transceiver;
+			}
+			else if(transceiver.currentDirection === 'inactive' && transceiver.sender?.getParameters()?.codecs?.find(c => c.mimeType.indexOf('video') > -1) && replaceVideo && !videoTransceiver) {
+				videoTransceiver = transceiver;
+			}
+		}
+
+		if (replaceAudio) {
+			config.stream.addTrack(stream.getAudioTracks()[0]);
+			config.tracks.push(stream.getAudioTracks()[0]);
+			if (audioTransceiver && audioTransceiver.sender) {
+				audioTrackReplacePromise = audioTransceiver.sender.replaceTrack(stream.getAudioTracks()[0]);
+			} else {
+				config.pc.addTrack(stream.getAudioTracks()[0], config.stream);
+			}
+		}
+		else {
+			if (audioTransceiver && audioTransceiver.sender) {
+				audioTrackReplacePromise = audioTransceiver.sender.replaceTrack(null);
+			}
+		}
+
+		if (replaceVideo) {
+			config.stream.addTrack(stream.getVideoTracks()[0]);
+			config.tracks.push(stream.getVideoTracks()[0]);
+			if (videoTransceiver && videoTransceiver.sender) {
+				videoTrackReplacePromise = videoTransceiver.sender.replaceTrack(stream.getVideoTracks()[0]);
+			} else {
+				if(!this.simulcast) {
+					config.pc.addTrack(stream.getVideoTracks()[0], config.stream);
+				}
+				else {
+					config.pc.addTransceiver(stream.getVideoTracks()[0], {
+						direction: 'sendonly',
+						streams: [config.stream],
+						sendEncodings: structuredClone(simulcastConfigForSource?.bitrates)
+					})
+				}
+			}
+		}
+		else {
+			if (videoTransceiver && videoTransceiver.sender) {
+				videoTrackReplacePromise = videoTransceiver.sender.replaceTrack(null);
+			}
+		}
+
+		// we possibly created new transceivers, so we need to get them again
+
+		transceivers = config.pc.getTransceivers();
+		existingTracks = [...(config.streamMap[this.id][source] || [])];
+		if(!audioTransceiver) {
+			audioTransceiver = transceivers.find(transceiver => transceiver.sender.track && transceiver.sender.track.kind === 'audio' && existingTracks.includes(transceiver.sender.track.id))
+		}
+		if(!videoTransceiver) {
+			videoTransceiver = transceivers.find(transceiver => transceiver.sender.track && transceiver.sender.track.kind === 'video' && existingTracks.includes(transceiver.sender.track.id))
+		}
+
+		let hasAudio = !!(stream && stream.getAudioTracks().length > 0);
+		let hasVideo = !!(stream && stream.getVideoTracks().length > 0);
+
+		this.#setupTransceivers(this.#publisherHandle.handleId, [hasAudio, false, hasVideo, false, audioTransceiver, videoTransceiver]);
+
+		const emitEvents = () => {
+			this.isPublished = true;
+
+			if(!config.stream.onremovetrack) {
+				config.stream.onremovetrack = (ev) => {};
+			}
+
+			let republishTimeoutId = null;
+			let tracks = config.stream.getTracks();
+
+			// this event is emitted when we publish a new source but more importantly if one of the sources goes away
+			this.#emitLocalFeedUpdate({
+				source
+			});
+
+			if(tracks.length) {
+				tracks.forEach(track => {
+
+					// used as a flag to not emit tracks that been already emitted
+					if(!track.onended) {
+
+						this.#emitLocalFeedUpdate({
+							addingTrack: true,
+							track,
+							source
+						})
+
+						track.onended = (ev) => {
+							config.stream.removeTrack(track);
+							config.tracks = config.tracks.filter(t => t.id !== track.id);
+							this.#emitLocalFeedUpdate({
+								removingTrack: true,
+								track,
+								source
+							})
+							clearTimeout(republishTimeoutId);
+							republishTimeoutId = setTimeout(() => {
+								this.#republishOnTrackEnded(source);
+							}, 100);
+
+						}
+					}
+				})
+			}
+
+			this.isMuted = [];
+			for(const source of Object.keys(config.streamMap[this.id])) {
+				const audioTrack = config.stream?.getAudioTracks()?.find(track => config.streamMap[this.id][source].includes(track.id));
+				const videoTrack = config.stream?.getVideoTracks()?.find(track => config.streamMap[this.id][source].includes(track.id));
+				this.isMuted.push({type: 'audio', value: !audioTrack || !audioTrack.enabled, source, mid: transceivers.find(transceiver => transceiver.sender?.track?.kind === 'audio' && transceiver.sender?.track?.id === audioTrack?.id)?.mid});
+				this.isMuted.push({type: 'video', value: !videoTrack || !videoTrack.enabled, source, mid: transceivers.find(transceiver => transceiver.sender?.track?.kind === 'video' && transceiver.sender?.track?.id === videoTrack?.id)?.mid});
+
+				this.emit('localHasVideo', !!videoTrack, source);
+				this.emit('localHasAudio', !!audioTrack, source);
+			}
+			for(const val of this.isMuted) {
+				this.emit('localMuted', {...val});
+			}
+			this.emit('published', true);
+			this.emit('publishing', false);
+
+		};
+
+		try {
+
+			await Promise.all([audioTrackReplacePromise, videoTrackReplacePromise]);
+
+			if(this._isDataChannelOpen !== true) {
+				await new Promise((resolve, reject) => {
+					let dataChannelTimeoutId = null;
+					let _cleanup = () => {
+						clearTimeout(dataChannelTimeoutId);
+						this._abortController.signal.removeEventListener('abort', _rejectAbort);
+						this.off('dataChannel', _resolve, this);
+					}
+					let _resolve = (val) => {
+						if (val) {
+							_cleanup();
+							resolve(this);
+						}
+					};
+					let _rejectTimeout = () => {
+						_cleanup();
+						reject({type: 'error', id: 39, message: 'Data channel did not open', data: null});
+					}
+					let _rejectAbort = () => {
+						_cleanup();
+						reject({type: 'warning', id: 40, message: 'Connection cancelled'})
+					}
+					dataChannelTimeoutId = setTimeout(_rejectTimeout, 10000);
+					this._abortController.signal.addEventListener('abort', _rejectAbort);
+					this.on('dataChannel', _resolve, this);
+				});
+			}
+
+			emitEvents();
+
+		}
+		catch(e) {
+			this.emit('publishing', false);
+		}
+
+
+	}
+
+	async unpublishLocal(dontWait = false) {
+		return this.isPublished
+			? this.sendMessage(this.#publisherHandle.handleId, {body: {"request": "unpublish"}}, dontWait)
+				.finally(r => {
+					this.isPublished = false;
+					this.emit('published', false);
+					return r
+				})
+			: Promise.resolve()
+	}
+
+	toggleAudio(value = null, source = 'camera0', mid) {
+		let handle = this.#publisherHandle;
+		if (!handle) {
+			this.emit('error', {
+				type: 'warning',
+				id: 41,
+				message: 'no local id, connect first', data: null
+			});
+			return;
+		}
+		let config = handle.webrtcStuff;
+		let transceivers = config.pc?.getTransceivers();
+		let transceiver = null;
+		if(source) {
+			transceiver = transceivers?.find(t => t.sender && t.sender.track && t.receiver.track.kind === "audio" && (config.streamMap[this.id][source] || []).includes(t.sender.track.id));
+		}
+		else {
+			transceiver = transceivers?.find(t => t.sender && t.sender.track && t.receiver.track.kind === "audio" && (mid ? t.mid === mid : true));
+		}
+		if (transceiver) {
+			transceiver.sender.track.enabled = value !== null ? !!value : !transceiver.sender.track.enabled;
+		}
+
+		this.isMuted = [];
+		for(const source of Object.keys(config.streamMap[this.id])) {
+			const audioTrack = config.stream?.getAudioTracks()?.find(track => config.streamMap[this.id][source].includes(track.id));
+			const audioTransceiver = transceivers?.find(transceiver => transceiver.sender.track && transceiver.sender.track.kind === 'audio' && transceiver.sender.track.id === audioTrack?.id);
+			const videoTrack = config.stream?.getVideoTracks()?.find(track => config.streamMap[this.id][source].includes(track.id));
+			const videoTransceiver = transceivers?.find(transceiver => transceiver.sender.track && transceiver.sender.track.kind === 'video' && transceiver.sender.track.id === videoTrack?.id);
+			this.isMuted.push({type: 'audio', value: !audioTrack || !audioTransceiver || !audioTransceiver?.sender?.track?.enabled , source, mid: audioTransceiver?.mid});
+			this.isMuted.push({type: 'video', value: !videoTrack || !videoTransceiver || !videoTransceiver?.sender?.track?.enabled, source, mid: videoTransceiver?.mid});
+		}
+		for(let val of this.isMuted) {
+			this.emit('localMuted', {...val});
+		}
+	}
+
+	toggleVideo(value = null, source = 'camera0', mid) {
+		let handle = this.#publisherHandle;
+		if (!handle) {
+			this.emit('error', {
+				type: 'warning',
+				id: 42,
+				message: 'no local id, connect first', data: null
+			});
+			return;
+		}
+		let config = handle.webrtcStuff;
+		let transceivers = config.pc?.getTransceivers();
+		let transceiver = null;
+		if(source) {
+			transceiver = transceivers?.find(t => t.sender && t.sender.track && t.receiver.track.kind === "video" && (config.streamMap[this.id][source] || []).includes(t.sender.track.id));
+		}
+		else {
+			transceiver = transceivers?.find(t => t.sender && t.sender.track && t.receiver.track.kind === "video" && (mid ? t.mid === mid : true));
+		}
+		if (transceiver) {
+			transceiver.sender.track.enabled = value !== null ? !!value : !transceiver.sender.track.enabled;
+		}
+		this.isMuted = [];
+		for(const source of Object.keys(config.streamMap[this.id])) {
+			const audioTrack = config.stream?.getAudioTracks()?.find(track => config.streamMap[this.id][source].includes(track.id));
+			const audioTransceiver = transceivers?.find(transceiver => transceiver.sender.track && transceiver.sender.track.kind === 'audio' && transceiver.sender.track.id === audioTrack?.id);
+			const videoTrack = config.stream?.getVideoTracks()?.find(track => config.streamMap[this.id][source].includes(track.id));
+			const videoTransceiver = transceivers?.find(transceiver => transceiver.sender.track && transceiver.sender.track.kind === 'video' && transceiver.sender.track.id === videoTrack?.id);
+			this.isMuted.push({type: 'audio', value: !audioTrack || !audioTransceiver || !audioTransceiver?.sender?.track?.enabled , source, mid: audioTransceiver?.mid});
+			this.isMuted.push({type: 'video', value: !videoTrack || !videoTransceiver || !videoTransceiver?.sender?.track?.enabled, source, mid: videoTransceiver?.mid});
+		}
+		for(let val of this.isMuted) {
+			this.emit('localMuted', {...val});
+		}
+	}
+
+	requestKeyFrame(handleId, mid) {
+		this.sendMessage(handleId, {
+			"body": {
+				"request": "configure",
+				"keyframe": true,
+				...(mid !== undefined ? {streams: [{mid,keyframe:true}]} : {})
+			}
+		}).catch(() => null)
+	}
+
+	setRoomType(type = 'watchparty') {
+		this._roomType = type;
+		return this._roomType;
+	}
+
+	#setSelectedSubstream(sender, mid, substream) {
+
+		const handle = this.#getHandle(sender);
+
+		if(!handle) {
+			return;
+		}
+
+		handle.webrtcStuff.lastSwitchTime.set(mid, Date.now());
+
+		if(!handle.webrtcStuff.currentLayers.has(mid)) {
+			handle.webrtcStuff.currentLayers.set(mid, {mid, substream: substream, temporal: -1});
+		}
+		else {
+			handle.webrtcStuff.currentLayers.get(mid).substream = substream;
+		}
+	}
+
+	#setSelectedTemporal(sender, mid, temporal) {
+
+		const handle = this.#getHandle(sender);
+
+		if(!handle) {
+			return;
+		}
+
+		handle.webrtcStuff.lastSwitchTime.set(mid, Date.now());
+
+		if(!handle.webrtcStuff.currentLayers.has(mid)) {
+			handle.webrtcStuff.currentLayers.set(mid, {mid, substream: -1, temporal: temporal});
+		}
+		else {
+			handle.webrtcStuff.currentLayers.get(mid).temporal = temporal;
+		}
+	}
+
+	#shouldEmitFeedUpdate(parsedDisplay = {}) {
+		const myUserRole = decodeJanusDisplay(this.display)?.role || 'participant';
+		const remoteUserRole = parsedDisplay?.role || 'participant';
+		const remoteUserId = parsedDisplay?.userId;
+		const shouldSubscribeToUserRole = this.userRoleSubscriptionRules[myUserRole][(this._roomType || 'watchparty')].indexOf(remoteUserRole) > -1
+		const shouldSubscribeToUserId = this._restrictSubscribeToUserIds.length === 0 || this._restrictSubscribeToUserIds.indexOf(remoteUserId) > -1;
+		return shouldSubscribeToUserRole && shouldSubscribeToUserId;
+	}
+
+	#shouldSubscribeParticipant(id, userId, description) {
+
+		const myUserRole = decodeJanusDisplay(this.display)?.role || 'participant';
+		const remoteUserRole = decodeJanusDisplay(userId)?.role || 'participant';
+		const remoteUserId = decodeJanusDisplay(userId)?.userId;
+		const remoteIntercomGroups = description?.intercomGroups || [];
+		const shouldSubscribeToUserRole = this.userRoleSubscriptionRules[myUserRole][(this._roomType || 'watchparty')].indexOf(remoteUserRole) > -1
+		const shouldSubscribeToUserId = this._restrictSubscribeToUserIds.length === 0 || this._restrictSubscribeToUserIds.indexOf(remoteUserId) > -1;
+		const shouldSubscribeToIntercomGroups = remoteIntercomGroups.some(g => this._listenIntercomChannels.indexOf(g) > -1);
+
+		return shouldSubscribeToUserRole && shouldSubscribeToUserId && shouldSubscribeToIntercomGroups;
+	}
+
+	getUserTalkIntercomChannels(userId) {
+		let talkIntercomChannels = []
+		let transceiver = this.#subscriberHandle.webrtcStuff.transceiverMap.find(t => t.display && decodeJanusDisplay(t.display)?.userId === userId && t.description);
+
+		if(!transceiver) {
+			return talkIntercomChannels;
+		}
+
+		try {
+			let description = JSON.parse(transceiver.description);
+			if(description.intercomGroups) {
+				description.intercomGroups.forEach(group => {
+					if(!talkIntercomChannels.includes(group)) {
+						talkIntercomChannels.push(group);
+					}
+				});
+			}
+		} catch (e) {}
+
+		return talkIntercomChannels;
+	}
+
+	async setTalkIntercomChannels(groups = ['participants']) {
+
+		if(typeof groups !== 'object' || !("length" in groups)) {
+			this._log('setTalkIntercomChannels: groups must be an array');
+			groups = [groups];
+		}
+
+		this._talkIntercomChannels = structuredClone(groups);
+		let handle = this.#getHandle(this.handleId);
+		if (!handle) {
+			return Promise.resolve();
+		}
+		let config = handle.webrtcStuff;
+		let descriptions = [];
+		let transceivers = config.pc.getTransceivers();
+		Object.keys(config.streamMap[this.id]).forEach(source => {
+			const simulcastConfigForSource = this.#findSimulcastConfig(source, this.simulcastSettings);
+			config.streamMap[this.id][source].forEach(trackId => {
+				let t = transceivers.find(transceiver => transceiver.sender.track && transceiver.sender.track.id === trackId)
+				if(t) {
+					descriptions.push({mid: t.mid, description: JSON.stringify({source, simulcastBitrates: simulcastConfigForSource?.bitrates, intercomGroups: this._talkIntercomChannels})});
+				}
+			})
+		});
+
+		return await this.sendMessage(this.handleId, {
+			body: {
+				"request": "configure",
+				descriptions: descriptions,
+			}
+		})
+	}
+
+	async setListenIntercomChannels(groups = ['participants']) {
+
+		if(typeof groups !== 'object' || !("length" in groups)) {
+			this._log('setListenIntercomChannels: groups must be an array');
+			groups = [groups];
+		}
+
+		this._listenIntercomChannels = structuredClone(groups);
+
+		if(!this.isConnected) {
+			return
+		}
+
+		return await this.#updateSubscriptions();
+	}
+
+	async setRestrictSubscribeToUserIds(userIds = []) {
+
+		if(typeof userIds !== 'object' || !("length" in userIds)) {
+			this._log('setRestrictSubscribeToUserIds: userIds must be an array');
+			userIds = [userIds];
+		}
+
+		this._restrictSubscribeToUserIds = structuredClone(userIds);
+
+		if(!this.isConnected) {
+			return
+		}
+
+		return await this.#updateSubscriptions();
+	}
+
+	async selectSubStream(id, substream = 2, temporal = 2, source, mid) {
+
+		this._log('Select substream called for id:', id, 'Source, mid:', source, mid, 'Substream:', substream, 'Temporal:', temporal);
+
+		let config = this.#subscriberHandle.webrtcStuff;
+		return new Promise((resolve, reject) => {
+			let messageTimeoutId;
+
+			if(!config.streamMap[id]) {
+				reject('no user found');
+			}
+
+			let clearListeners = () => {
+				clearTimeout(messageTimeoutId);
+				this._abortController.signal.removeEventListener('abort', abortResponse);
+				this.off('longPollEvent', parseResponse);
+				this.ws?.removeEventListener('message', parseResponse);
+			};
+
+			let abortResponse = () => {
+				clearListeners();
+				reject('aborted');
+			};
+
+			let parseResponse = (event) => {
+				let json = typeof event.data === 'string'
+					? JSON.parse(event.data)
+					: event.data;
+
+				var sender = json["sender"];
+				if(sender === this.#subscriberHandle.handleId) {
+					let plugindata = json["plugindata"] || {};
+					let msg = plugindata["data"] || {};
+					let substream = msg["substream"];
+					if(substream !== undefined && substream !== null && (mid !== undefined ? msg["mid"] === mid : true)) {
+						clearListeners();
+						resolve({substream, sender});
+					}
+				}
+			}
+
+			if(source !== undefined || mid !== undefined) {
+				if(mid === undefined) {
+					let transceivers = config.pc.getTransceivers();
+					for(let trackId of config.streamMap[id][source]) {
+						let transceiver = transceivers.find(transceiver => transceiver.receiver.track && transceiver.receiver.track.kind === 'video' && transceiver.receiver.track.id === trackId)
+						if(transceiver) {
+							mid = transceiver.mid;
+							break;
+						}
+					}
+				}
+				if(mid !== undefined) {
+
+					this.on('longPollEvent', parseResponse);
+					this.ws?.addEventListener('message', parseResponse);
+					this._abortController.signal.addEventListener('abort', abortResponse);
+					messageTimeoutId = setTimeout(() => {
+						clearListeners();
+						reject('timeout');
+					}, 10000);
+
+					this.sendMessage(this.#subscriberHandle.handleId, {
+						"body": {
+							"request": "configure",
+							"streams": [
+								{
+									mid, substream: parseInt(substream), temporal: parseInt(temporal)
+								}
+							]
+						}
+					})
+				} else {
+					reject('no mid found');
+				}
+			}
+			else {
+				reject('no source or mid');
+			}
+		});
+	}
+
+	async #getStats(type = 'video') {
+
+		let handle = this.#subscriberHandle;
+		if(handle) {
+
+			const tracks =  handle?.webrtcStuff?.tracks.filter(track =>  track.kind === type);
+			const transceivers = handle?.webrtcStuff?.pc?.getTransceivers();
+			return await tracks.reduce(async (prevPromise, track) => {
+
+				const results = await prevPromise;
+				const mid = transceivers.find(t =>
+					t.receiver?.track?.id === track.id || t.sender?.track?.id === track.id
+				)?.mid;
+				const transceiverData = this.#getTransceiverDataByMid(mid);
+
+				const id = transceiverData?.feed_id ?? null;
+				const display = transceiverData?.feed_display ?? null;
+				const description = transceiverData.feed_description ?? null;
+
+				return handle.webrtcStuff.pc.getStats(track)
+					.then(stats => {
+
+						const parsedStats = {
+							inboundRtpStats: null,
+							remoteOutboundRtpStats: null,
+							candidatePairStats: null,
+							packetLoss: 0,
+							jitter: 0,
+							rtt: 0,
+							currentBandwidth: 0,
+							framesDecoded: 0,
+							framesDropped: 0,
+							framesReceived: 0,
+							frameRate: 0,
+							freezeCount: 0,
+							totalFreezesDuration: 0,
+						};
+
+						let selectedCandidatePairId = null;
+						
+						// First pass to identify the selected candidate pair ID from transport
+						stats.forEach(stat => {
+							if (stat.type === 'transport' && stat.selectedCandidatePairId) {
+								selectedCandidatePairId = stat.selectedCandidatePairId;
+							}
+						});
+
+						// Second pass to process all stats
+						stats.forEach(stat => {
+							// Inbound RTP stats processing
+							if (stat.type === 'inbound-rtp' && !stat.isRemote) {
+								parsedStats.inboundRtpStats = stat;
+								
+								// Consistent unit conversion - convert seconds to milliseconds for jitter
+								parsedStats.jitter = stat.jitter ? Math.round(stat.jitter * 1000) : 0;
+								
+								parsedStats.framesDecoded = stat.framesDecoded || 0;
+								parsedStats.framesDropped = stat.framesDropped || 0;
+								parsedStats.framesReceived = stat.framesReceived || 0;
+								parsedStats.frameRate = stat.framesPerSecond || 0;
+								parsedStats.freezeCount = stat.freezeCount || 0;
+								parsedStats.totalFreezesDuration = stat.totalFreezesDuration || 0;
+
+								// Robust packet loss calculation
+								if (stat.packetsLost !== undefined && stat.packetsReceived !== undefined) {
+									const totalPackets = stat.packetsLost + stat.packetsReceived;
+									if (totalPackets > 0) {
+										// Calculate as percentage and round to 2 decimal places for accuracy
+										parsedStats.packetLoss = Number(((stat.packetsLost / totalPackets) * 100).toFixed(2));
+									} else {
+										parsedStats.packetLoss = 0;
+									}
+								} else {
+									parsedStats.packetLoss = 0;
+								}
+							}
+
+							if (stat.type === 'remote-outbound-rtp') {
+								parsedStats.remoteOutboundRtpStats = stat;
+							}
+
+							// Find active candidate pair based on the selectedCandidatePairId
+							if (stat.type === 'candidate-pair' && 
+								(stat.selected || stat.id === selectedCandidatePairId)) {
+								parsedStats.candidatePairStats = stat;
+								
+								// RTT calculation from candidate pair
+								if (stat.currentRoundTripTime) {
+									parsedStats.rtt = Math.round(stat.currentRoundTripTime * 1000); // Convert to ms
+								} else if (stat.totalRoundTripTime && stat.responsesReceived > 0) {
+									parsedStats.rtt = Math.round((stat.totalRoundTripTime / stat.responsesReceived) * 1000);
+								}
+							}
+						});
+
+						// Additional fallback for bandwidth estimation from inboundRtp
+						if (parsedStats.currentBandwidth === 0 && parsedStats.inboundRtpStats) {
+							const stat = parsedStats.inboundRtpStats;
+							// Simple estimation based on received bytes over time
+							if (stat.bytesReceived && stat.timestamp && handle.webrtcStuff.stats && 
+								handle.webrtcStuff.stats[stat.id]) {
+								const prevStat = handle.webrtcStuff.stats[stat.id];
+								const timeDiff = stat.timestamp - prevStat.timestamp;
+								if (timeDiff > 0) {
+									const bitrateBps = 8000 * (stat.bytesReceived - prevStat.bytesReceived) / timeDiff;
+									parsedStats.currentBandwidth = Math.floor(bitrateBps / 1000);
+								}
+							}
+							// Store current stats for next calculation
+							if (!handle.webrtcStuff.stats) {
+								handle.webrtcStuff.stats = {};
+							}
+							handle.webrtcStuff.stats[stat.id] = { ...stat };
+						}
+
+						return [...results, {
+                            stats: Object.fromEntries(stats), // Convert MapLike object to regular object
+                            parsedStats,
+                            id,
+                            display,
+                            description,
+                            mid
+                        }];
+					});
+			}, Promise.resolve([]))
+		}
+        
+        return [];
+	}
+
+	#adjustVideoQualitySettings(stats) {
+
+		// Only proceed if we have stats to work with and simulcast is enabled
+		if (!stats?.length || !this.simulcast) {
+			return;
+		}
+
+		const handle = this.#subscriberHandle;
+		const webrtcStuff = handle?.webrtcStuff;
+
+		if(!handle) {
+			return
+		}
+
+		const now = Date.now();
+		
+		// Process each video stream's stats
+		for (const stat of stats) {
+			// Skip if no parsedStats or missing essential data
+			if (!stat.parsedStats || !stat.mid || !stat.id || !stat.description) {
+				continue;
+			}
+			
+			const mid = stat.mid;
+			const feedId = stat.id;
+			
+			// Parse description to get simulcast settings
+			let simulcastConfig = null;
+			try {
+				const description = typeof stat.description === 'string' ? 
+					JSON.parse(stat.description) : stat.description;
+				
+				if (description?.simulcastBitrates) {
+					simulcastConfig = {
+						bitrates: description.simulcastBitrates,
+						defaultSubstream: 0 // Default to highest quality initially
+					};
+				}
+			} catch (e) {
+				this._log('Error parsing simulcast config:', e);
+				continue;
+			}
+
+			// Skip if no simulcast config or we don't have layer tracking for this mid
+			if (!simulcastConfig || !webrtcStuff?.currentLayers?.has(mid)) {
+				continue;
+			}
+			
+			const currentLayer = webrtcStuff?.currentLayers?.get(mid);
+			const currentSubstream = currentLayer.substream;
+			const currentTemporal = currentLayer.temporal === -1 ? 2 : currentLayer.temporal;
+			
+			// Initialize quality history for this mid if needed
+			if (!webrtcStuff.qualityHistory.has(mid)) {
+				webrtcStuff.qualityHistory.set(mid, []);
+				webrtcStuff.lastSwitchTime.set(mid, 0);
+			}
+			
+			// Extract network stats
+			const { 
+				packetLoss, 
+				jitter, 
+				rtt, 
+				currentBandwidth,
+				framesDropped,
+				framesReceived,
+				freezeCount,
+				totalFreezesDuration
+			} = stat.parsedStats;
+			
+			// Calculated stats (like frame drop rate)
+			const frameDropRate = framesReceived ? (framesDropped / framesReceived * 100) : 0;
+
+			// Add current quality measurement to history
+			const qualityMeasure = {
+				timestamp: now,
+				packetLoss,
+				jitter,
+				rtt,
+				currentBandwidth,
+				frameDropRate,
+				freezeCount,
+				totalFreezesDuration
+			};
+
+			// Determine whether we need to switch qualities
+			let targetSubstream = currentSubstream;
+
+			const history = webrtcStuff.qualityHistory.get(mid);
+			history.push(qualityMeasure);
+			
+			// Keep only recent history
+			const recentHistory = history.filter(item => now - item.timestamp < this.#rtcStatsConfig.historySize);
+			webrtcStuff.qualityHistory.set(mid, recentHistory);
+
+			let totalFreezesDurationTillLast = null;
+
+			// if we can calculate the freeze duration for last measured segment
+
+			if(recentHistory.length - 2 > -1) {
+
+				totalFreezesDurationTillLast = totalFreezesDuration - (recentHistory?.[recentHistory.length - 2]?.totalFreezesDuration ?? 0);
+				if(totalFreezesDurationTillLast * 1000 >= this.#rtcStatsConfig.freezeLengthThreshold * this._statsInterval) {
+					this._log(`Freezes detected for ${mid} - totalFreezesDuration: ${totalFreezesDuration}, totalFreezesDurationTillLast: ${totalFreezesDurationTillLast}`);
+					if (currentSubstream > 0) {
+						targetSubstream = currentSubstream - 1;
+					}
+
+					// Apply the layer change if needed
+					// Don't change layers if we haven't waited enough since last switch
+
+					if (targetSubstream !== currentSubstream && now - webrtcStuff.lastSwitchTime.get(mid) >= this.#rtcStatsConfig.switchCooldownForFreeze) {
+						webrtcStuff.lastSwitchTime.set(mid, now);
+						this.selectSubStream(feedId, targetSubstream, currentTemporal, null, mid)
+							.then(() => {
+								this._log(`Successfully switched substream for ${mid} to ${targetSubstream}`);
+							})
+							.catch(err => {
+								this._log(`Failed to switch substream for ${mid}:`, err);
+							});
+					}
+					continue;
+				}
+			}
+
+			// Don't change layers if we haven't waited enough since last switch
+			if (now - webrtcStuff.lastSwitchTime.get(mid) < this.#rtcStatsConfig.switchCooldown) {
+				continue;
+			}
+			
+			// Get median values from recent history to avoid making decisions on outliers
+			const medianPacketLoss = median(recentHistory.map(item => item.packetLoss));
+			const medianJitter = median(recentHistory.map(item => item.jitter));
+			const medianRtt = median(recentHistory.map(item => item.rtt));
+			const medianBandwidth = median(recentHistory.map(item => item.currentBandwidth));
+			const medianFrameDropRate = median(recentHistory.map(item => item.frameDropRate));
+
+			// Check for network issues that would require downgrading
+			const hasHighPacketLoss = medianPacketLoss > this.#rtcStatsConfig.packetLossThreshold;
+			const hasHighJitter = medianJitter > this.#rtcStatsConfig.jitterBufferThreshold;
+			const hasHighRtt = medianRtt > this.#rtcStatsConfig.roundTripTimeThreshold;
+			// Check if we have high frame drop rate
+			const hasHighFrameDropRate = medianFrameDropRate > this.#rtcStatsConfig.frameDropRateThreshold; // 5% frame drop threshold
+
+			// Determine required bandwidth based on simulcast config
+			let currentLayerBitrate = 0;
+			let nextHigherLayerBitrate = 0;
+
+			// Bitrates are ordered from high to low (h, m, l)
+			if (simulcastConfig?.bitrates?.length > currentSubstream) {
+				currentLayerBitrate = simulcastConfig.bitrates[2 - currentSubstream].maxBitrate / 1000; // Convert to kbps
+
+				if (currentSubstream < simulcastConfig?.bitrates?.length - 1) {
+					nextHigherLayerBitrate = simulcastConfig.bitrates[(2 - currentSubstream) - 1].maxBitrate / 1000;
+				}
+			}
+
+			// !!! WE CAN'T USE THIS AS IT REPORTS medianBandwidth of 1500 for 2000 stream and the stream works just fine
+			// Check if we have enough bandwidth for current layer
+			const hasLowBandwidthForCurrentLayer = medianBandwidth < (currentLayerBitrate * this.#rtcStatsConfig.badBandwidthThresholdMultiplier);
+
+			// Log stats for debugging
+			this._log(`Stream ${mid} stats:`, {
+				packetLoss: medianPacketLoss,
+				jitter: medianJitter,
+				rtt: medianRtt,
+				bandwidth: medianBandwidth,
+				frameDropRate: medianFrameDropRate,
+				currentLayerBitrate,
+				currentSubstream,
+				totalFreezesDurationTillLast
+			});
+			
+			// Network issues detected - downgrade if possible
+			if (hasHighPacketLoss || hasHighJitter || hasHighRtt || hasHighFrameDropRate) {
+				// Can't downgrade if already at lowest quality
+				if (currentSubstream > 0) {
+					targetSubstream = currentSubstream - 1;
+					this._log(`Downgrading stream quality for ${mid} due to network issues:`, {
+						packetLoss: medianPacketLoss,
+						jitter: medianJitter,
+						rtt: medianRtt,
+						bandwidth: medianBandwidth,
+						frameDropRate: medianFrameDropRate,
+						from: currentSubstream,
+						to: targetSubstream
+					});
+				}
+			} 
+			// Check if we can upgrade - network is good
+			else {
+
+				const stableHistory = recentHistory.filter(item => now - item.timestamp < this.#rtcStatsConfig.stableNetworkTime)
+				const hasStableNetwork = stableHistory.every(item => item.packetLoss < this.#rtcStatsConfig.packetLossThreshold &&
+						item.jitter < this.#rtcStatsConfig.jitterBufferThreshold &&
+						item.rtt < this.#rtcStatsConfig.roundTripTimeThreshold &&
+						item.frameDropRate < this.#rtcStatsConfig.frameDropRateThreshold
+					);
+
+				if (hasStableNetwork) {
+					if(currentSubstream < 2) {
+						targetSubstream = currentSubstream + 1;
+						this._log(`Upgrading stream quality for ${mid} due to good network conditions:`, {
+							packetLoss: medianPacketLoss,
+							jitter: medianJitter,
+							rtt: medianRtt,
+							bandwidth: medianBandwidth,
+							from: currentSubstream,
+							to: targetSubstream
+						});
+					}
+				}
+			}
+
+			// Apply the layer change if needed
+			if (targetSubstream !== currentSubstream) {
+				webrtcStuff.lastSwitchTime.set(mid, now);
+				this.selectSubStream(feedId, targetSubstream, currentTemporal, null, mid)
+					.then(() => {
+						this._log(`Successfully switched substream for ${mid} to ${targetSubstream}`);
+					})
+					.catch(err => {
+						this._log(`Failed to switch substream for ${mid}:`, err);
+					});
+			}
+		}
+	}
+
+	#emitRtcStats(stats) {
+		if (stats?.length > 0) {
+			const s = stats.map(stat => {
+				const {
+					currentBandwidth,
+					frameRate,
+					framesDecoded,
+					framesDropped,
+					framesReceived,
+					freezeCount,
+					jitter,
+					packetLoss,
+					rtt,
+					totalFreezesDuration
+				} = stat.parsedStats;
+
+				let description = {};
+				try {
+					description = JSON.parse(stat.description);
+				} catch {}
+				return {
+					id: stat.id,
+					mid: stat.mid,
+					userId: decodeJanusDisplay(stat.display)?.userId,
+					source: description.source,
+					stats: {
+						currentBandwidth,
+						frameRate,
+						framesDecoded,
+						framesDropped,
+						framesReceived,
+						freezeCount,
+						jitter,
+						packetLoss,
+						rtt,
+						totalFreezesDuration
+					}
+				}
+			});
+			this.emit('rtcStats', s);
+		}
+	}
+
+	#disableStatsWatch() {
+		if (this._statsIntervalId) {
+			clearInterval(this._statsIntervalId);
+			this._statsIntervalId = null;
+		}
+	}
+
+	#enableStatsWatch() {
+
+		this.#disableStatsWatch();
+
+		const loop = () => {
+			this.#getStats('video')
+				.then(stats => {
+					if (stats && stats.length > 0) {
+						this.#emitRtcStats(stats)
+						if(this.options.enableVideoQualityAdjustment) {
+							this.#adjustVideoQualitySettings(stats);
+						}
+					}
+				})
+		};
+
+		this._statsIntervalId = setInterval(loop, this._statsInterval);
+	}
+
+}
+
+
+export default Room;
+
+
+