@whereby.com/core 0.25.0 → 0.26.0

package/dist/index.cjs

@@ -2,8 +2,8 @@
 
 var toolkit = require('@reduxjs/toolkit');
 var media = require('@whereby.com/media');
-var events$1 = require('events');
 var Chrome111_js = require('mediasoup-client/lib/handlers/Chrome111.js');
+var events$1 = require('events');
 var nodeBtoa = require('btoa');
 var axios = require('axios');
 
@@ -45,9 +45,9 @@ const createReactor = (selectors, callback) => {
     });
 };
 
-const coreVersion = "0.25.0";
+const coreVersion = "0.26.0";
 
-const initialState$f = {
+const initialState$g = {
     isNodeSdk: false,
     isActive: false,
     isDialIn: false,
@@ -59,7 +59,7 @@ const initialState$f = {
 };
 const appSlice = toolkit.createSlice({
     name: "app",
-    initialState: initialState$f,
+    initialState: initialState$g,
     reducers: {
         doAppStart: (state, action) => {
             const url = new URL(action.payload.roomUrl);
@@ -122,13 +122,13 @@ const ROOM_ACTION_PERMISSIONS_BY_ROLE = {
     canAskToSpeak: ["host"],
     canSpotlight: ["host"],
 };
-const initialState$e = {
+const initialState$f = {
     roomKey: null,
     roleName: "none",
 };
 const authorizationSlice = toolkit.createSlice({
     name: "authorization",
-    initialState: initialState$e,
+    initialState: initialState$f,
     reducers: {
         setRoomKey: (state, action) => {
             return Object.assign(Object.assign({}, state), { roomKey: action.payload });
@@ -199,13 +199,13 @@ typeof SuppressedError === "function" ? SuppressedError : function (error, suppr
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 };
 
-const initialState$d = {
+const initialState$e = {
     isFetching: false,
     data: null,
 };
 const deviceCredentialsSlice = toolkit.createSlice({
     name: "deviceCredentials",
-    initialState: initialState$d,
+    initialState: initialState$e,
     reducers: {},
     extraReducers: (builder) => {
         builder.addCase(doGetDeviceCredentials.pending, (state) => {
@@ -280,7 +280,7 @@ function createSocket() {
     };
     return new media.ServerSocket(socketHost, socketOverrides);
 }
-const initialState$c = {
+const initialState$d = {
     deviceIdentified: false,
     isIdentifyingDevice: false,
     status: "ready",
@@ -288,7 +288,7 @@ const initialState$c = {
 };
 const signalConnectionSlice = toolkit.createSlice({
     name: "signalConnection",
-    initialState: initialState$c,
+    initialState: initialState$d,
     reducers: {
         socketConnecting: (state) => {
             return Object.assign(Object.assign({}, state), { status: "connecting" });
@@ -297,7 +297,7 @@ const signalConnectionSlice = toolkit.createSlice({
             return Object.assign(Object.assign({}, state), { socket: action.payload, status: "connected" });
         },
         socketDisconnected: (state) => {
-            return Object.assign(Object.assign({}, state), { deviceIdentified: false, status: "disconnected" });
+            return Object.assign(Object.assign({}, state), { socket: null, deviceIdentified: false, status: "disconnected" });
         },
         socketReconnecting: (state) => {
             return Object.assign(Object.assign({}, state), { status: "reconnecting" });
@@ -392,12 +392,12 @@ startAppListening({
     },
 });
 
-const initialState$b = {
+const initialState$c = {
     chatMessages: [],
 };
 const chatSlice = toolkit.createSlice({
     name: "chat",
-    initialState: initialState$b,
+    initialState: initialState$c,
     reducers: {},
     extraReducers(builder) {
         builder.addCase(signalEvents.chatMessage, (state, action) => {
@@ -478,6 +478,60 @@ const selectCloudRecordingStartedAt = (state) => state.cloudRecording.startedAt;
 const selectCloudRecordingError = (state) => state.cloudRecording.error;
 const selectIsCloudRecording = (state) => state.cloudRecording.isRecording;
 
+const initialState$b = {
+    data: null,
+    isFetching: false,
+    error: null,
+};
+const organizationSlice = toolkit.createSlice({
+    initialState: initialState$b,
+    name: "organization",
+    reducers: {},
+    extraReducers: (builder) => {
+        builder.addCase(doOrganizationFetch.pending, (state) => {
+            return Object.assign(Object.assign({}, state), { isFetching: true });
+        });
+        builder.addCase(doOrganizationFetch.fulfilled, (state, action) => {
+            if (!action.payload)
+                return Object.assign(Object.assign({}, state), { isFetching: true });
+            return Object.assign(Object.assign({}, state), { isFetching: false, data: action.payload });
+        });
+        builder.addCase(doOrganizationFetch.rejected, (state) => {
+            return Object.assign(Object.assign({}, state), { isFetching: false, error: true });
+        });
+    },
+});
+const doOrganizationFetch = createAppAsyncThunk("organization/doOrganizationFetch", (_, { extra, getState }) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const roomUrl = selectAppRoomUrl(getState());
+        const organization = yield extra.services.fetchOrganizationFromRoomUrl(roomUrl || "");
+        if (!organization) {
+            throw new Error("Invalid room url");
+        }
+        return organization;
+    }
+    catch (error) {
+        console.error(error);
+    }
+}));
+const selectOrganizationRaw = (state) => state.organization;
+const selectOrganizationId = (state) => { var _a; return (_a = state.organization.data) === null || _a === void 0 ? void 0 : _a.organizationId; };
+const selectShouldFetchOrganization = toolkit.createSelector(selectAppIsActive, selectOrganizationRaw, selectDeviceCredentialsRaw, (appIsActive, organization, deviceCredentials) => {
+    if (appIsActive &&
+        !organization.data &&
+        !organization.isFetching &&
+        !organization.error &&
+        !deviceCredentials.isFetching) {
+        return true;
+    }
+    return false;
+});
+createReactor([selectShouldFetchOrganization], ({ dispatch }, shouldFetchOrganization) => {
+    if (shouldFetchOrganization) {
+        dispatch(doOrganizationFetch());
+    }
+});
+
 function fakeAudioStream() {
     const audioCtx = new AudioContext();
     const oscillator = audioCtx.createOscillator();
@@ -1183,82 +1237,175 @@ createReactor([selectLocalParticipantDisplayName, selectLocalParticipantStickyRe
 });
 
 const initialState$9 = {
-    status: "inactive",
-    stream: null,
+    session: null,
+    status: "ready",
     error: null,
 };
-const localScreenshareSlice = toolkit.createSlice({
-    name: "localScreenshare",
+const roomConnectionSlice = toolkit.createSlice({
     initialState: initialState$9,
+    name: "roomConnection",
     reducers: {
-        stopScreenshare(state, action) {
-            return Object.assign(Object.assign({}, state), { status: "inactive", stream: null });
+        connectionStatusChanged: (state, action) => {
+            return Object.assign(Object.assign({}, state), { status: action.payload });
         },
     },
     extraReducers: (builder) => {
-        builder.addCase(doStartScreenshare.pending, (state) => {
-            return Object.assign(Object.assign({}, state), { status: "starting" });
+        builder.addCase(signalEvents.roomJoined, (state, action) => {
+            var _a, _b;
+            const { error, isLocked } = action.payload;
+            if (error === "room_locked" && isLocked) {
+                return Object.assign(Object.assign({}, state), { status: "room_locked" });
+            }
+            if (error) {
+                return Object.assign(Object.assign({}, state), { status: "disconnected", error });
+            }
+            return Object.assign(Object.assign({}, state), { status: "connected", session: (_b = (_a = action.payload.room) === null || _a === void 0 ? void 0 : _a.session) !== null && _b !== void 0 ? _b : null });
         });
-        builder.addCase(doStartScreenshare.fulfilled, (state, { payload: { stream } }) => {
-            return Object.assign(Object.assign({}, state), { status: "active", stream });
+        builder.addCase(signalEvents.disconnect, (state) => {
+            if (["kicked", "left"].includes(state.status)) {
+                return Object.assign({}, state);
+            }
+            return Object.assign(Object.assign({}, state), { status: "disconnected" });
         });
-        builder.addCase(doStartScreenshare.rejected, (state, { payload }) => {
-            return Object.assign(Object.assign({}, state), { error: payload, status: "inactive", stream: null });
+        builder.addCase(signalEvents.newClient, (state, action) => {
+            var _a, _b;
+            return Object.assign(Object.assign({}, state), { session: (_b = (_a = action.payload.room) === null || _a === void 0 ? void 0 : _a.session) !== null && _b !== void 0 ? _b : null });
+        });
+        builder.addCase(signalEvents.roomSessionEnded, (state, action) => {
+            var _a;
+            if (((_a = state.session) === null || _a === void 0 ? void 0 : _a.id) !== action.payload.roomSessionId) {
+                return state;
+            }
+            return Object.assign(Object.assign({}, state), { session: null });
+        });
+        builder.addCase(signalEvents.clientKicked, (state) => {
+            return Object.assign(Object.assign({}, state), { status: "kicked" });
+        });
+        builder.addCase(signalEvents.roomLeft, (state) => {
+            return Object.assign(Object.assign({}, state), { status: "left" });
+        });
+        builder.addCase(socketReconnecting, (state) => {
+            return Object.assign(Object.assign({}, state), { status: "reconnecting" });
         });
     },
 });
-const { stopScreenshare } = localScreenshareSlice.actions;
-const doStartScreenshare = createAppAsyncThunk("localScreenshare/doStartScreenshare", (_, { dispatch, getState, rejectWithValue }) => __awaiter(void 0, void 0, void 0, function* () {
-    var _a;
-    try {
-        const state = getState();
-        const screenshareStream = selectLocalScreenshareStream(state);
-        if (screenshareStream) {
-            return { stream: screenshareStream };
-        }
-        const stream = yield navigator.mediaDevices.getDisplayMedia();
-        const onEnded = () => {
-            dispatch(doStopScreenshare());
-        };
-        if ("oninactive" in stream) {
-            stream.addEventListener("inactive", onEnded);
-        }
-        else {
-            (_a = stream.getVideoTracks()[0]) === null || _a === void 0 ? void 0 : _a.addEventListener("ended", onEnded);
-        }
-        return { stream };
-    }
-    catch (error) {
-        return rejectWithValue(error);
-    }
-}));
-const doStopScreenshare = createAppThunk(() => (dispatch, getState) => {
+const { connectionStatusChanged } = roomConnectionSlice.actions;
+const doKnockRoom = createAppThunk(() => (dispatch, getState) => {
     const state = getState();
-    const screenshareStream = selectLocalScreenshareStream(state);
-    if (!screenshareStream) {
-        return;
+    const socket = selectSignalConnectionRaw(state).socket;
+    const roomName = selectAppRoomName(state);
+    const roomKey = selectRoomKey(state);
+    const displayName = selectAppDisplayName(state);
+    const isDialIn = selectAppIsDialIn(state);
+    const userAgent = selectAppUserAgent(state);
+    const externalId = selectAppExternalId(state);
+    const organizationId = selectOrganizationId(state);
+    socket === null || socket === void 0 ? void 0 : socket.emit("knock_room", {
+        avatarUrl: null,
+        config: {
+            isAudioEnabled: true,
+            isVideoEnabled: true,
+        },
+        deviceCapabilities: { canScreenshare: true },
+        displayName,
+        isCoLocated: false,
+        isDialIn,
+        isDevicePermissionDenied: false,
+        kickFromOtherRooms: false,
+        organizationId,
+        roomKey,
+        roomName,
+        userAgent,
+        externalId,
+    });
+    dispatch(connectionStatusChanged("knocking"));
+});
+const doConnectRoom = createAppThunk(() => (dispatch, getState) => {
+    const state = getState();
+    const socket = selectSignalConnectionRaw(state).socket;
+    const roomName = selectAppRoomName(state);
+    const roomKey = selectRoomKey(state);
+    const displayName = selectAppDisplayName(state);
+    const userAgent = selectAppUserAgent(state);
+    const externalId = selectAppExternalId(state);
+    const isDialIn = selectAppIsDialIn(state);
+    const organizationId = selectOrganizationId(state);
+    const isCameraEnabled = selectIsCameraEnabled(getState());
+    const isMicrophoneEnabled = selectIsMicrophoneEnabled(getState());
+    const clientClaim = selectLocalParticipantClientClaim(getState());
+    socket === null || socket === void 0 ? void 0 : socket.emit("join_room", Object.assign({ avatarUrl: null, config: {
+            isAudioEnabled: isMicrophoneEnabled,
+            isVideoEnabled: isCameraEnabled,
+        }, deviceCapabilities: { canScreenshare: true }, displayName, isCoLocated: false, isDialIn, isDevicePermissionDenied: false, kickFromOtherRooms: false, organizationId,
+        roomKey,
+        roomName,
+        userAgent,
+        externalId }, (clientClaim && { clientClaim })));
+    dispatch(connectionStatusChanged("connecting"));
+});
+const selectRoomConnectionRaw = (state) => state.roomConnection;
+const selectRoomConnectionSession = (state) => state.roomConnection.session;
+const selectRoomConnectionSessionId = (state) => { var _a; return (_a = state.roomConnection.session) === null || _a === void 0 ? void 0 : _a.id; };
+const selectRoomConnectionStatus = (state) => state.roomConnection.status;
+const selectRoomConnectionError = (state) => state.roomConnection.error;
+const selectShouldConnectRoom = toolkit.createSelector([
+    selectAppIsActive,
+    selectOrganizationId,
+    selectRoomConnectionStatus,
+    selectSignalConnectionDeviceIdentified,
+    selectLocalMediaStatus,
+    selectRoomConnectionError,
+], (appIsActive, hasOrganizationIdFetched, roomConnectionStatus, signalConnectionDeviceIdentified, localMediaStatus, roomConnectionError) => {
+    if (appIsActive &&
+        localMediaStatus === "started" &&
+        signalConnectionDeviceIdentified &&
+        !!hasOrganizationIdFetched &&
+        ["ready", "reconnecting", "disconnected"].includes(roomConnectionStatus) &&
+        !roomConnectionError) {
+        return true;
+    }
+    return false;
+});
+createReactor([selectShouldConnectRoom], ({ dispatch }, shouldConnectRoom) => {
+    if (shouldConnectRoom) {
+        dispatch(doConnectRoom());
     }
-    screenshareStream.getTracks().forEach((track) => track.stop());
-    dispatch(stopScreenshare({ stream: screenshareStream }));
 });
-const selectLocalScreenshareRaw = (state) => state.localScreenshare;
-const selectLocalScreenshareStatus = (state) => state.localScreenshare.status;
-const selectLocalScreenshareStream = (state) => state.localScreenshare.stream;
 startAppListening({
-    actionCreator: localMediaStopped,
-    effect: (_, { getState }) => {
+    actionCreator: signalEvents.knockHandled,
+    effect: ({ payload }, { dispatch, getState }) => {
+        const { clientId, resolution } = payload;
         const state = getState();
-        const screenshareStream = selectLocalScreenshareStream(state);
-        if (!screenshareStream) {
+        const selfId = selectSelfId(state);
+        if (clientId !== selfId) {
             return;
         }
-        screenshareStream === null || screenshareStream === void 0 ? void 0 : screenshareStream.getTracks().forEach((track) => {
-            track.stop();
-        });
-    },
-});
-
-function createRtcEventAction(name) {
+        if (resolution === "accepted") {
+            dispatch(setRoomKey(payload.metadata.roomKey));
+            dispatch(doConnectRoom());
+        }
+        else if (resolution === "rejected") {
+            dispatch(connectionStatusChanged("knock_rejected"));
+        }
+    },
+});
+startAppListening({
+    actionCreator: doAppStop,
+    effect: (_, { dispatch, getState }) => {
+        const state = getState();
+        const roomConnectionStatus = selectRoomConnectionStatus(state);
+        if (roomConnectionStatus === "connected") {
+            const socket = selectSignalConnectionRaw(state).socket;
+            socket === null || socket === void 0 ? void 0 : socket.emit("leave_room");
+            dispatch(connectionStatusChanged("leaving"));
+        }
+        else {
+            doSignalDisconnect();
+        }
+    },
+});
+
+function createRtcEventAction(name) {
     return toolkit.createAction(`rtcConnection/event/${name}`);
 }
 const rtcEvents = {
@@ -1460,373 +1607,388 @@ const selectNumParticipants = toolkit.createSelector(selectRemoteParticipants, s
 });
 
 const initialState$7 = {
-    data: null,
-    isFetching: false,
+    status: "inactive",
+    stream: null,
     error: null,
 };
-const organizationSlice = toolkit.createSlice({
+const localScreenshareSlice = toolkit.createSlice({
+    name: "localScreenshare",
     initialState: initialState$7,
-    name: "organization",
-    reducers: {},
+    reducers: {
+        stopScreenshare(state, action) {
+            return Object.assign(Object.assign({}, state), { status: "inactive", stream: null });
+        },
+    },
     extraReducers: (builder) => {
-        builder.addCase(doOrganizationFetch.pending, (state) => {
-            return Object.assign(Object.assign({}, state), { isFetching: true });
+        builder.addCase(doStartScreenshare.pending, (state) => {
+            return Object.assign(Object.assign({}, state), { status: "starting" });
         });
-        builder.addCase(doOrganizationFetch.fulfilled, (state, action) => {
-            if (!action.payload)
-                return Object.assign(Object.assign({}, state), { isFetching: true });
-            return Object.assign(Object.assign({}, state), { isFetching: false, data: action.payload });
+        builder.addCase(doStartScreenshare.fulfilled, (state, { payload: { stream } }) => {
+            return Object.assign(Object.assign({}, state), { status: "active", stream });
         });
-        builder.addCase(doOrganizationFetch.rejected, (state) => {
-            return Object.assign(Object.assign({}, state), { isFetching: false, error: true });
+        builder.addCase(doStartScreenshare.rejected, (state, { payload }) => {
+            return Object.assign(Object.assign({}, state), { error: payload, status: "inactive", stream: null });
         });
     },
 });
-const doOrganizationFetch = createAppAsyncThunk("organization/doOrganizationFetch", (_, { extra, getState }) => __awaiter(void 0, void 0, void 0, function* () {
+const { stopScreenshare } = localScreenshareSlice.actions;
+const doStartScreenshare = createAppAsyncThunk("localScreenshare/doStartScreenshare", (_, { dispatch, getState, rejectWithValue }) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a;
     try {
-        const roomUrl = selectAppRoomUrl(getState());
-        const organization = yield extra.services.fetchOrganizationFromRoomUrl(roomUrl || "");
-        if (!organization) {
-            throw new Error("Invalid room url");
+        const state = getState();
+        const screenshareStream = selectLocalScreenshareStream(state);
+        if (screenshareStream) {
+            return { stream: screenshareStream };
         }
-        return organization;
+        const stream = yield navigator.mediaDevices.getDisplayMedia();
+        const onEnded = () => {
+            dispatch(doStopScreenshare());
+        };
+        if ("oninactive" in stream) {
+            stream.addEventListener("inactive", onEnded);
+        }
+        else {
+            (_a = stream.getVideoTracks()[0]) === null || _a === void 0 ? void 0 : _a.addEventListener("ended", onEnded);
+        }
+        return { stream };
     }
     catch (error) {
-        console.error(error);
+        return rejectWithValue(error);
     }
 }));
-const selectOrganizationRaw = (state) => state.organization;
-const selectOrganizationId = (state) => { var _a; return (_a = state.organization.data) === null || _a === void 0 ? void 0 : _a.organizationId; };
-const selectShouldFetchOrganization = toolkit.createSelector(selectAppIsActive, selectOrganizationRaw, selectDeviceCredentialsRaw, (appIsActive, organization, deviceCredentials) => {
-    if (appIsActive &&
-        !organization.data &&
-        !organization.isFetching &&
-        !organization.error &&
-        !deviceCredentials.isFetching) {
-        return true;
+const doStopScreenshare = createAppThunk(() => (dispatch, getState) => {
+    const state = getState();
+    const screenshareStream = selectLocalScreenshareStream(state);
+    if (!screenshareStream) {
+        return;
     }
-    return false;
+    screenshareStream.getTracks().forEach((track) => track.stop());
+    dispatch(stopScreenshare({ stream: screenshareStream }));
 });
-createReactor([selectShouldFetchOrganization], ({ dispatch }, shouldFetchOrganization) => {
-    if (shouldFetchOrganization) {
-        dispatch(doOrganizationFetch());
-    }
+const selectLocalScreenshareRaw = (state) => state.localScreenshare;
+const selectLocalScreenshareStatus = (state) => state.localScreenshare.status;
+const selectLocalScreenshareStream = (state) => state.localScreenshare.stream;
+startAppListening({
+    actionCreator: localMediaStopped,
+    effect: (_, { getState }) => {
+        const state = getState();
+        const screenshareStream = selectLocalScreenshareStream(state);
+        if (!screenshareStream) {
+            return;
+        }
+        screenshareStream === null || screenshareStream === void 0 ? void 0 : screenshareStream.getTracks().forEach((track) => {
+            track.stop();
+        });
+    },
 });
 
+const createWebRtcEmitter = (dispatch) => {
+    return {
+        emit: (eventName, data) => {
+            if (eventName === "rtc_manager_created") {
+                dispatch(doRtcManagerCreated(data));
+            }
+            else if (eventName === "stream_added") {
+                dispatch(rtcEvents.streamAdded(data));
+            }
+            else if (eventName === "rtc_manager_destroyed") {
+                dispatch(rtcManagerDestroyed());
+            }
+            else ;
+        },
+    };
+};
 const initialState$6 = {
-    session: null,
-    status: "ready",
+    dispatcherCreated: false,
     error: null,
+    isCreatingDispatcher: false,
+    reportedStreamResolutions: {},
+    rtcManager: null,
+    rtcManagerDispatcher: null,
+    rtcManagerInitialized: false,
+    status: "inactive",
+    isAcceptingStreams: false,
 };
-const roomConnectionSlice = toolkit.createSlice({
+const rtcConnectionSlice = toolkit.createSlice({
+    name: "rtcConnection",
     initialState: initialState$6,
-    name: "roomConnection",
     reducers: {
-        connectionStatusChanged: (state, action) => {
-            return Object.assign(Object.assign({}, state), { status: action.payload });
+        isAcceptingStreams: (state, action) => {
+            return Object.assign(Object.assign({}, state), { isAcceptingStreams: action.payload });
+        },
+        resolutionReported: (state, action) => {
+            const { streamId, width, height } = action.payload;
+            return Object.assign(Object.assign({}, state), { reportedStreamResolutions: Object.assign(Object.assign({}, state.reportedStreamResolutions), { [streamId]: { width, height } }) });
+        },
+        rtcDisconnected: () => {
+            return Object.assign({}, initialState$6);
+        },
+        rtcDispatcherCreated: (state, action) => {
+            return Object.assign(Object.assign({}, state), { dispatcherCreated: true, rtcManagerDispatcher: action.payload });
+        },
+        rtcManagerCreated: (state, action) => {
+            return Object.assign(Object.assign({}, state), { rtcManager: action.payload, status: "ready" });
+        },
+        rtcManagerDestroyed: (state) => {
+            return Object.assign(Object.assign({}, state), { rtcManager: null });
+        },
+        rtcManagerInitialized: (state) => {
+            return Object.assign(Object.assign({}, state), { rtcManagerInitialized: true });
         },
     },
     extraReducers: (builder) => {
-        builder.addCase(signalEvents.roomJoined, (state, action) => {
-            var _a, _b;
-            const { error, isLocked } = action.payload;
-            if (error === "room_locked" && isLocked) {
-                return Object.assign(Object.assign({}, state), { status: "room_locked" });
-            }
-            if (error) {
-                return Object.assign(Object.assign({}, state), { status: "disconnected", error });
-            }
-            return Object.assign(Object.assign({}, state), { status: "connected", session: (_b = (_a = action.payload.room) === null || _a === void 0 ? void 0 : _a.session) !== null && _b !== void 0 ? _b : null });
-        });
-        builder.addCase(signalEvents.disconnect, (state) => {
-            if (["kicked", "left"].includes(state.status)) {
-                return Object.assign({}, state);
-            }
-            return Object.assign(Object.assign({}, state), { status: "disconnected" });
-        });
-        builder.addCase(signalEvents.newClient, (state, action) => {
-            var _a, _b;
-            return Object.assign(Object.assign({}, state), { session: (_b = (_a = action.payload.room) === null || _a === void 0 ? void 0 : _a.session) !== null && _b !== void 0 ? _b : null });
-        });
-        builder.addCase(signalEvents.roomSessionEnded, (state, action) => {
-            var _a;
-            if (((_a = state.session) === null || _a === void 0 ? void 0 : _a.id) !== action.payload.roomSessionId) {
-                return state;
-            }
-            return Object.assign(Object.assign({}, state), { session: null });
-        });
-        builder.addCase(signalEvents.clientKicked, (state) => {
-            return Object.assign(Object.assign({}, state), { status: "kicked" });
-        });
-        builder.addCase(signalEvents.roomLeft, (state) => {
-            return Object.assign(Object.assign({}, state), { status: "left" });
-        });
         builder.addCase(socketReconnecting, (state) => {
             return Object.assign(Object.assign({}, state), { status: "reconnecting" });
         });
+        builder.addCase(signalEvents.roomJoined, (state) => {
+            return Object.assign(Object.assign({}, state), { status: state.status === "reconnecting" ? "ready" : state.status });
+        });
     },
 });
-const { connectionStatusChanged } = roomConnectionSlice.actions;
-const doKnockRoom = createAppThunk(() => (dispatch, getState) => {
+const { resolutionReported, rtcDispatcherCreated, rtcDisconnected, rtcManagerCreated, rtcManagerDestroyed, rtcManagerInitialized, isAcceptingStreams, } = rtcConnectionSlice.actions;
+const doConnectRtc = createAppThunk(() => (dispatch, getState) => {
     const state = getState();
     const socket = selectSignalConnectionRaw(state).socket;
-    const roomName = selectAppRoomName(state);
-    const roomKey = selectRoomKey(state);
-    const displayName = selectAppDisplayName(state);
-    const isDialIn = selectAppIsDialIn(state);
-    const userAgent = selectAppUserAgent(state);
-    const externalId = selectAppExternalId(state);
-    const organizationId = selectOrganizationId(state);
-    socket === null || socket === void 0 ? void 0 : socket.emit("knock_room", {
-        avatarUrl: null,
-        config: {
-            isAudioEnabled: true,
-            isVideoEnabled: true,
+    const dispatcher = selectRtcConnectionRaw(state).rtcManagerDispatcher;
+    const isCameraEnabled = selectIsCameraEnabled(state);
+    const isMicrophoneEnabled = selectIsMicrophoneEnabled(state);
+    const isNodeSdk = selectAppIsNodeSdk(state);
+    if (dispatcher || !socket) {
+        return;
+    }
+    const webrtcProvider = {
+        getMediaConstraints: () => ({
+            audio: isMicrophoneEnabled,
+            video: isCameraEnabled,
+        }),
+        deferrable(clientId) {
+            return !clientId;
         },
-        deviceCapabilities: { canScreenshare: true },
-        displayName,
-        isCoLocated: false,
-        isDialIn,
-        isDevicePermissionDenied: false,
-        kickFromOtherRooms: false,
-        organizationId,
-        roomKey,
-        roomName,
-        userAgent,
-        externalId,
-    });
-    dispatch(connectionStatusChanged("knocking"));
-});
-const doConnectRoom = createAppThunk(() => (dispatch, getState) => {
-    const state = getState();
-    const socket = selectSignalConnectionRaw(state).socket;
-    const roomName = selectAppRoomName(state);
-    const roomKey = selectRoomKey(state);
-    const displayName = selectAppDisplayName(state);
-    const userAgent = selectAppUserAgent(state);
-    const externalId = selectAppExternalId(state);
-    const isDialIn = selectAppIsDialIn(state);
-    const organizationId = selectOrganizationId(state);
-    const isCameraEnabled = selectIsCameraEnabled(getState());
-    const isMicrophoneEnabled = selectIsMicrophoneEnabled(getState());
-    const clientClaim = selectLocalParticipantClientClaim(getState());
-    socket === null || socket === void 0 ? void 0 : socket.emit("join_room", Object.assign({ avatarUrl: null, config: {
-            isAudioEnabled: isMicrophoneEnabled,
-            isVideoEnabled: isCameraEnabled,
-        }, deviceCapabilities: { canScreenshare: true }, displayName, isCoLocated: false, isDialIn, isDevicePermissionDenied: false, kickFromOtherRooms: false, organizationId,
-        roomKey,
-        roomName,
-        userAgent,
-        externalId }, (clientClaim && { clientClaim })));
-    dispatch(connectionStatusChanged("connecting"));
+    };
+    const rtcManagerDispatcher = new media.RtcManagerDispatcher({
+        emitter: createWebRtcEmitter(dispatch),
+        serverSocket: socket,
+        webrtcProvider,
+        features: {
+            isNodeSdk,
+            lowDataModeEnabled: false,
+            sfuServerOverrideHost: undefined,
+            turnServerOverrideHost: undefined,
+            useOnlyTURN: undefined,
+            vp9On: false,
+            h264On: false,
+            simulcastScreenshareOn: false,
+            deviceHandlerFactory: isNodeSdk ? Chrome111_js.Chrome111.createFactory() : undefined,
+        },
+    });
+    dispatch(rtcDispatcherCreated(rtcManagerDispatcher));
 });
-const selectRoomConnectionRaw = (state) => state.roomConnection;
-const selectRoomConnectionSession = (state) => state.roomConnection.session;
-const selectRoomConnectionSessionId = (state) => { var _a; return (_a = state.roomConnection.session) === null || _a === void 0 ? void 0 : _a.id; };
-const selectRoomConnectionStatus = (state) => state.roomConnection.status;
-const selectRoomConnectionError = (state) => state.roomConnection.error;
-const selectShouldConnectRoom = toolkit.createSelector([
-    selectAppIsActive,
-    selectOrganizationId,
-    selectRoomConnectionStatus,
-    selectSignalConnectionDeviceIdentified,
-    selectLocalMediaStatus,
-    selectRoomConnectionError,
-], (appIsActive, hasOrganizationIdFetched, roomConnectionStatus, signalConnectionDeviceIdentified, localMediaStatus, roomConnectionError) => {
-    if (appIsActive &&
-        localMediaStatus === "started" &&
-        signalConnectionDeviceIdentified &&
-        !!hasOrganizationIdFetched &&
-        ["ready", "reconnecting", "disconnected"].includes(roomConnectionStatus) &&
-        !roomConnectionError) {
-        return true;
+const doDisconnectRtc = createAppThunk(() => (dispatch, getState) => {
+    const { rtcManager } = selectRtcConnectionRaw(getState());
+    if (rtcManager) {
+        rtcManager.disconnectAll();
     }
-    return false;
+    dispatch(rtcDisconnected());
 });
-createReactor([selectShouldConnectRoom], ({ dispatch }, shouldConnectRoom) => {
-    if (shouldConnectRoom) {
-        dispatch(doConnectRoom());
+const doHandleAcceptStreams = createAppThunk((payload) => (dispatch, getState) => {
+    var _a;
+    dispatch(isAcceptingStreams(true));
+    const state = getState();
+    const rtcManager = selectRtcConnectionRaw(state).rtcManager;
+    const remoteClients = selectRemoteClients(state);
+    if (!rtcManager) {
+        throw new Error("No rtc manager");
     }
-});
-startAppListening({
-    actionCreator: signalEvents.knockHandled,
-    effect: ({ payload }, { dispatch, getState }) => {
-        const { clientId, resolution } = payload;
-        const state = getState();
-        const selfId = selectSelfId(state);
-        if (clientId !== selfId) {
-            return;
+    const activeBreakout = false;
+    const shouldAcceptNewClients = (_a = rtcManager.shouldAcceptStreamsFromBothSides) === null || _a === void 0 ? void 0 : _a.call(rtcManager);
+    const updates = [];
+    for (const { clientId, streamId, state } of payload) {
+        const participant = remoteClients.find((p) => p.id === clientId);
+        if (!participant)
+            continue;
+        if (state === "to_accept" ||
+            (state === "new_accept" && shouldAcceptNewClients) ||
+            (state === "old_accept" && !shouldAcceptNewClients)) {
+            const enforceTurnProtocol = participant.isDialIn ? "onlytls" : undefined;
+            rtcManager.acceptNewStream({
+                streamId: streamId === "0" ? clientId : streamId,
+                clientId,
+                shouldAddLocalVideo: streamId === "0",
+                activeBreakout,
+                enforceTurnProtocol,
+            });
         }
-        if (resolution === "accepted") {
-            dispatch(setRoomKey(payload.metadata.roomKey));
-            dispatch(doConnectRoom());
+        else if (state === "new_accept" || state === "old_accept") ;
+        else if (state === "to_unaccept") {
+            rtcManager === null || rtcManager === void 0 ? void 0 : rtcManager.disconnect(streamId === "0" ? clientId : streamId, activeBreakout);
         }
-        else if (resolution === "rejected") {
-            dispatch(connectionStatusChanged("knock_rejected"));
+        else if (state !== "done_accept") {
+            continue;
         }
-    },
+        else ;
+        updates.push({ clientId, streamId, state: state.replace(/to_|new_|old_/, "done_") });
+    }
+    dispatch(streamStatusUpdated(updates));
+    dispatch(isAcceptingStreams(false));
+});
+const doRtcReportStreamResolution = createAppThunk(({ streamId, width, height }) => (dispatch, getState) => {
+    const { reportedStreamResolutions, rtcManager } = selectRtcConnectionRaw(getState());
+    const localStream = selectLocalMediaStream(getState());
+    if (!rtcManager || (localStream === null || localStream === void 0 ? void 0 : localStream.id) === streamId) {
+        return;
+    }
+    const old = reportedStreamResolutions[streamId];
+    if (!old || old.width !== width || old.height !== height) {
+        rtcManager.updateStreamResolution(streamId, null, { width: width || 1, height: height || 1 });
+    }
+    dispatch(resolutionReported({ streamId, width, height }));
+});
+const doRtcManagerCreated = createAppThunk((payload) => (dispatch) => {
+    const { rtcManager } = payload;
+    dispatch(rtcManagerCreated(rtcManager));
+});
+const doRtcManagerInitialize = createAppThunk(() => (dispatch, getState) => {
+    const localMediaStream = selectLocalMediaStream(getState());
+    const rtcManager = selectRtcConnectionRaw(getState()).rtcManager;
+    const isCameraEnabled = selectIsCameraEnabled(getState());
+    const isMicrophoneEnabled = selectIsMicrophoneEnabled(getState());
+    if (localMediaStream && rtcManager) {
+        rtcManager.addNewStream("0", localMediaStream, !isMicrophoneEnabled, !isCameraEnabled);
+    }
+    dispatch(rtcManagerInitialized());
 });
+const selectRtcConnectionRaw = (state) => state.rtcConnection;
+const selectRtcManagerInitialized = (state) => state.rtcConnection.rtcManagerInitialized;
+const selectRtcManager = (state) => state.rtcConnection.rtcManager;
+const selectRtcDispatcherCreated = (state) => state.rtcConnection.dispatcherCreated;
+const selectRtcIsCreatingDispatcher = (state) => state.rtcConnection.isCreatingDispatcher;
+const selectRtcStatus = (state) => state.rtcConnection.status;
+const selectIsAcceptingStreams = (state) => state.rtcConnection.isAcceptingStreams;
 startAppListening({
-    actionCreator: doAppStop,
-    effect: (_, { dispatch, getState }) => {
-        const state = getState();
-        const roomConnectionStatus = selectRoomConnectionStatus(state);
-        if (roomConnectionStatus === "connected") {
-            const socket = selectSignalConnectionRaw(state).socket;
-            socket === null || socket === void 0 ? void 0 : socket.emit("leave_room");
-            dispatch(connectionStatusChanged("leaving"));
-        }
-        else {
-            doSignalDisconnect();
-        }
+    actionCreator: doSetDevice.fulfilled,
+    effect: ({ payload }, { getState }) => {
+        const { replacedTracks } = payload;
+        const { rtcManager } = selectRtcConnectionRaw(getState());
+        const stream = selectLocalMediaStream(getState());
+        const replace = (kind, oldTrack) => {
+            const track = stream === null || stream === void 0 ? void 0 : stream.getTracks().find((t) => t.kind === kind);
+            return track && (rtcManager === null || rtcManager === void 0 ? void 0 : rtcManager.replaceTrack(oldTrack, track));
+        };
+        replacedTracks === null || replacedTracks === void 0 ? void 0 : replacedTracks.forEach((t) => {
+            replace(t.kind, t);
+        });
     },
 });
-
-const emitter = new events$1.EventEmitter();
-function createNotificationEvent(payload) {
-    const notificationEvent = Object.assign(Object.assign({}, payload), { timestamp: Date.now() });
-    return notificationEvent;
-}
-const initialNotificationsState = {
-    emitter,
-    events: [],
-};
-const notificationsSlice = toolkit.createSlice({
-    name: "notifications",
-    initialState: initialNotificationsState,
-    reducers: {
-        addNotification: (state, action) => {
-            return Object.assign(Object.assign({}, state), { events: [...state.events, Object.assign({}, action.payload)] });
-        },
-        doClearNotifications: (state) => {
-            return Object.assign(Object.assign({}, state), { events: [] });
-        },
+startAppListening({
+    actionCreator: doStartScreenshare.fulfilled,
+    effect: ({ payload }, { getState }) => {
+        const { stream } = payload;
+        const { rtcManager } = selectRtcConnectionRaw(getState());
+        rtcManager === null || rtcManager === void 0 ? void 0 : rtcManager.addNewStream(stream.id, stream, false, true);
     },
 });
-const { doClearNotifications } = notificationsSlice.actions;
-const doSetNotification = createAppThunk((payload) => (dispatch, getState) => {
-    dispatch(notificationsSlice.actions.addNotification(payload));
-    const state = getState();
-    const emitter = selectNotificationsEmitter(state);
-    emitter.emit(payload.type, payload);
-    emitter.emit("*", payload);
-});
-const selectNotificationsRaw = (state) => state.notifications;
-const selectNotificationsEvents = (state) => state.notifications.events;
-const selectNotificationsEmitter = (state) => state.notifications.emitter;
 startAppListening({
-    actionCreator: signalEvents.chatMessage,
-    effect: ({ payload }, { dispatch, getState }) => {
-        const state = getState();
-        const client = selectRemoteParticipants(state).find(({ id }) => id === payload.senderId);
-        if (!client) {
-            console.warn("Could not find remote client that sent chat message");
-            return;
-        }
-        dispatch(doSetNotification(createNotificationEvent({
-            type: "chatMessageReceived",
-            message: `${client.displayName} says: ${payload.text}`,
-            props: {
-                client,
-                chatMessage: {
-                    senderId: payload.senderId,
-                    timestamp: payload.timestamp,
-                    text: payload.text,
-                },
-            },
-        })));
+    actionCreator: doAppStop,
+    effect: (_, { getState }) => {
+        const rtcManager = selectRtcManager(getState());
+        rtcManager === null || rtcManager === void 0 ? void 0 : rtcManager.rtcStatsDisconnect();
     },
 });
 startAppListening({
-    actionCreator: signalEvents.audioEnableRequested,
-    effect: ({ payload }, { dispatch, getState }) => {
-        const { enable, requestedByClientId } = payload;
-        const state = getState();
-        const client = selectRemoteParticipants(state).find(({ id }) => id === requestedByClientId);
-        if (!client) {
-            console.warn("Could not find remote client that requested a local audio change");
-            return;
-        }
-        dispatch(doSetNotification(createNotificationEvent({
-            type: enable ? "requestAudioEnable" : "requestAudioDisable",
-            message: enable
-                ? `${client.displayName} has requested for you to speak`
-                : `${client.displayName} has muted your microphone`,
-            props: {
-                client,
-                enable,
-            },
-        })));
+    actionCreator: stopScreenshare,
+    effect: ({ payload }, { getState }) => {
+        const { stream } = payload;
+        const { rtcManager } = selectRtcConnectionRaw(getState());
+        rtcManager === null || rtcManager === void 0 ? void 0 : rtcManager.removeStream(stream.id, stream, null);
     },
 });
 startAppListening({
-    actionCreator: signalEvents.clientMetadataReceived,
-    effect: (action, { dispatch, getOriginalState, getState }) => {
+    actionCreator: doSwitchLocalStream.fulfilled,
+    effect: ({ payload }, { getState }) => {
         var _a;
-        const { error, payload } = action.payload;
-        if (error || !payload) {
-            return;
-        }
-        const { clientId, stickyReaction } = payload;
-        const state = getState();
-        const canAskToSpeak = selectIsAuthorizedToAskToSpeak(state);
-        if (!canAskToSpeak) {
-            return;
-        }
-        const client = selectRemoteParticipants(state).find(({ id }) => id === clientId);
-        if (!client) {
-            console.warn("Could not find remote client that provided updated metadata");
-            return;
-        }
-        const previousState = getOriginalState();
-        const previousClient = selectRemoteParticipants(previousState).find(({ id }) => id === clientId);
-        if ((!stickyReaction && !(previousClient === null || previousClient === void 0 ? void 0 : previousClient.stickyReaction)) ||
-            (stickyReaction === null || stickyReaction === void 0 ? void 0 : stickyReaction.timestamp) === ((_a = previousClient === null || previousClient === void 0 ? void 0 : previousClient.stickyReaction) === null || _a === void 0 ? void 0 : _a.timestamp)) {
-            return;
+        const stream = selectLocalMediaStream(getState());
+        const { rtcManager } = selectRtcConnectionRaw(getState());
+        if (stream && rtcManager) {
+            const replace = (kind, oldTrack) => {
+                const track = stream.getTracks().find((t) => t.kind === kind);
+                return track && rtcManager.replaceTrack(oldTrack, track);
+            };
+            (_a = payload === null || payload === void 0 ? void 0 : payload.replacedTracks) === null || _a === void 0 ? void 0 : _a.forEach((t) => {
+                replace(t.kind, t);
+            });
         }
-        dispatch(doSetNotification(createNotificationEvent({
-            type: stickyReaction ? "remoteHandRaised" : "remoteHandLowered",
-            message: `${client.displayName} ${stickyReaction ? "raised" : "lowered"} their hand`,
-            props: {
-                client,
-                stickyReaction,
-            },
-        })));
     },
 });
-createReactor([selectSignalStatus], ({ dispatch, getState }, signalStatus) => {
-    const state = getState();
-    const roomConnectionStatus = selectRoomConnectionStatus(state);
-    if (["left", "kicked"].includes(roomConnectionStatus)) {
-        return;
+const selectShouldConnectRtc = toolkit.createSelector(selectRtcStatus, selectAppIsActive, selectRtcDispatcherCreated, selectRtcIsCreatingDispatcher, selectSignalConnectionSocket, (rtcStatus, appIsActive, dispatcherCreated, isCreatingDispatcher, signalSocket) => {
+    if (appIsActive && rtcStatus === "inactive" && !dispatcherCreated && !isCreatingDispatcher && signalSocket) {
+        return true;
     }
-    if (signalStatus === "disconnected") {
-        dispatch(doSetNotification(createNotificationEvent({
-            type: "signalTrouble",
-            message: `Network connection lost. Trying to reconnect you...`,
-            props: {},
-        })));
+    return false;
+});
+createReactor([selectShouldConnectRtc], ({ dispatch }, shouldConnectRtc) => {
+    if (shouldConnectRtc) {
+        dispatch(doConnectRtc());
     }
-    else if (signalStatus === "connected") {
-        dispatch(doSetNotification(createNotificationEvent({
-            type: "signalOk",
-            message: `Network connection available`,
-            props: {},
-        })));
+});
+const selectShouldInitializeRtc = toolkit.createSelector(selectRtcManager, selectRtcManagerInitialized, selectLocalMediaStatus, (rtcManager, rtcManagerInitialized, localMediaStatus) => {
+    if (localMediaStatus === "started" && rtcManager && !rtcManagerInitialized) {
+        return true;
     }
+    return false;
 });
-startAppListening({
-    actionCreator: signalEvents.clientUnableToJoin,
-    effect: (action, { dispatch }) => {
-        var _a;
-        if (((_a = action.payload) === null || _a === void 0 ? void 0 : _a.error) === "room_full") {
-            dispatch(doSetNotification(createNotificationEvent({
-                type: "clientUnableToJoinFullRoom",
-                message: "Someone tried to join but the room is full and at capacity.",
-                props: {},
-            })));
+createReactor([selectShouldInitializeRtc], ({ dispatch }, shouldInitializeRtc) => {
+    if (shouldInitializeRtc) {
+        dispatch(doRtcManagerInitialize());
+    }
+});
+const selectShouldDisconnectRtc = toolkit.createSelector(selectRtcStatus, selectAppIsActive, (status, appIsActive) => {
+    if (!appIsActive && !["inactive", "disconnected"].includes(status)) {
+        return true;
+    }
+    return false;
+});
+createReactor([selectShouldDisconnectRtc], ({ dispatch }, shouldDisconnectRtc) => {
+    if (shouldDisconnectRtc) {
+        dispatch(doDisconnectRtc());
+    }
+});
+const selectStreamsToAccept = toolkit.createSelector(selectRtcStatus, selectRemoteClients, (rtcStatus, remoteParticipants) => {
+    if (rtcStatus !== "ready") {
+        return [];
+    }
+    const upd = [];
+    for (const client of remoteParticipants) {
+        const { streams, id: clientId, newJoiner } = client;
+        for (let i = 0; i < streams.length; i++) {
+            let streamId = streams[i].id;
+            let state = streams[i].state;
+            if ((streams === null || streams === void 0 ? void 0 : streams.length) > 1 && streams[1].id === "0") {
+                if (i === 0) {
+                    streamId = streams[1].id;
+                    state = streams[1].state;
+                }
+                else if (i === 1) {
+                    streamId = streams[0].id;
+                    state = streams[0].state;
+                }
+            }
+            {
+                if (state === "done_accept")
+                    continue;
+                upd.push({
+                    clientId,
+                    streamId,
+                    state: `${newJoiner && streamId === "0" ? "new" : "to"}_accept`,
+                });
+            }
         }
-    },
+    }
+    return upd;
+});
+createReactor([selectStreamsToAccept, selectIsAcceptingStreams], ({ dispatch }, streamsToAccept, isAcceptingStreams) => {
+    if (0 < streamsToAccept.length && !isAcceptingStreams) {
+        dispatch(doHandleAcceptStreams(streamsToAccept));
+    }
 });
 
 function isStreamerClient(client) {
@@ -1938,313 +2100,256 @@ const selectAllClientViews = toolkit.createSelector(selectLocalParticipantView,
     return [...(localParticipant ? [localParticipant] : []), ...remoteParticipants];
 });
 
-const createWebRtcEmitter = (dispatch) => {
-    return {
-        emit: (eventName, data) => {
-            if (eventName === "rtc_manager_created") {
-                dispatch(doRtcManagerCreated(data));
-            }
-            else if (eventName === "stream_added") {
-                dispatch(rtcEvents.streamAdded(data));
-            }
-            else if (eventName === "rtc_manager_destroyed") {
-                dispatch(rtcManagerDestroyed());
-            }
-            else ;
-        },
-    };
-};
 const initialState$4 = {
-    dispatcherCreated: false,
-    error: null,
-    isCreatingDispatcher: false,
-    reportedStreamResolutions: {},
-    rtcManager: null,
-    rtcManagerDispatcher: null,
-    rtcManagerInitialized: false,
-    status: "inactive",
-    isAcceptingStreams: false,
+    running: false,
 };
-const rtcConnectionSlice = toolkit.createSlice({
-    name: "rtcConnection",
+const connectionMonitorSlice = toolkit.createSlice({
+    name: "connectionMonitor",
     initialState: initialState$4,
     reducers: {
-        isAcceptingStreams: (state, action) => {
-            return Object.assign(Object.assign({}, state), { isAcceptingStreams: action.payload });
-        },
-        resolutionReported: (state, action) => {
-            const { streamId, width, height } = action.payload;
-            return Object.assign(Object.assign({}, state), { reportedStreamResolutions: Object.assign(Object.assign({}, state.reportedStreamResolutions), { [streamId]: { width, height } }) });
+        connectionMonitorStarted: (state, action) => {
+            return Object.assign(Object.assign({}, state), { running: true, stopCallbackFunction: action.payload.stopIssueSubscription });
         },
-        rtcDisconnected: () => {
+        connectionMonitorStopped: () => {
             return Object.assign({}, initialState$4);
         },
-        rtcDispatcherCreated: (state, action) => {
-            return Object.assign(Object.assign({}, state), { dispatcherCreated: true, rtcManagerDispatcher: action.payload });
-        },
-        rtcManagerCreated: (state, action) => {
-            return Object.assign(Object.assign({}, state), { rtcManager: action.payload, status: "ready" });
-        },
-        rtcManagerDestroyed: (state) => {
-            return Object.assign(Object.assign({}, state), { rtcManager: null });
-        },
-        rtcManagerInitialized: (state) => {
-            return Object.assign(Object.assign({}, state), { rtcManagerInitialized: true });
-        },
-    },
-    extraReducers: (builder) => {
-        builder.addCase(socketReconnecting, (state) => {
-            return Object.assign(Object.assign({}, state), { status: "reconnecting" });
-        });
-        builder.addCase(signalEvents.roomJoined, (state) => {
-            return Object.assign(Object.assign({}, state), { status: state.status === "reconnecting" ? "ready" : state.status });
-        });
     },
 });
-const { resolutionReported, rtcDispatcherCreated, rtcDisconnected, rtcManagerCreated, rtcManagerDestroyed, rtcManagerInitialized, isAcceptingStreams, } = rtcConnectionSlice.actions;
-const doConnectRtc = createAppThunk(() => (dispatch, getState) => {
-    const state = getState();
-    const socket = selectSignalConnectionRaw(state).socket;
-    const dispatcher = selectRtcConnectionRaw(state).rtcManagerDispatcher;
-    const isCameraEnabled = selectIsCameraEnabled(state);
-    const isMicrophoneEnabled = selectIsMicrophoneEnabled(state);
-    const isNodeSdk = selectAppIsNodeSdk(state);
-    if (dispatcher || !socket) {
-        return;
-    }
-    const webrtcProvider = {
-        getMediaConstraints: () => ({
-            audio: isMicrophoneEnabled,
-            video: isCameraEnabled,
-        }),
-        deferrable(clientId) {
-            return !clientId;
-        },
-    };
-    const rtcManagerDispatcher = new media.RtcManagerDispatcher({
-        emitter: createWebRtcEmitter(dispatch),
-        serverSocket: socket,
-        webrtcProvider,
-        features: {
-            isNodeSdk,
-            lowDataModeEnabled: false,
-            sfuServerOverrideHost: undefined,
-            turnServerOverrideHost: undefined,
-            useOnlyTURN: undefined,
-            vp9On: false,
-            h264On: false,
-            simulcastScreenshareOn: false,
-            deviceHandlerFactory: isNodeSdk ? Chrome111_js.Chrome111.createFactory() : undefined,
+const { connectionMonitorStarted, connectionMonitorStopped } = connectionMonitorSlice.actions;
+const doStartConnectionMonitor = createAppThunk(() => (dispatch, getState) => {
+    media.setClientProvider(() => {
+        const state = getState();
+        const clientViews = selectAllClientViews(state).map((clientView) => {
+            var _a, _b;
+            return ({
+                id: clientView.id,
+                clientId: clientView.clientId,
+                isLocalClient: clientView.isLocalClient,
+                audio: {
+                    enabled: clientView.isAudioEnabled,
+                    track: (_a = clientView.stream) === null || _a === void 0 ? void 0 : _a.getAudioTracks()[0],
+                },
+                video: {
+                    enabled: clientView.isVideoEnabled,
+                    track: (_b = clientView.stream) === null || _b === void 0 ? void 0 : _b.getVideoTracks()[0],
+                },
+                isPresentation: clientView.isPresentation,
+            });
+        });
+        return clientViews;
+    });
+    const issueMonitorSubscription = media.subscribeIssues({
+        onUpdatedIssues: (issuesAndMetricsByClients) => {
+            var _a;
+            const state = getState();
+            const rtcManager = selectRtcManager(state);
+            if (!rtcManager) {
+                return;
+            }
+            let lossSend = 0;
+            let lossReceive = 0;
+            let bitrateSend = 0;
+            let bitrateReceive = 0;
+            Object.entries(issuesAndMetricsByClients.aggregated.metrics).forEach(([key, value]) => {
+                if (/loc.*packetloss/.test(key))
+                    lossSend = Math.max(lossSend, value.curMax);
+                if (/rem.*packetloss/.test(key))
+                    lossReceive = Math.max(lossReceive, value.curMax);
+                if (/loc.*bitrate/.test(key))
+                    bitrateSend += value.curSum;
+                if (/rem.*bitrate/.test(key))
+                    bitrateReceive += value.curSum;
+            });
+            rtcManager.sendStatsCustomEvent("insightsStats", {
+                ls: Math.round(lossSend * 1000) / 1000,
+                lr: Math.round(lossReceive * 1000) / 1000,
+                bs: Math.round(bitrateSend),
+                br: Math.round(bitrateReceive),
+                cpu: (_a = issuesAndMetricsByClients.aggregated.metrics["global-cpu-pressure"]) === null || _a === void 0 ? void 0 : _a.curSum,
+                _time: Date.now(),
+            });
         },
     });
-    dispatch(rtcDispatcherCreated(rtcManagerDispatcher));
-});
-const doDisconnectRtc = createAppThunk(() => (dispatch, getState) => {
-    const { rtcManager } = selectRtcConnectionRaw(getState());
-    if (rtcManager) {
-        rtcManager.disconnectAll();
-    }
-    dispatch(rtcDisconnected());
+    dispatch(connectionMonitorStarted({ stopIssueSubscription: issueMonitorSubscription.stop }));
 });
-const doHandleAcceptStreams = createAppThunk((payload) => (dispatch, getState) => {
-    var _a;
-    dispatch(isAcceptingStreams(true));
+const doStopConnectionMonitor = createAppThunk(() => (dispatch, getState) => {
     const state = getState();
-    const rtcManager = selectRtcConnectionRaw(state).rtcManager;
-    const remoteClients = selectRemoteClients(state);
-    if (!rtcManager) {
-        throw new Error("No rtc manager");
-    }
-    const activeBreakout = false;
-    const shouldAcceptNewClients = (_a = rtcManager.shouldAcceptStreamsFromBothSides) === null || _a === void 0 ? void 0 : _a.call(rtcManager);
-    const updates = [];
-    for (const { clientId, streamId, state } of payload) {
-        const participant = remoteClients.find((p) => p.id === clientId);
-        if (!participant)
-            continue;
-        if (state === "to_accept" ||
-            (state === "new_accept" && shouldAcceptNewClients) ||
-            (state === "old_accept" && !shouldAcceptNewClients)) {
-            const enforceTurnProtocol = participant.isDialIn ? "onlytls" : undefined;
-            rtcManager.acceptNewStream({
-                streamId: streamId === "0" ? clientId : streamId,
-                clientId,
-                shouldAddLocalVideo: streamId === "0",
-                activeBreakout,
-                enforceTurnProtocol,
-            });
-        }
-        else if (state === "new_accept" || state === "old_accept") ;
-        else if (state === "to_unaccept") {
-            rtcManager === null || rtcManager === void 0 ? void 0 : rtcManager.disconnect(streamId === "0" ? clientId : streamId, activeBreakout);
-        }
-        else if (state !== "done_accept") {
-            continue;
-        }
-        else ;
-        updates.push({ clientId, streamId, state: state.replace(/to_|new_|old_/, "done_") });
+    const stopCallbackFn = selectStopCallbackFunction(state);
+    if (stopCallbackFn) {
+        stopCallbackFn();
     }
-    dispatch(streamStatusUpdated(updates));
-    dispatch(isAcceptingStreams(false));
+    dispatch(connectionMonitorStopped());
 });
-const doRtcReportStreamResolution = createAppThunk(({ streamId, width, height }) => (dispatch, getState) => {
-    const { reportedStreamResolutions, rtcManager } = selectRtcConnectionRaw(getState());
-    const localStream = selectLocalMediaStream(getState());
-    if (!rtcManager || (localStream === null || localStream === void 0 ? void 0 : localStream.id) === streamId) {
-        return;
-    }
-    const old = reportedStreamResolutions[streamId];
-    if (!old || old.width !== width || old.height !== height) {
-        rtcManager.updateStreamResolution(streamId, null, { width: width || 1, height: height || 1 });
+const selectConnectionMonitorIsRunning = (state) => state.connectionMonitor.running;
+const selectStopCallbackFunction = (state) => state.connectionMonitor.stopCallbackFunction;
+const selectShouldStartConnectionMonitor = toolkit.createSelector(selectRoomConnectionStatus, selectConnectionMonitorIsRunning, (roomConnectionStatus, isRunning) => {
+    if (!isRunning && roomConnectionStatus === "connected") {
+        return true;
     }
-    dispatch(resolutionReported({ streamId, width, height }));
+    return false;
 });
-const doRtcManagerCreated = createAppThunk((payload) => (dispatch) => {
-    const { rtcManager } = payload;
-    dispatch(rtcManagerCreated(rtcManager));
+const selectShouldStopConnectionMonitor = toolkit.createSelector(selectRoomConnectionStatus, selectConnectionMonitorIsRunning, (roomConnectionStatus, isRunning) => {
+    if (isRunning && ["kicked", "left"].includes(roomConnectionStatus)) {
+        return true;
+    }
+    return false;
 });
-const doRtcManagerInitialize = createAppThunk(() => (dispatch, getState) => {
-    const localMediaStream = selectLocalMediaStream(getState());
-    const rtcManager = selectRtcConnectionRaw(getState()).rtcManager;
-    const isCameraEnabled = selectIsCameraEnabled(getState());
-    const isMicrophoneEnabled = selectIsMicrophoneEnabled(getState());
-    if (localMediaStream && rtcManager) {
-        rtcManager.addNewStream("0", localMediaStream, !isMicrophoneEnabled, !isCameraEnabled);
+createReactor([selectShouldStartConnectionMonitor], ({ dispatch }, shouldStartConnectionMonitor) => {
+    if (shouldStartConnectionMonitor) {
+        dispatch(doStartConnectionMonitor());
     }
-    dispatch(rtcManagerInitialized());
 });
-const selectRtcConnectionRaw = (state) => state.rtcConnection;
-const selectRtcManagerInitialized = (state) => state.rtcConnection.rtcManagerInitialized;
-const selectRtcManager = (state) => state.rtcConnection.rtcManager;
-const selectRtcDispatcherCreated = (state) => state.rtcConnection.dispatcherCreated;
-const selectRtcIsCreatingDispatcher = (state) => state.rtcConnection.isCreatingDispatcher;
-const selectRtcStatus = (state) => state.rtcConnection.status;
-const selectIsAcceptingStreams = (state) => state.rtcConnection.isAcceptingStreams;
-startAppListening({
-    actionCreator: doSetDevice.fulfilled,
-    effect: ({ payload }, { getState }) => {
-        const { replacedTracks } = payload;
-        const { rtcManager } = selectRtcConnectionRaw(getState());
-        const stream = selectLocalMediaStream(getState());
-        const replace = (kind, oldTrack) => {
-            const track = stream === null || stream === void 0 ? void 0 : stream.getTracks().find((t) => t.kind === kind);
-            return track && (rtcManager === null || rtcManager === void 0 ? void 0 : rtcManager.replaceTrack(oldTrack, track));
-        };
-        replacedTracks === null || replacedTracks === void 0 ? void 0 : replacedTracks.forEach((t) => {
-            replace(t.kind, t);
-        });
-    },
+createReactor([selectShouldStopConnectionMonitor], ({ dispatch }, shouldStartConnectionMonitor) => {
+    if (shouldStartConnectionMonitor) {
+        dispatch(doStopConnectionMonitor());
+    }
 });
-startAppListening({
-    actionCreator: doStartScreenshare.fulfilled,
-    effect: ({ payload }, { getState }) => {
-        const { stream } = payload;
-        const { rtcManager } = selectRtcConnectionRaw(getState());
-        rtcManager === null || rtcManager === void 0 ? void 0 : rtcManager.addNewStream(stream.id, stream, false, true);
+
+const emitter = new events$1.EventEmitter();
+function createNotificationEvent(payload) {
+    const notificationEvent = Object.assign(Object.assign({}, payload), { timestamp: Date.now() });
+    return notificationEvent;
+}
+const initialNotificationsState = {
+    emitter,
+    events: [],
+};
+const notificationsSlice = toolkit.createSlice({
+    name: "notifications",
+    initialState: initialNotificationsState,
+    reducers: {
+        addNotification: (state, action) => {
+            return Object.assign(Object.assign({}, state), { events: [...state.events, Object.assign({}, action.payload)] });
+        },
+        doClearNotifications: (state) => {
+            return Object.assign(Object.assign({}, state), { events: [] });
+        },
     },
 });
+const { doClearNotifications } = notificationsSlice.actions;
+const doSetNotification = createAppThunk((payload) => (dispatch, getState) => {
+    dispatch(notificationsSlice.actions.addNotification(payload));
+    const state = getState();
+    const emitter = selectNotificationsEmitter(state);
+    emitter.emit(payload.type, payload);
+    emitter.emit("*", payload);
+});
+const selectNotificationsRaw = (state) => state.notifications;
+const selectNotificationsEvents = (state) => state.notifications.events;
+const selectNotificationsEmitter = (state) => state.notifications.emitter;
 startAppListening({
-    actionCreator: doAppStop,
-    effect: (_, { getState }) => {
-        const rtcManager = selectRtcManager(getState());
-        rtcManager === null || rtcManager === void 0 ? void 0 : rtcManager.rtcStatsDisconnect();
+    actionCreator: signalEvents.chatMessage,
+    effect: ({ payload }, { dispatch, getState }) => {
+        const state = getState();
+        const client = selectRemoteParticipants(state).find(({ id }) => id === payload.senderId);
+        if (!client) {
+            console.warn("Could not find remote client that sent chat message");
+            return;
+        }
+        dispatch(doSetNotification(createNotificationEvent({
+            type: "chatMessageReceived",
+            message: `${client.displayName} says: ${payload.text}`,
+            props: {
+                client,
+                chatMessage: {
+                    senderId: payload.senderId,
+                    timestamp: payload.timestamp,
+                    text: payload.text,
+                },
+            },
+        })));
     },
 });
 startAppListening({
-    actionCreator: stopScreenshare,
-    effect: ({ payload }, { getState }) => {
-        const { stream } = payload;
-        const { rtcManager } = selectRtcConnectionRaw(getState());
-        rtcManager === null || rtcManager === void 0 ? void 0 : rtcManager.removeStream(stream.id, stream, null);
+    actionCreator: signalEvents.audioEnableRequested,
+    effect: ({ payload }, { dispatch, getState }) => {
+        const { enable, requestedByClientId } = payload;
+        const state = getState();
+        const client = selectRemoteParticipants(state).find(({ id }) => id === requestedByClientId);
+        if (!client) {
+            console.warn("Could not find remote client that requested a local audio change");
+            return;
+        }
+        dispatch(doSetNotification(createNotificationEvent({
+            type: enable ? "requestAudioEnable" : "requestAudioDisable",
+            message: enable
+                ? `${client.displayName} has requested for you to speak`
+                : `${client.displayName} has muted your microphone`,
+            props: {
+                client,
+                enable,
+            },
+        })));
     },
 });
 startAppListening({
-    actionCreator: doSwitchLocalStream.fulfilled,
-    effect: ({ payload }, { getState }) => {
+    actionCreator: signalEvents.clientMetadataReceived,
+    effect: (action, { dispatch, getOriginalState, getState }) => {
         var _a;
-        const stream = selectLocalMediaStream(getState());
-        const { rtcManager } = selectRtcConnectionRaw(getState());
-        if (stream && rtcManager) {
-            const replace = (kind, oldTrack) => {
-                const track = stream.getTracks().find((t) => t.kind === kind);
-                return track && rtcManager.replaceTrack(oldTrack, track);
-            };
-            (_a = payload === null || payload === void 0 ? void 0 : payload.replacedTracks) === null || _a === void 0 ? void 0 : _a.forEach((t) => {
-                replace(t.kind, t);
-            });
+        const { error, payload } = action.payload;
+        if (error || !payload) {
+            return;
+        }
+        const { clientId, stickyReaction } = payload;
+        const state = getState();
+        const canAskToSpeak = selectIsAuthorizedToAskToSpeak(state);
+        if (!canAskToSpeak) {
+            return;
+        }
+        const client = selectRemoteParticipants(state).find(({ id }) => id === clientId);
+        if (!client) {
+            console.warn("Could not find remote client that provided updated metadata");
+            return;
+        }
+        const previousState = getOriginalState();
+        const previousClient = selectRemoteParticipants(previousState).find(({ id }) => id === clientId);
+        if ((!stickyReaction && !(previousClient === null || previousClient === void 0 ? void 0 : previousClient.stickyReaction)) ||
+            (stickyReaction === null || stickyReaction === void 0 ? void 0 : stickyReaction.timestamp) === ((_a = previousClient === null || previousClient === void 0 ? void 0 : previousClient.stickyReaction) === null || _a === void 0 ? void 0 : _a.timestamp)) {
+            return;
         }
+        dispatch(doSetNotification(createNotificationEvent({
+            type: stickyReaction ? "remoteHandRaised" : "remoteHandLowered",
+            message: `${client.displayName} ${stickyReaction ? "raised" : "lowered"} their hand`,
+            props: {
+                client,
+                stickyReaction,
+            },
+        })));
     },
 });
-const selectShouldConnectRtc = toolkit.createSelector(selectRtcDispatcherCreated, selectRtcIsCreatingDispatcher, selectSignalConnectionSocket, (dispatcherCreated, isCreatingDispatcher, signalSocket) => {
-    if (!dispatcherCreated && !isCreatingDispatcher && signalSocket) {
-        return true;
-    }
-    return false;
-});
-createReactor([selectShouldConnectRtc], ({ dispatch }, shouldConnectRtc) => {
-    if (shouldConnectRtc) {
-        dispatch(doConnectRtc());
-    }
-});
-const selectShouldInitializeRtc = toolkit.createSelector(selectRtcManager, selectRtcManagerInitialized, selectLocalMediaStatus, (rtcManager, rtcManagerInitialized, localMediaStatus) => {
-    if (localMediaStatus === "started" && rtcManager && !rtcManagerInitialized) {
-        return true;
-    }
-    return false;
-});
-createReactor([selectShouldInitializeRtc], ({ dispatch }, shouldInitializeRtc) => {
-    if (shouldInitializeRtc) {
-        dispatch(doRtcManagerInitialize());
+createReactor([selectSignalStatus], ({ dispatch, getState }, signalStatus) => {
+    const state = getState();
+    const roomConnectionStatus = selectRoomConnectionStatus(state);
+    if (["left", "kicked"].includes(roomConnectionStatus)) {
+        return;
     }
-});
-const selectShouldDisconnectRtc = toolkit.createSelector(selectRtcStatus, selectAppIsActive, (status, appIsActive) => {
-    if (!appIsActive && !["inactive", "disconnected"].includes(status)) {
-        return true;
+    if (signalStatus === "disconnected") {
+        dispatch(doSetNotification(createNotificationEvent({
+            type: "signalTrouble",
+            message: `Network connection lost. Trying to reconnect you...`,
+            props: {},
+        })));
     }
-    return false;
-});
-createReactor([selectShouldDisconnectRtc], ({ dispatch }, shouldDisconnectRtc) => {
-    if (shouldDisconnectRtc) {
-        dispatch(doDisconnectRtc());
+    else if (signalStatus === "connected") {
+        dispatch(doSetNotification(createNotificationEvent({
+            type: "signalOk",
+            message: `Network connection available`,
+            props: {},
+        })));
     }
 });
-const selectStreamsToAccept = toolkit.createSelector(selectRtcStatus, selectRemoteClients, (rtcStatus, remoteParticipants) => {
-    if (rtcStatus !== "ready") {
-        return [];
-    }
-    const upd = [];
-    for (const client of remoteParticipants) {
-        const { streams, id: clientId, newJoiner } = client;
-        for (let i = 0; i < streams.length; i++) {
-            let streamId = streams[i].id;
-            let state = streams[i].state;
-            if ((streams === null || streams === void 0 ? void 0 : streams.length) > 1 && streams[1].id === "0") {
-                if (i === 0) {
-                    streamId = streams[1].id;
-                    state = streams[1].state;
-                }
-                else if (i === 1) {
-                    streamId = streams[0].id;
-                    state = streams[0].state;
-                }
-            }
-            {
-                if (state === "done_accept")
-                    continue;
-                upd.push({
-                    clientId,
-                    streamId,
-                    state: `${newJoiner && streamId === "0" ? "new" : "to"}_accept`,
-                });
-            }
+startAppListening({
+    actionCreator: signalEvents.clientUnableToJoin,
+    effect: (action, { dispatch }) => {
+        var _a;
+        if (((_a = action.payload) === null || _a === void 0 ? void 0 : _a.error) === "room_full") {
+            dispatch(doSetNotification(createNotificationEvent({
+                type: "clientUnableToJoinFullRoom",
+                message: "Someone tried to join but the room is full and at capacity.",
+                props: {},
+            })));
         }
-    }
-    return upd;
-});
-createReactor([selectStreamsToAccept, selectIsAcceptingStreams], ({ dispatch }, streamsToAccept, isAcceptingStreams) => {
-    if (0 < streamsToAccept.length && !isAcceptingStreams) {
-        dispatch(doHandleAcceptStreams(streamsToAccept));
-    }
+    },
 });
 
 const rtcAnalyticsCustomEvents = {
@@ -2616,6 +2721,7 @@ const appReducer = toolkit.combineReducers({
     authorization: authorizationSlice.reducer,
     chat: chatSlice.reducer,
     cloudRecording: cloudRecordingSlice.reducer,
+    connectionMonitor: connectionMonitorSlice.reducer,
     deviceCredentials: deviceCredentialsSlice.reducer,
     localMedia: localMediaSlice.reducer,
     localParticipant: localParticipantSlice.reducer,
@@ -3693,6 +3799,9 @@ exports.appSlice = appSlice;
 exports.authorizationSlice = authorizationSlice;
 exports.chatSlice = chatSlice;
 exports.cloudRecordingSlice = cloudRecordingSlice;
+exports.connectionMonitorSlice = connectionMonitorSlice;
+exports.connectionMonitorStarted = connectionMonitorStarted;
+exports.connectionMonitorStopped = connectionMonitorStopped;
 exports.createAppAsyncThunk = createAppAsyncThunk;
 exports.createAppAuthorizedThunk = createAppAuthorizedThunk;
 exports.createAppThunk = createAppThunk;
@@ -3741,9 +3850,11 @@ exports.doSignalDisconnect = doSignalDisconnect;
 exports.doSignalIdentifyDevice = doSignalIdentifyDevice;
 exports.doSpotlightParticipant = doSpotlightParticipant;
 exports.doStartCloudRecording = doStartCloudRecording;
+exports.doStartConnectionMonitor = doStartConnectionMonitor;
 exports.doStartLocalMedia = doStartLocalMedia;
 exports.doStartScreenshare = doStartScreenshare;
 exports.doStopCloudRecording = doStopCloudRecording;
+exports.doStopConnectionMonitor = doStopConnectionMonitor;
 exports.doStopLocalMedia = doStopLocalMedia;
 exports.doStopScreenshare = doStopScreenshare;
 exports.doSwitchLocalStream = doSwitchLocalStream;
@@ -3757,7 +3868,7 @@ exports.hasValue = hasValue;
 exports.initialCloudRecordingState = initialCloudRecordingState;
 exports.initialLocalMediaState = initialLocalMediaState;
 exports.initialNotificationsState = initialNotificationsState;
-exports.initialState = initialState$f;
+exports.initialState = initialState$g;
 exports.isAcceptingStreams = isAcceptingStreams;
 exports.isClientSpotlighted = isClientSpotlighted;
 exports.listenerMiddleware = listenerMiddleware;
@@ -3809,6 +3920,7 @@ exports.selectCloudRecordingError = selectCloudRecordingError;
 exports.selectCloudRecordingRaw = selectCloudRecordingRaw;
 exports.selectCloudRecordingStartedAt = selectCloudRecordingStartedAt;
 exports.selectCloudRecordingStatus = selectCloudRecordingStatus;
+exports.selectConnectionMonitorIsRunning = selectConnectionMonitorIsRunning;
 exports.selectCurrentCameraDeviceId = selectCurrentCameraDeviceId;
 exports.selectCurrentMicrophoneDeviceId = selectCurrentMicrophoneDeviceId;
 exports.selectCurrentSpeakerDeviceId = selectCurrentSpeakerDeviceId;
@@ -3887,6 +3999,8 @@ exports.selectShouldFetchDeviceCredentials = selectShouldFetchDeviceCredentials;
 exports.selectShouldFetchOrganization = selectShouldFetchOrganization;
 exports.selectShouldIdentifyDevice = selectShouldIdentifyDevice;
 exports.selectShouldInitializeRtc = selectShouldInitializeRtc;
+exports.selectShouldStartConnectionMonitor = selectShouldStartConnectionMonitor;
+exports.selectShouldStopConnectionMonitor = selectShouldStopConnectionMonitor;
 exports.selectSignalConnectionDeviceIdentified = selectSignalConnectionDeviceIdentified;
 exports.selectSignalConnectionRaw = selectSignalConnectionRaw;
 exports.selectSignalConnectionSocket = selectSignalConnectionSocket;
@@ -3896,6 +4010,7 @@ exports.selectSpeakerDevices = selectSpeakerDevices;
 exports.selectSpotlightedClientViews = selectSpotlightedClientViews;
 exports.selectSpotlights = selectSpotlights;
 exports.selectSpotlightsRaw = selectSpotlightsRaw;
+exports.selectStopCallbackFunction = selectStopCallbackFunction;
 exports.selectStreamingRaw = selectStreamingRaw;
 exports.selectStreamsToAccept = selectStreamsToAccept;
 exports.selectWaitingParticipants = selectWaitingParticipants;