diff --git a/Makefile b/Makefile
index 4a64fcd25..f51e42446 100644
--- a/Makefile
+++ b/Makefile
@@ -275,7 +275,6 @@ endif
 
 cargo.lint:
 	cargo clippy --all -- -D clippy::pedantic -D warnings \
-		-A clippy::enum_glob_use \
 		-A clippy::wildcard_imports
 
 
diff --git a/crates/medea-coturn-telnet-client/src/client.rs b/crates/medea-coturn-telnet-client/src/client.rs
index 9c0ee37d9..6cd6e0081 100644
--- a/crates/medea-coturn-telnet-client/src/client.rs
+++ b/crates/medea-coturn-telnet-client/src/client.rs
@@ -55,7 +55,8 @@ pub enum CoturnTelnetError {
 
 impl From<CoturnCliCodecError> for CoturnTelnetError {
     fn from(err: CoturnCliCodecError) -> Self {
-        use CoturnCliCodecError::*;
+        use CoturnCliCodecError::{BadResponse, IoFailed};
+
         match err {
             IoFailed(e) => Self::from(e),
             BadResponse(e) => Self::from(e),
@@ -108,7 +109,7 @@ impl CoturnTelnetConnection {
         &mut self,
         username: String,
     ) -> Result<Vec<String>, CoturnTelnetError> {
-        use CoturnTelnetError::*;
+        use CoturnTelnetError::{Disconnected, UnexpectedMessage};
 
         self.0
             .send(CoturnCliRequest::PrintSessions(username))
@@ -141,7 +142,7 @@ impl CoturnTelnetConnection {
         &mut self,
         session_id: String,
     ) -> Result<(), CoturnTelnetError> {
-        use CoturnTelnetError::*;
+        use CoturnTelnetError::{Disconnected, UnexpectedMessage};
 
         self.0
             .send(CoturnCliRequest::CloseSession(session_id))
@@ -193,7 +194,9 @@ impl CoturnTelnetConnection {
     /// - First message received is not [`CoturnCliResponse::EnterPassword`].
     /// - Second message received is not [`CoturnCliResponse::Ready`].
     async fn auth(&mut self, pass: Bytes) -> Result<(), CoturnTelnetError> {
-        use CoturnTelnetError::*;
+        use CoturnTelnetError::{
+            Disconnected, UnexpectedMessage, WrongPassword,
+        };
 
         let response = self.0.next().await.ok_or(Disconnected)??;
         if let CoturnCliResponse::EnterPassword = response {
@@ -222,7 +225,7 @@ impl CoturnTelnetConnection {
     /// [Coturn]: https://github.com/coturn/coturn
     /// [Telnet]: https://en.wikipedia.org/wiki/Telnet
     pub async fn ping(&mut self) -> Result<(), CoturnTelnetError> {
-        use CoturnTelnetError::*;
+        use CoturnTelnetError::{Disconnected, UnexpectedMessage};
 
         self.0.send(CoturnCliRequest::Ping).await?;
 
diff --git a/crates/medea-coturn-telnet-client/src/proto.rs b/crates/medea-coturn-telnet-client/src/proto.rs
index 8ed926e4e..da36811e0 100644
--- a/crates/medea-coturn-telnet-client/src/proto.rs
+++ b/crates/medea-coturn-telnet-client/src/proto.rs
@@ -102,7 +102,7 @@ impl TryFrom<BytesMut> for CoturnCliResponse {
     type Error = CoturnResponseParseError;
 
     fn try_from(mut msg: BytesMut) -> Result<Self, Self::Error> {
-        use CoturnResponseParseError::*;
+        use CoturnResponseParseError::{BadResponseFormat, BadResponseType};
 
         // delete cursor if message ends with it
         if msg.ends_with(CURSOR.as_bytes()) {
@@ -165,7 +165,8 @@ pub enum CoturnCliRequest {
 
 impl From<CoturnCliRequest> for Bytes {
     fn from(req: CoturnCliRequest) -> Self {
-        use CoturnCliRequest::*;
+        use CoturnCliRequest::{Auth, CloseSession, Ping, PrintSessions};
+
         match req {
             Auth(pass) => pass,
             PrintSessions(username) => format!("ps {}", username).into(),
diff --git a/jason/CHANGELOG.md b/jason/CHANGELOG.md
index c4ef2c1d6..91a7e0fa3 100644
--- a/jason/CHANGELOG.md
+++ b/jason/CHANGELOG.md
@@ -14,6 +14,7 @@ All user visible changes to this project will be documented in this file. This p
 ### BC Breaks
 
 - Library API:
+    - Replace `MediaStreamHandle` with `LocalMediaStream` and `RemoteMediaStream` ([#97]);
     - Expose `on_local_stream` callback in `Room` instead of `Jason` ([#54]);
     - Remove error argument from `on_local_stream` callback ([#54]);
     - Room initialization ([#46]):
@@ -25,7 +26,7 @@ All user visible changes to this project will be documented in this file. This p
 
 - Media management:
     - Library API:
-        - Mute/unmute local video/audio ([#40], [#81]):
+        - Mute/unmute local video/audio ([#40], [#81], [#97]):
             - `Room.mute_audio()`;
             - `Room.unmute_audio()`;
             - `Room.mute_video()`;
@@ -35,15 +36,15 @@ All user visible changes to this project will be documented in this file. This p
             - `MediaManager.enumerate_devices()`;
             - `MediaManager.init_local_stream()`.
         - Local media stream constraints:
-            - `MediaStreamConstraints`, `AudioTrackConstraints` classes ([#46]);
+            - `MediaStreamSettings`, `AudioTrackConstraints` classes ([#46], [#97]);
             - `DeviceVideoTrackConstraints`, `DisplayVideoTrackConstraints` classes ([#78]).
         - Room initialization ([#46]):
             - `Jason.init_room()`;
             - `Room.join()`;
-        - Ability to inject local video/audio stream into `Room` via `Room.inject_local_stream()` ([#54]);
+        - Ability to configure local media stream used by `Room` via `Room.set_local_media_settings()` ([#54], [#97]);
         - `Room.on_failed_local_stream` callback ([#54]);
         - `Room.on_close` callback for WebSocket close initiated by server ([#55]);
-        - `RtcIceTransportPolicy` configuration ([#79]).
+    - `RtcIceTransportPolicy` configuration ([#79]).
 - Room management:
     - Library API:
         - `Room.on_connection_loss` callback that JS side can start Jason reconnection on connection loss with ([#75]);
@@ -77,6 +78,7 @@ All user visible changes to this project will be documented in this file. This p
 [#81]: /../../pull/81
 [#87]: /../../pull/87
 [#90]: /../../pull/90
+[#97]: /../../pull/97
 
 
 
diff --git a/jason/demo/index.html b/jason/demo/index.html
index bf5d9a4bd..51c1ac204 100644
--- a/jason/demo/index.html
+++ b/jason/demo/index.html
@@ -10,7 +10,10 @@
   <script type="module">
     import init, {
       Jason,
-      MediaStreamConstraints, AudioTrackConstraints, DeviceVideoTrackConstraints, DisplayVideoTrackConstraints
+      MediaStreamSettings,
+      AudioTrackConstraints,
+      DeviceVideoTrackConstraints,
+      DisplayVideoTrackConstraints,
     } from './js/medea_jason.js';
 
     let inited = false;
@@ -99,7 +102,7 @@
       inited = true;
       const jason = new Jason();
 
-      async function getDevices(audio_select, video_select, current_stream) {
+      async function fillMediaDevicesInputs(audio_select, video_select, current_stream) {
         const current_audio = current_stream.getAudioTracks().pop().label
           || "disable";
         const current_video = current_stream.getVideoTracks().pop().label
@@ -129,10 +132,8 @@
         video_select.append(option);
       }
 
-      async function getStream(audio_select, video_select) {
-
-        let constraints = new MediaStreamConstraints();
-
+      async function build_constraints(audio_select, video_select) {
+        let constraints = new MediaStreamSettings();
         let audio = new AudioTrackConstraints();
         let audioSource = audio_select.options[audio_select.selectedIndex];
         if (audioSource) {
@@ -154,9 +155,13 @@
           constraints.device_video(new DeviceVideoTrackConstraints());
         }
 
-        return await jason.media_manager().init_local_stream(constraints);
+        return constraints;
       }
 
+      let isCallStarted = false;
+      let localStream = null;
+      let isAudioMuted = false;
+      let isVideoMuted = false;
       let chooseRoomDiv = document.getElementById('choose-room');
       let videoCallDiv = document.getElementById('video-call');
       let chooseRoomButton = document.getElementById('choose-room__join');
@@ -177,28 +182,40 @@
 
       let room = await jason.init_room();
 
-      const updateLocalVideo = async function (stream) {
-        localVideo.srcObject = stream;
+      const updateLocalVideo = async (stream) => {
+        localVideo.srcObject = stream.get_media_stream();
         await localVideo.play();
       };
 
       audioSelect.addEventListener('change', async () => {
         try {
-          const stream = await getStream(audioSelect, videoSelect);
-          await updateLocalVideo(stream);
-          room.inject_local_stream(stream);
+          const constraints = await build_constraints(audioSelect, videoSelect);
+          if (localStream && localStream.ptr > 0 ){
+            localStream.free();
+          }
+          if (!isAudioMuted) {
+            localStream = await jason.media_manager().init_local_stream(constraints)
+            await updateLocalVideo(localStream);
+          }
+          await room.set_local_media_settings(constraints);
         } catch (e) {
-          logError("Changing audio source failed", e);
+          console.error("Changing audio source failed: " + e);
         }
       });
 
       videoSelect.addEventListener('change', async () => {
         try {
-          const stream = await getStream(audioSelect, videoSelect);
-          await updateLocalVideo(stream);
-          room.inject_local_stream(stream);
+          const constraints = await build_constraints(audioSelect, videoSelect);
+          if (localStream && localStream.ptr > 0 ){
+            localStream.free();
+          }
+          if (!isVideoMuted) {
+            localStream = await jason.media_manager().init_local_stream(constraints)
+            await updateLocalVideo(localStream);
+          }
+          await room.set_local_media_settings(constraints);
         } catch (e) {
-          logError("Changing video source failed", e);
+          console.error("Changing video source failed: " + e);
         }
       });
 
@@ -207,6 +224,7 @@
       });
 
       room.on_new_connection((connection) => {
+        isCallStarted = true;
         connection.on_remote_stream(async (stream) => {
           let videoDiv = document.getElementById("remote-videos");
           let video = document.createElement("video");
@@ -223,6 +241,11 @@
         });
       });
 
+      room.on_local_stream((stream) => {
+        updateLocalVideo(stream);
+        stream.free();
+      });
+
       let connectionState = document.getElementById('connection-state__state');
       room.on_connection_loss(async (reconnectHandle) => {
         connectionState.className = 'badge badge-warning';
@@ -250,29 +273,50 @@
 
       let muteAudio = document.getElementById('control__mute_audio');
       let muteVideo = document.getElementById('control__mute_video');
-      let isAudioMuted = false;
-      let isVideoMuted = false;
 
       muteAudio.addEventListener('click', async () => {
-        if(isAudioMuted) {
-          await room.unmute_audio();
-          isAudioMuted = false;
-          muteAudio.textContent = "Mute audio";
-        } else {
-          await room.mute_audio();
-          isAudioMuted = true;
-          muteAudio.textContent = "Unmute audio";
+        try {
+          if (isAudioMuted) {
+            if (isCallStarted) {
+              await room.unmute_audio();
+            }
+            isAudioMuted = false;
+            muteAudio.textContent = "Mute audio";
+          } else {
+            if (isCallStarted) {
+              await room.mute_audio();
+              if (localStream && localStream.ptr > 0 ){
+                localStream.free_audio();
+              }
+            }
+            isAudioMuted = true;
+            muteAudio.textContent = "Unmute audio";
+          }
+        } catch (e) {
+          console.error(e.message());
         }
       });
       muteVideo.addEventListener('click', async () => {
-        if(isVideoMuted) {
-          await room.unmute_video();
-          isVideoMuted = false;
-          muteVideo.textContent = "Mute video";
-        } else {
-          await room.mute_video();
-          isVideoMuted = true;
-          muteVideo.textContent = "Unmute video";
+        try {
+          if (isVideoMuted) {
+            if (!isCallStarted) {
+              const constraints = await build_constraints(audioSelect, videoSelect);
+              localStream = await jason.media_manager().init_local_stream(constraints)
+              await updateLocalVideo(localStream);
+            }
+            await room.unmute_video();
+            isVideoMuted = false;
+            muteVideo.textContent = "Mute video";
+          } else {
+            await room.mute_video();
+            if (localStream && localStream.ptr > 0 ){
+              localStream.free_video();
+            }
+            isVideoMuted = true;
+            muteVideo.textContent = "Unmute video";
+          }
+        } catch (e) {
+          console.error(e.message());
         }
       });
 
@@ -320,12 +364,13 @@
         videoCallDiv.style.display = "";
 
         try {
-          const stream = await getStream(audioSelect, videoSelect);
-          await updateLocalVideo(stream);
-          await getDevices(audioSelect, videoSelect, stream);
-          room.inject_local_stream(stream);
+          const constraints = await build_constraints(audioSelect, videoSelect);
+          localStream = await jason.media_manager().init_local_stream(constraints)
+          await updateLocalVideo(localStream);
+          await fillMediaDevicesInputs(audioSelect, videoSelect, localStream.get_media_stream());
+          await room.set_local_media_settings(constraints);
         } catch (e) {
-          logError("Init local video failed", e);
+          console.error("Init local video failed: " + e.message());
         }
 
       } else {
@@ -336,12 +381,13 @@
           bindJoinButtons(roomId);
 
           try {
-            const stream = await getStream(audioSelect, videoSelect);
-            await updateLocalVideo(stream);
-            await getDevices(audioSelect, videoSelect, stream);
-            room.inject_local_stream(stream);
+            const constraints = await build_constraints(audioSelect, videoSelect);
+            localStream = await jason.media_manager().init_local_stream(constraints)
+            await updateLocalVideo(localStream);
+            await fillMediaDevicesInputs(audioSelect, videoSelect, localStream.get_media_stream());
+            await room.set_local_media_settings(constraints);
           } catch (e) {
-            logError("Init local video failed", e);
+            console.error("Init local video failed: " + e.message());
           }
 
           chooseRoomDiv.style.display = "none";
diff --git a/jason/e2e-demo/js/index.js b/jason/e2e-demo/js/index.js
index bf4ba3cc9..bd540cc36 100644
--- a/jason/e2e-demo/js/index.js
+++ b/jason/e2e-demo/js/index.js
@@ -311,8 +311,8 @@ window.onload = async function() {
     video_select.append(option);
   }
 
-  async function getStream(audio_select, video_select) {
-    let constraints = new rust.MediaStreamConstraints();
+  async function build_constraints(audio_select, video_select) {
+    let constraints = new rust.MediaStreamSettings();
     let audio = new rust.AudioTrackConstraints();
     let audioSource = audio_select.options[audio_select.selectedIndex];
     if (audioSource) {
@@ -334,10 +334,14 @@ window.onload = async function() {
       constraints.device_video(new rust.DeviceVideoTrackConstraints());
     }
 
-    return await jason.media_manager().init_local_stream(constraints);
+    return constraints;
   }
 
   let room = newRoom();
+  let isCallStarted = false;
+  let localStream = null;
+  let isAudioMuted = false;
+  let isVideoMuted = false;
   let connectBtnsDiv = document.getElementsByClassName('connect')[0];
   let controlBtns = document.getElementsByClassName('control')[0];
   let audioSelect = document.getElementsByClassName('connect__select-device_audio')[0];
@@ -345,7 +349,7 @@ window.onload = async function() {
   let localVideo = document.querySelector('.local-video > video');
 
   const updateLocalVideo = async (stream) => {
-    localVideo.srcObject = stream;
+    localVideo.srcObject = stream.get_media_stream();
     await localVideo.play();
   };
 
@@ -354,15 +358,17 @@ window.onload = async function() {
     room = await jason.init_room();
 
     try {
-      const stream = await getStream(audioSelect, videoSelect);
-      await updateLocalVideo(stream);
-      await fillMediaDevicesInputs(audioSelect, videoSelect, stream);
-      room.inject_local_stream(stream);
+      const constraints = await build_constraints(audioSelect, videoSelect);
+      localStream = await jason.media_manager().init_local_stream(constraints)
+      await updateLocalVideo(localStream);
+      await fillMediaDevicesInputs(audioSelect, videoSelect, localStream.get_media_stream());
+      await room.set_local_media_settings(constraints);
     } catch (e) {
       console.error("Init local video failed: " + e.message());
     }
 
     room.on_new_connection( (connection) => {
+      isCallStarted = true;
       connection.on_remote_stream( async (stream) => {
         let videoDiv = document.getElementsByClassName("remote-videos")[0];
         let video = document.createElement("video");
@@ -376,8 +382,13 @@ window.onload = async function() {
       });
     });
 
+    room.on_local_stream((stream) => {
+      updateLocalVideo(stream);
+      stream.free();
+    });
+
     room.on_failed_local_stream((error) => {
-      console.error(error);
+      console.error(error.message());
     });
 
     room.on_connection_loss( async (reconnectHandle) => {
@@ -431,9 +442,15 @@ window.onload = async function() {
 
     audioSelect.addEventListener('change', async () => {
       try {
-        const stream = await getStream(audioSelect, videoSelect);
-        await updateLocalVideo(stream);
-        room.inject_local_stream(stream);
+        const constraints = await build_constraints(audioSelect, videoSelect);
+        if (localStream && localStream.ptr > 0 ){
+          localStream.free();
+        }
+        if (!isAudioMuted) {
+          localStream = await jason.media_manager().init_local_stream(constraints)
+          await updateLocalVideo(localStream);
+        }
+        await room.set_local_media_settings(constraints);
       } catch (e) {
         console.error("Changing audio source failed: " + e);
       }
@@ -441,9 +458,15 @@ window.onload = async function() {
 
     videoSelect.addEventListener('change', async () => {
       try {
-        const stream = await getStream(audioSelect, videoSelect);
-        await updateLocalVideo(stream);
-        room.inject_local_stream(stream);
+        const constraints = await build_constraints(audioSelect, videoSelect);
+        if (localStream && localStream.ptr > 0 ){
+          localStream.free();
+        }
+        if (!isVideoMuted) {
+          localStream = await jason.media_manager().init_local_stream(constraints)
+          await updateLocalVideo(localStream);
+        }
+        await room.set_local_media_settings(constraints);
       } catch (e) {
         console.error("Changing video source failed: " + e);
       }
@@ -452,17 +475,22 @@ window.onload = async function() {
     let muteAudio = document.getElementsByClassName('control__mute_audio')[0];
     let muteVideo = document.getElementsByClassName('control__mute_video')[0];
     let closeApp = document.getElementsByClassName('control__close_app')[0];
-    let isAudioMuted = false;
-    let isVideoMuted = false;
 
     muteAudio.addEventListener('click', async () => {
       try {
         if (isAudioMuted) {
-          await room.unmute_audio();
+          if (isCallStarted) {
+            await room.unmute_audio();
+          }
           isAudioMuted = false;
           muteAudio.textContent = "Mute audio";
         } else {
-          await room.mute_audio();
+          if (isCallStarted) {
+            await room.mute_audio();
+            if (localStream && localStream.ptr > 0 ){
+              localStream.free_audio();
+            }
+          }
           isAudioMuted = true;
           muteAudio.textContent = "Unmute audio";
         }
@@ -473,11 +501,19 @@ window.onload = async function() {
     muteVideo.addEventListener('click', async () => {
       try {
         if (isVideoMuted) {
+          if (!isCallStarted) {
+            const constraints = await build_constraints(audioSelect, videoSelect);
+            localStream = await jason.media_manager().init_local_stream(constraints)
+            await updateLocalVideo(localStream);
+          }
           await room.unmute_video();
           isVideoMuted = false;
           muteVideo.textContent = "Mute video";
         } else {
           await room.mute_video();
+          if (localStream && localStream.ptr > 0 ){
+            localStream.free_video();
+          }
           isVideoMuted = true;
           muteVideo.textContent = "Unmute video";
         }
diff --git a/jason/e2e-demo/video-call.html b/jason/e2e-demo/video-call.html
index 27cf0bd1d..db2eaa2f1 100644
--- a/jason/e2e-demo/video-call.html
+++ b/jason/e2e-demo/video-call.html
@@ -31,21 +31,11 @@
     }
 
     .connect {
-      position: fixed;
-      bottom: 200px;
-      left: 50%;
-      transform: translateX(-50%);
-      background: #FFFFFF;
-      padding: 10px;
-      border-radius: 3px;
+      float: left;
     }
 
     .local-video {
-      position: fixed;
-      bottom: 0;
-      left: 0;
-      margin-left: 20px;
-      margin-bottom: 20px;
+      float: left;
       width: auto;
       height: 150px;
       max-width: 225px;
@@ -62,15 +52,7 @@
     }
 
     .connect__device {
-      margin-top: 5px;
-    }
-
-    .connect__device>label {
-      font-size: 10pt;
-    }
-
-    .connect__device>label>select {
-      margin-top: 5px;
+      float: left;
     }
 
     .btn {
@@ -87,10 +69,7 @@
     }
 
     .control {
-      position: fixed;
-      bottom: 150px;
-      left: 50%;
-      transform: translateX(-50%);
+      float: left;
     }
 
     .control__btn {
@@ -227,20 +206,28 @@
       cursor: pointer;
       margin-top: 5px;
     }
+
+    .footer {
+      position: fixed;
+      left: 0;
+      bottom: 0;
+      width: 100%;
+    }
   </style>
 </head>
 <body>
   <div class="remote-videos">
   </div>
 
-  <div class="local-video video">
-    <video muted autoplay width="100%" height="100%"></video>
-  </div>
-
-  <div class="connect toggle-content is-visible">
-    <div>
-      <input class="connect__username" placeholder="username">
-      <button class="connect__join btn">Join</button>
+  <div class="footer">
+    <div class="local-video video">
+      <video muted autoplay width="100%" height="100%"></video>
+    </div>
+    <div class="connect toggle-content is-visible">
+      <div>
+        <input class="connect__username" placeholder="username">
+        <button class="connect__join btn">Join</button>
+      </div>
     </div>
     <div class="connect__device">
       <label>Audio:
@@ -252,12 +239,11 @@
         </select>
       </label>
     </div>
-  </div>
-
-  <div class="control toggle-content">
-    <button class="control__mute_audio control__btn btn">Mute audio</button>
-    <button class="control__mute_video control__btn btn">Mute video</button>
-    <button class="control__close_app control__btn btn">Dispose</button>
+    <div class="control toggle-content">
+      <button class="control__mute_audio control__btn btn">Mute audio</button>
+      <button class="control__mute_video control__btn btn">Mute video</button>
+      <button class="control__close_app control__btn btn">Dispose</button>
+    </div>
   </div>
 
   <div class="window control-debug__window_create-endpoint toggle-content">
diff --git a/jason/src/api/connection.rs b/jason/src/api/connection.rs
index 34cb78a22..d8dfbd64a 100644
--- a/jason/src/api/connection.rs
+++ b/jason/src/api/connection.rs
@@ -8,7 +8,7 @@ use std::{
 use wasm_bindgen::prelude::*;
 
 use crate::{
-    peer::MediaStreamHandle,
+    peer::RemoteMediaStream,
     utils::{Callback, HandlerDetachedError},
 };
 
@@ -17,7 +17,7 @@ use crate::{
 /// Shared between JS side ([`ConnectionHandle`]) and
 /// Rust side ([`Connection`]).
 struct InnerConnection {
-    on_remote_stream: Callback<MediaStreamHandle>,
+    on_remote_stream: Callback<RemoteMediaStream>,
 }
 
 /// Connection with a specific remote `Member`, that is used on JS side.
@@ -62,7 +62,7 @@ impl Connection {
     /// Invoke `on_remote_stream` [`Connection`]'s callback
     /// for a given [`MediaStream`] received from a related remote [`Member`].
     #[inline]
-    pub(crate) fn on_remote_stream(&self, stream: MediaStreamHandle) {
+    pub(crate) fn on_remote_stream(&self, stream: RemoteMediaStream) {
         self.0.borrow().on_remote_stream.call(stream);
     }
 }
diff --git a/jason/src/api/room.rs b/jason/src/api/room.rs
index e8e9e755b..a3c54d45f 100644
--- a/jason/src/api/room.rs
+++ b/jason/src/api/room.rs
@@ -20,12 +20,12 @@ use medea_client_api_proto::{
 use tracerr::Traced;
 use wasm_bindgen::{prelude::*, JsValue};
 use wasm_bindgen_futures::{future_to_promise, spawn_local};
-use web_sys::MediaStream as SysMediaStream;
 
 use crate::{
+    media::{MediaStream, MediaStreamSettings},
     peer::{
-        MediaConnectionsError, MediaStream, MediaStreamHandle, MuteState,
-        PeerError, PeerEvent, PeerEventHandler, PeerRepository, RtcStats,
+        MediaConnectionsError, MuteState, PeerError, PeerEvent,
+        PeerEventHandler, PeerMediaStream, PeerRepository, RtcStats,
         StableMuteState, TransceiverKind,
     },
     rpc::{
@@ -140,7 +140,7 @@ enum RoomError {
     #[display(fmt = "Remote stream from unknown peer")]
     UnknownRemotePeer,
 
-    /// Returned if [`MediaTrack`] update failed.
+    /// Returned if [`MediaStreamTrack`] update failed.
     #[display(fmt = "Failed to update Track with {} ID.", _0)]
     FailedTrackPatch(TrackId),
 
@@ -164,7 +164,10 @@ impl From<TransportError> for RoomError {
 
 impl From<PeerError> for RoomError {
     fn from(err: PeerError) -> Self {
-        use PeerError::*;
+        use PeerError::{
+            MediaConnections, MediaManager, RtcPeerConnection, StreamRequest,
+        };
+
         match err {
             MediaConnections(ref e) => match e {
                 MediaConnectionsError::InvalidTrackPatch(id) => {
@@ -191,6 +194,7 @@ impl From<MediaConnectionsError> for RoomError {
 /// Actually, represents a [`Weak`]-based handle to `InnerRoom`.
 ///
 /// For using [`RoomHandle`] on Rust side, consider the `Room`.
+// TODO: get rid of this RefCell.
 #[wasm_bindgen]
 pub struct RoomHandle(Weak<RefCell<InnerRoom>>);
 
@@ -199,10 +203,11 @@ impl RoomHandle {
     ///
     /// # Errors
     ///
-    /// When:
-    /// - `on_failed_local_stream` callback is not set;
-    /// - `on_connection_loss` callback is not set;
-    /// - fails to connect to media server.
+    /// With [`RoomError::CallbackNotSet`] if `on_failed_local_stream` or
+    /// `on_connection_loss` callbacks are not set.
+    ///
+    /// With [`RoomError::CouldNotConnectToServer`] if cannot connect to media
+    /// server.
     pub fn inner_join(
         &self,
         token: String,
@@ -297,16 +302,19 @@ impl RoomHandle {
             .map(|inner| inner.borrow_mut().on_close.set_func(f))
     }
 
-    /// Sets `on_local_stream` callback, which will be invoked once media
-    /// acquisition request will resolve successfully. Only invoked if media
-    /// request was initiated by media server.
+    /// Sets `on_local_stream` callback. This callback is invoked each time
+    /// media acquisition request will resolve successfully. This might
+    /// happen in such cases:
+    /// 1. Media server initiates media request.
+    /// 2. `unmute_audio`/`unmute_video` is called.
+    /// 3. [`MediaStreamSettings`] updated via `set_local_media_settings`.
     pub fn on_local_stream(&self, f: js_sys::Function) -> Result<(), JsValue> {
         upgrade_or_detached!(self.0)
             .map(|inner| inner.borrow_mut().on_local_stream.set_func(f))
     }
 
     /// Sets `on_failed_local_stream` callback, which will be invoked on local
-    /// media acquisition or media injection failures.
+    /// media acquisition failures.
     pub fn on_failed_local_stream(
         &self,
         f: js_sys::Function,
@@ -331,6 +339,7 @@ impl RoomHandle {
     /// Establishes connection with media server (if it doesn't already exist).
     /// Fails if:
     ///   - `on_failed_local_stream` callback is not set
+    ///   - `on_connection_loss` callback is not set
     ///   - unable to connect to media server.
     ///
     /// Effectively returns `Result<(), JasonError>`.
@@ -342,16 +351,29 @@ impl RoomHandle {
         )
     }
 
-    /// Injects local media stream for all created and new [`PeerConnection`]s
-    /// in this [`Room`].
+    /// Updates this [`Room`]s [`MediaStreamSettings`]. This affects all
+    /// [`PeerConnection`]s in this [`Room`]. If [`MediaStreamSettings`] is
+    /// configured for some [`Room`], then this [`Room`] can only send
+    /// [`MediaStream`] that corresponds to this settings.
+    /// [`MediaStreamSettings`] update will change [`MediaStream`] in all
+    /// sending peers, so that might cause new [getUserMedia()][1] request.
+    ///
+    /// Media obtaining/injection errors are fired to `on_failed_local_stream`
+    /// callback.
     ///
     /// [`PeerConnection`]: crate::peer::PeerConnection
-    pub fn inject_local_stream(
+    /// [1]: https://tinyurl.com/rnxcavf
+    pub fn set_local_media_settings(
         &self,
-        stream: SysMediaStream,
-    ) -> Result<(), JsValue> {
-        upgrade_or_detached!(self.0)
-            .map(|inner| inner.borrow_mut().inject_local_stream(stream))
+        settings: &MediaStreamSettings,
+    ) -> Promise {
+        let inner = upgrade_or_detached!(self.0, JasonError);
+        let settings = settings.clone();
+        future_to_promise(async move {
+            let inner = inner?;
+            inner.borrow_mut().set_local_media_settings(settings).await;
+            Ok(JsValue::UNDEFINED)
+        })
     }
 
     /// Mutes outbound audio in this [`Room`].
@@ -484,7 +506,7 @@ struct InnerRoom {
     rpc: Rc<dyn RpcClient>,
 
     /// Local media stream for injecting into new created [`PeerConnection`]s.
-    local_stream: Option<SysMediaStream>,
+    local_stream_settings: Option<MediaStreamSettings>,
 
     /// [`PeerConnection`] repository.
     peers: Box<dyn PeerRepository>,
@@ -502,10 +524,10 @@ struct InnerRoom {
     /// Callback to be invoked when new [`MediaStream`] is acquired providing
     /// its actual underlying [MediaStream][1] object.
     ///
-    /// [1]: https://www.w3.org/TR/mediacapture-streams/#mediastream
+    /// [1]: https://w3.org/TR/mediacapture-streams/#mediastream
     // TODO: will be extended with some metadata that would allow client to
     //       understand purpose of obtaining this stream.
-    on_local_stream: Callback<MediaStreamHandle>,
+    on_local_stream: Callback<MediaStream>,
 
     /// Callback to be invoked when failed obtain [`MediaStream`] from
     /// [`MediaManager`] or failed inject stream into [`PeerConnection`].
@@ -536,7 +558,7 @@ impl InnerRoom {
     ) -> Self {
         Self {
             rpc,
-            local_stream: None,
+            local_stream_settings: None,
             peers,
             peer_event_sender,
             connections: HashMap::new(),
@@ -665,27 +687,37 @@ impl InnerRoom {
             .is_none()
     }
 
-    /// Injects given local stream into all [`PeerConnection`]s of this [`Room`]
-    /// and stores its for injecting into new [`PeerConnection`]s.
+    /// Updates this [`Room`]s [`MediaStreamSettings`]. This affects all
+    /// [`PeerConnection`]s in this [`Room`]. If [`MediaStreamSettings`] is
+    /// configured for some [`Room`], then this [`Room`] can only send
+    /// [`MediaStream`] that corresponds to this settings.
+    /// [`MediaStreamSettings`] update will change [`MediaStream`] in all
+    /// sending peers, so that might cause new [getUserMedia()][1] request.
+    ///
+    /// Media obtaining/injection errors are fired to `on_failed_local_stream`
+    /// callback.
     ///
-    /// If injecting fails, then invokes `on_failed_local_stream` callback with
-    /// a failure error.
-    fn inject_local_stream(&mut self, stream: SysMediaStream) {
+    /// [`PeerConnection`]: crate::peer::PeerConnection
+    /// [1]: https://tinyurl.com/rnxcavf
+    fn set_local_media_settings(
+        &mut self,
+        settings: MediaStreamSettings,
+    ) -> impl Future<Output = ()> + 'static {
         let peers = self.peers.get_all();
-        let injected_stream = Clone::clone(&stream);
+        let settings_clone = settings.clone();
         let error_callback = Rc::clone(&self.on_failed_local_stream);
-        spawn_local(async move {
+        self.local_stream_settings.replace(settings);
+        async move {
             for peer in peers {
                 if let Err(err) = peer
-                    .inject_local_stream(&injected_stream)
+                    .update_local_stream(Some(settings_clone.clone()))
                     .await
                     .map_err(tracerr::map_from_and_wrap!(=> RoomError))
                 {
                     error_callback.call(JasonError::from(err));
                 }
             }
-        });
-        self.local_stream.replace(stream);
+        }
     }
 }
 
@@ -725,7 +757,7 @@ impl EventHandler for InnerRoom {
 
         self.create_connections_from_tracks(&tracks);
 
-        let local_stream = self.local_stream.clone();
+        let local_stream_constraints = self.local_stream_settings.clone();
         let rpc = Rc::clone(&self.rpc);
         let error_callback = Rc::clone(&self.on_failed_local_stream);
         spawn_local(
@@ -733,7 +765,7 @@ impl EventHandler for InnerRoom {
                 match sdp_offer {
                     None => {
                         let sdp_offer = peer
-                            .get_offer(tracks, local_stream.as_ref())
+                            .get_offer(tracks, local_stream_constraints)
                             .await
                             .map_err(tracerr::map_from_and_wrap!())?;
                         let mids = peer
@@ -747,7 +779,11 @@ impl EventHandler for InnerRoom {
                     }
                     Some(offer) => {
                         let sdp_answer = peer
-                            .process_offer(offer, tracks, local_stream.as_ref())
+                            .process_offer(
+                                offer,
+                                tracks,
+                                local_stream_constraints,
+                            )
                             .await
                             .map_err(tracerr::map_from_and_wrap!())?;
                         rpc.send_command(Command::MakeSdpAnswer {
@@ -871,7 +907,7 @@ impl PeerEventHandler for InnerRoom {
         &mut self,
         _: PeerId,
         sender_id: PeerId,
-        remote_stream: MediaStream,
+        remote_stream: PeerMediaStream,
     ) {
         match self.connections.get(&sender_id) {
             Some(conn) => conn.on_remote_stream(remote_stream.new_handle()),
@@ -884,7 +920,7 @@ impl PeerEventHandler for InnerRoom {
 
     /// Invokes `on_local_stream` [`Room`]'s callback.
     fn on_new_local_stream(&mut self, _: PeerId, stream: MediaStream) {
-        self.on_local_stream.call(stream.new_handle());
+        self.on_local_stream.call(stream);
     }
 
     /// Handles [`PeerEvent::IceConnectionStateChanged`] event and sends new
@@ -929,6 +965,27 @@ impl PeerEventHandler for InnerRoom {
             metrics: PeerMetrics::RtcStats(stats.0),
         });
     }
+
+    /// Handles [`PeerEvent::NewLocalStreamRequired`] event and updates local
+    /// stream of [`PeerConnection`] that sent request.
+    fn on_new_local_stream_required(&mut self, peer_id: PeerId) {
+        if let Some(peer) = self.peers.get(peer_id) {
+            let constraints_clone = self.local_stream_settings.clone();
+            let error_callback = Rc::clone(&self.on_failed_local_stream);
+            spawn_local(async move {
+                if let Err(err) = peer
+                    .update_local_stream(constraints_clone)
+                    .await
+                    .map_err(tracerr::map_from_and_wrap!(=> RoomError))
+                {
+                    error_callback.call(JasonError::from(err));
+                }
+            });
+        } else {
+            JasonError::from(tracerr::new!(RoomError::NoSuchPeer(peer_id)))
+                .print();
+        }
+    }
 }
 
 impl Drop for InnerRoom {
diff --git a/jason/src/lib.rs b/jason/src/lib.rs
index 6dce1acde..a9fc9576f 100644
--- a/jason/src/lib.rs
+++ b/jason/src/lib.rs
@@ -30,7 +30,7 @@ pub use self::{
     api::{ConnectionHandle, Jason, RoomHandle},
     media::{
         AudioTrackConstraints, DeviceVideoTrackConstraints,
-        DisplayVideoTrackConstraints, MediaStreamConstraints,
+        DisplayVideoTrackConstraints, MediaStreamSettings,
     },
 };
 
diff --git a/jason/src/media/constraints.rs b/jason/src/media/constraints.rs
index 070f84ab5..604768480 100644
--- a/jason/src/media/constraints.rs
+++ b/jason/src/media/constraints.rs
@@ -20,18 +20,43 @@ enum StreamSource<D, S> {
     Display(S),
 }
 
+impl StreamSource<DeviceVideoTrackConstraints, DisplayVideoTrackConstraints> {
+    fn merge(
+        &mut self,
+        other: StreamSource<
+            DeviceVideoTrackConstraints,
+            DisplayVideoTrackConstraints,
+        >,
+    ) {
+        use StreamSource::{Device, Display};
+
+        match self {
+            Device(this) => {
+                if let Device(that) = other {
+                    this.merge(that);
+                }
+            }
+            Display(this) => {
+                if let Display(that) = other {
+                    this.merge(that);
+                }
+            }
+        };
+    }
+}
+
 /// [MediaStreamConstraints][1] wrapper.
 ///
-/// [1]: https://www.w3.org/TR/mediacapture-streams/#dom-mediastreamconstraints
+/// [1]: https://w3.org/TR/mediacapture-streams/#dom-mediastreamconstraints
 #[wasm_bindgen]
 #[derive(Clone, Default)]
-pub struct MediaStreamConstraints {
+pub struct MediaStreamSettings {
     audio: Option<AudioTrackConstraints>,
     video: Option<VideoTrackConstraints>,
 }
 
 #[wasm_bindgen]
-impl MediaStreamConstraints {
+impl MediaStreamSettings {
     /// Creates new [`MediaStreamConstraints`] with none constraints configured.
     #[wasm_bindgen(constructor)]
     pub fn new() -> Self {
@@ -40,7 +65,7 @@ impl MediaStreamConstraints {
 
     /// Specifies the nature and settings of the audio [MediaStreamTrack][1].
     ///
-    /// [1]: https://www.w3.org/TR/mediacapture-streams/#mediastreamtrack
+    /// [1]: https://w3.org/TR/mediacapture-streams/#mediastreamtrack
     pub fn audio(&mut self, constraints: AudioTrackConstraints) {
         self.audio.replace(constraints);
     }
@@ -58,7 +83,7 @@ impl MediaStreamConstraints {
     }
 }
 
-impl MediaStreamConstraints {
+impl MediaStreamSettings {
     /// Returns only audio constraints.
     pub fn get_audio(&self) -> &Option<AudioTrackConstraints> {
         &self.audio
@@ -69,6 +94,16 @@ impl MediaStreamConstraints {
         &self.video
     }
 
+    /// Takes only audio constraints.
+    pub fn take_audio(&mut self) -> Option<AudioTrackConstraints> {
+        self.audio.take()
+    }
+
+    /// Takes only video constraints.
+    pub fn take_video(&mut self) -> Option<VideoTrackConstraints> {
+        self.video.take()
+    }
+
     /// Set [`VideoTrackConstraints`].
     pub fn video(&mut self, constraints: VideoTrackConstraints) {
         self.video.replace(constraints);
@@ -82,7 +117,7 @@ impl MediaStreamConstraints {
 /// source (device or display), and allows to group two requests with different
 /// sources.
 ///
-/// [1]: https://www.w3.org/TR/mediacapture-streams/#mediastreamconstraints
+/// [1]: https://w3.org/TR/mediacapture-streams/#mediastreamconstraints
 pub enum MultiSourceMediaStreamConstraints {
     /// Only [getUserMedia()][1] request is required.
     ///
@@ -91,19 +126,28 @@ pub enum MultiSourceMediaStreamConstraints {
 
     /// Only [getDisplayMedia()][1] request is required.
     ///
-    /// [1]: https://tinyurl.com/wotjrns
+    /// [1]: https://w3.org/TR/screen-capture/#dom-mediadevices-getdisplaymedia
     Display(SysMediaStreamConstraints),
 
     /// Both [getUserMedia()][1] and [getDisplayMedia()][2] are required.
     ///
     /// [1]: https://tinyurl.com/rnxcavf
-    /// [2]: https://tinyurl.com/wotjrns
+    /// [2]: https://w3.org/TR/screen-capture/#dom-mediadevices-getdisplaymedia
     DeviceAndDisplay(SysMediaStreamConstraints, SysMediaStreamConstraints),
 }
 
-impl From<MediaStreamConstraints> for MultiSourceMediaStreamConstraints {
-    fn from(constraints: MediaStreamConstraints) -> Self {
-        use MultiSourceMediaStreamConstraints::*;
+/// TL;DR:
+/// `{None, None}` => `None`
+/// `{None, Device}` => `Device`
+/// `{None, Display}` => `Display`
+/// `{None, Any}` => `Device`
+/// `{Some, None}` => `Device`
+/// `{Some, Device}` => `Device`
+/// `{Some, Display}` => `DeviceAndDisplay`
+/// `{Some, Any}` => `Device`
+impl From<MediaStreamSettings> for Option<MultiSourceMediaStreamConstraints> {
+    fn from(constraints: MediaStreamSettings) -> Self {
+        use MultiSourceMediaStreamConstraints as C;
 
         let mut sys_constraints = SysMediaStreamConstraints::new();
         let video = match constraints.video {
@@ -111,36 +155,42 @@ impl From<MediaStreamConstraints> for MultiSourceMediaStreamConstraints {
                 Some(StreamSource::Device(device)) => {
                     sys_constraints
                         .video(&SysMediaTrackConstraints::from(device).into());
-                    StreamSource::Device(sys_constraints)
+                    Some(StreamSource::Device(sys_constraints))
                 }
                 Some(StreamSource::Display(display)) => {
                     sys_constraints
                         .video(&SysMediaTrackConstraints::from(display).into());
-                    StreamSource::Display(sys_constraints)
+                    Some(StreamSource::Display(sys_constraints))
                 }
                 None => {
                     // defaults to device video
                     sys_constraints
                         .video(&SysMediaTrackConstraints::new().into());
-                    StreamSource::Device(sys_constraints)
+                    Some(StreamSource::Device(sys_constraints))
                 }
             },
-            None => StreamSource::Device(sys_constraints),
+            None => None,
         };
 
         match (constraints.audio, video) {
-            (Some(audio), StreamSource::Device(mut caps)) => {
+            (Some(audio), Some(StreamSource::Device(mut caps))) => {
                 caps.audio(&SysMediaTrackConstraints::from(audio).into());
-                Device(caps)
+                Some(C::Device(caps))
             }
-            (Some(audio), StreamSource::Display(caps)) => {
+            (Some(audio), Some(StreamSource::Display(caps))) => {
                 let mut audio_caps = SysMediaStreamConstraints::new();
                 audio_caps.audio(&SysMediaTrackConstraints::from(audio).into());
 
-                DeviceAndDisplay(audio_caps, caps)
+                Some(C::DeviceAndDisplay(audio_caps, caps))
             }
-            (None, StreamSource::Device(caps)) => Device(caps),
-            (None, StreamSource::Display(caps)) => Display(caps),
+            (None, Some(StreamSource::Device(caps))) => Some(C::Device(caps)),
+            (None, Some(StreamSource::Display(caps))) => Some(C::Display(caps)),
+            (Some(audio), None) => {
+                let mut audio_caps = SysMediaStreamConstraints::new();
+                audio_caps.audio(&SysMediaTrackConstraints::from(audio).into());
+                Some(C::Device(audio_caps))
+            }
+            (None, None) => None,
         }
     }
 }
@@ -181,7 +231,7 @@ impl TrackConstraints {
     /// [`TrackConstraints`].
     ///
     /// [1]: https://w3.org/TR/mediacapture-streams/#mediastreamtrack
-    pub fn satisfies(&self, track: &SysMediaStreamTrack) -> bool {
+    pub fn satisfies<T: AsRef<SysMediaStreamTrack>>(&self, track: T) -> bool {
         match self {
             Self::Audio(audio) => audio.satisfies(&track),
             Self::Video(video) => video.satisfies(&track),
@@ -224,7 +274,7 @@ impl AudioTrackConstraints {
 
     /// Sets [deviceId][1] constraint.
     ///
-    /// [1]: https://www.w3.org/TR/mediacapture-streams/#def-constraint-deviceId
+    /// [1]: https://w3.org/TR/mediacapture-streams/#def-constraint-deviceId
     pub fn device_id(&mut self, device_id: String) {
         self.device_id = Some(device_id);
     }
@@ -234,8 +284,9 @@ impl AudioTrackConstraints {
     /// Checks if provided [MediaStreamTrack][1] satisfies constraints
     /// contained.
     ///
-    /// [1]: https://www.w3.org/TR/mediacapture-streams/#mediastreamtrack
-    pub fn satisfies(&self, track: &SysMediaStreamTrack) -> bool {
+    /// [1]: https://w3.org/TR/mediacapture-streams/#mediastreamtrack
+    pub fn satisfies<T: AsRef<SysMediaStreamTrack>>(&self, track: T) -> bool {
+        let track = track.as_ref();
         if track.kind() != "audio" {
             return false;
         }
@@ -247,6 +298,15 @@ impl AudioTrackConstraints {
         satisfies_by_device_id(&self.device_id, track)
         // TODO returns Result<bool, Error>
     }
+
+    /// Merges this [`AudioTrackConstraints`] with `another` one, meaning that
+    /// if some constraint is not set on this one, then it will be applied from
+    /// `another`.
+    pub fn merge(&mut self, another: AudioTrackConstraints) {
+        if self.device_id.is_none() && another.device_id.is_some() {
+            self.device_id = another.device_id;
+        }
+    }
 }
 
 impl From<ProtoAudioConstraints> for AudioTrackConstraints {
@@ -288,6 +348,17 @@ pub struct DeviceVideoTrackConstraints {
     device_id: Option<String>,
 }
 
+impl DeviceVideoTrackConstraints {
+    /// Merges this [`DeviceVideoTrackConstraints`] with `another` one , meaning
+    /// that if some constraint is not set on this one, then it will be applied
+    /// from `another`.
+    fn merge(&mut self, another: DeviceVideoTrackConstraints) {
+        if self.device_id.is_none() && another.device_id.is_some() {
+            self.device_id = another.device_id;
+        }
+    }
+}
+
 /// Constraints applicable to video tracks that are sourced from screen-capture.
 #[wasm_bindgen]
 impl DeviceVideoTrackConstraints {
@@ -300,7 +371,7 @@ impl DeviceVideoTrackConstraints {
 
     /// Sets [deviceId][1] constraint.
     ///
-    /// [1]: https://www.w3.org/TR/mediacapture-streams/#def-constraint-deviceId
+    /// [1]: https://w3.org/TR/mediacapture-streams/#def-constraint-deviceId
     pub fn device_id(&mut self, device_id: String) {
         self.device_id = Some(device_id);
     }
@@ -311,6 +382,16 @@ impl DeviceVideoTrackConstraints {
 #[derive(Clone, Default)]
 pub struct DisplayVideoTrackConstraints {}
 
+impl DisplayVideoTrackConstraints {
+    /// Merges this [`DisplayVideoTrackConstraints`] with `another` one, meaning
+    /// that if some constraint is not set on this one, then it will be applied
+    /// from `another`.
+    #[allow(clippy::unused_self)]
+    fn merge(&mut self, _: DisplayVideoTrackConstraints) {
+        // no constraints => nothing to do here atm
+    }
+}
+
 #[wasm_bindgen]
 impl DisplayVideoTrackConstraints {
     /// Creates new [`DisplayVideoTrackConstraints`] with none constraints
@@ -325,8 +406,9 @@ impl VideoTrackConstraints {
     /// Checks if provided [MediaStreamTrack][1] satisfies constraints
     /// contained.
     ///
-    /// [1]: https://www.w3.org/TR/mediacapture-streams/#mediastreamtrack
-    pub fn satisfies(&self, track: &SysMediaStreamTrack) -> bool {
+    /// [1]: https://w3.org/TR/mediacapture-streams/#mediastreamtrack
+    pub fn satisfies<T: AsRef<SysMediaStreamTrack>>(&self, track: T) -> bool {
+        let track = track.as_ref();
         if track.kind() != "video" {
             return false;
         }
@@ -347,8 +429,8 @@ impl VideoTrackConstraints {
         }
     }
 
-    /// Detect is video track captured from display searching [specific
-    /// fields][1] in its settings. Only works in Chrome atm.
+    /// Detects if video track captured from display searching
+    /// [specific fields][1] in its settings. Only works in Chrome atm.
     ///
     /// [1]: https://tinyurl.com/ufx7mcw
     fn guess_is_from_display(track: &SysMediaStreamTrack) -> bool {
@@ -369,6 +451,21 @@ impl VideoTrackConstraints {
             .is_some()
         }
     }
+
+    /// Merges this [`VideoTrackConstraints`] with `another` one, meaning that
+    /// if some constraint is not set on this one, then it will be applied from
+    /// `another`.
+    pub fn merge(&mut self, another: VideoTrackConstraints) {
+        match (self.0.as_mut(), another.0) {
+            (None, Some(another)) => {
+                self.0.replace(another);
+            }
+            (Some(this), Some(another)) => {
+                this.merge(another);
+            }
+            _ => {}
+        };
+    }
 }
 
 impl From<ProtoVideoConstraints> for VideoTrackConstraints {
diff --git a/jason/src/media/device_info.rs b/jason/src/media/device_info.rs
index 95e60526d..6d5754d62 100644
--- a/jason/src/media/device_info.rs
+++ b/jason/src/media/device_info.rs
@@ -1,4 +1,4 @@
-//! [`MediaDeviceInfo`][1] related objects.
+//! [MediaDeviceInfo][1] related objects.
 //!
 //! [1]: https://w3.org/TR/mediacapture-streams/#device-info
 
@@ -34,9 +34,11 @@ pub struct InputDeviceInfo {
 /// [MediaDeviceKind][1] wrapper, excluding `audiooutput`.
 ///
 /// [1]: https://w3.org/TR/mediacapture-streams/#dom-mediadevicekind
+#[derive(Clone, Copy, Eq, PartialEq)]
 enum InputDeviceKind {
     /// `audioinput` device (for example a microphone).
     Audio,
+
     /// `videoinput` device ( for example a webcam).
     Video,
 }
diff --git a/jason/src/media/manager.rs b/jason/src/media/manager.rs
index c5cce5743..a7fd268f2 100644
--- a/jason/src/media/manager.rs
+++ b/jason/src/media/manager.rs
@@ -17,17 +17,20 @@ use wasm_bindgen::{prelude::*, JsValue};
 use wasm_bindgen_futures::{future_to_promise, JsFuture};
 use web_sys::{
     MediaDevices, MediaStream as SysMediaStream,
-    MediaStreamConstraints as SysMediaStreamConstraints, MediaStreamTrack,
+    MediaStreamConstraints as SysMediaStreamConstraints,
 };
 
 use crate::{
-    media::{MediaStreamConstraints, MultiSourceMediaStreamConstraints},
+    media::{
+        stream::{MediaStream, MediaStreamTrack, WeakMediaStreamTrack},
+        MediaStreamSettings, MultiSourceMediaStreamConstraints,
+    },
     utils::{window, HandlerDetachedError, JasonError, JsCaused, JsError},
 };
 
 use super::InputDeviceInfo;
 
-// TODO: Screen capture API (https://www.w3.org/TR/screen-capture/) is in draft
+// TODO: Screen capture API (https://w3.org/TR/screen-capture/) is in draft
 //       stage atm, so there is no web-sys bindings for it.
 //       Discussion https://github.com/rustwasm/wasm-bindgen/issues/1950
 #[wasm_bindgen(inline_js = "export function get_display_media(media_devices, \
@@ -57,9 +60,9 @@ pub enum MediaManagerError {
     #[display(fmt = "MediaDevices.getUserMedia() failed: {}", _0)]
     GetUserMediaFailed(JsError),
 
-    /// Occurs if the [getDisplayMedia][1] request failed.
+    /// Occurs if the [MediaDevices.getDisplayMedia()][1] request failed.
     ///
-    /// [1]: https://tinyurl.com/wotjrns
+    /// [1]: https://w3.org/TR/screen-capture/#dom-mediadevices-getdisplaymedia
     #[display(fmt = "MediaDevices.getDisplayMedia() failed: {}", _0)]
     GetDisplayMediaFailed(JsError),
 
@@ -72,9 +75,16 @@ pub enum MediaManagerError {
 
 type Result<T> = std::result::Result<T, Traced<MediaManagerError>>;
 
-/// Manager that is responsible for [MediaStream][1] acquisition and storing.
+/// [`MediaManager`] performs all media acquisition requests
+/// ([getUserMedia()][1]/[getDisplayMedia()][2]) and stores all received tracks
+/// for further reusage.
 ///
-/// [1]: https://w3.org/TR/mediacapture-streams/#mediastream
+/// [`MediaManager`] stores weak references to
+/// [`MediaStreamTrack`]s, so if there are no strong references to some track,
+/// then this track is stopped and deleted from [`MediaManager`].
+///
+/// [1]: https://w3.org/TR/mediacapture-streams/#dom-mediadevices-getusermedia
+/// [2]: https://w3.org/TR/screen-capture/#dom-mediadevices-getdisplaymedia
 #[derive(Default)]
 pub struct MediaManager(Rc<InnerMediaManager>);
 
@@ -82,14 +92,17 @@ pub struct MediaManager(Rc<InnerMediaManager>);
 #[derive(Default)]
 struct InnerMediaManager {
     /// Obtained tracks storage
-    tracks: Rc<RefCell<Vec<MediaStreamTrack>>>,
+    tracks: Rc<RefCell<Vec<WeakMediaStreamTrack>>>,
 }
 
 impl InnerMediaManager {
     /// Returns the vector of [`MediaDeviceInfo`] objects.
     fn enumerate_devices() -> impl Future<Output = Result<Vec<InputDeviceInfo>>>
     {
-        use MediaManagerError::*;
+        use MediaManagerError::{
+            CouldNotGetMediaDevices, EnumerateDevicesFailed,
+        };
+
         async {
             let devices = window()
                 .navigator()
@@ -120,106 +133,141 @@ impl InnerMediaManager {
         }
     }
 
-    /// Returns [MediaStream][1] and information if this stream is new one,
-    /// meaning that it was obtained via new [getUserMedia()][2] call or was
-    /// build from already owned tracks.
+    /// Obtains [`MediaStream`] based on a provided [`MediaStreamSettings`].
+    /// This can be a stream built from tracks that were acquired earlier, or
+    /// from new tracks, acquired via [getUserMedia()][1] or/and
+    /// [getDisplayMedia()][2] requests.
     ///
-    /// [1]: https://w3.org/TR/mediacapture-streams/#mediastream
-    /// [2]: https://tinyurl.com/rnxcavf
+    /// # Errors
+    ///
+    /// With [`MediaManagerError::GetUserMediaFailed`] IF [getUserMedia()][1]
+    /// request failed.
+    ///
+    /// With [`MediaManagerError::GetDisplayMediaFailed`] if
+    /// [getDisplayMedia()][2] request failed.
+    ///
+    ///
+    /// [1]: https://tinyurl.com/rnxcavf
+    /// [2]: https://w3.org/TR/screen-capture/#dom-mediadevices-getdisplaymedia
     fn get_stream(
         &self,
-        caps: MediaStreamConstraints,
-    ) -> impl Future<Output = Result<(SysMediaStream, bool)>> {
-        if let Some(stream) = self.get_from_storage(&caps) {
-            future::ok((stream, false)).left_future().left_future()
-        } else {
-            let caps: MultiSourceMediaStreamConstraints = caps.into();
-            match caps {
-                MultiSourceMediaStreamConstraints::Display(caps) => self
-                    .get_display_media(caps)
-                    .and_then(|stream| future::ok((stream, true)))
+        mut caps: MediaStreamSettings,
+    ) -> impl Future<Output = Result<(MediaStream, bool)>> {
+        let original_caps = caps.clone();
+
+        let mut result = self.get_from_storage(&mut caps);
+        let caps: Option<MultiSourceMediaStreamConstraints> = caps.into();
+        match caps {
+            None => {
+                future::ok((MediaStream::new(result, original_caps), false))
                     .left_future()
-                    .right_future(),
-                MultiSourceMediaStreamConstraints::Device(caps) => self
-                    .get_user_media(caps)
-                    .and_then(|stream| future::ok((stream, true)))
-                    .right_future()
-                    .left_future(),
-                MultiSourceMediaStreamConstraints::DeviceAndDisplay(
-                    device_caps,
-                    display_caps,
-                ) => {
-                    let get_user_media = self.get_user_media(device_caps);
-                    let get_display_media =
-                        self.get_display_media(display_caps);
-
-                    async move {
-                        let get_user_media = get_user_media.await?;
-                        let get_display_media = get_display_media.await?;
-
-                        let merged =
-                            merge_streams(&get_user_media, &get_display_media);
-
-                        Ok((merged, true))
-                    }
-                    .right_future()
-                    .right_future()
+                    .left_future()
+            }
+            Some(MultiSourceMediaStreamConstraints::Display(caps)) => self
+                .get_display_media(caps)
+                .map_ok(|mut tracks| {
+                    result.append(&mut tracks);
+                    result
+                })
+                .map_ok(|result| {
+                    (MediaStream::new(result, original_caps), true)
+                })
+                .left_future()
+                .right_future(),
+            Some(MultiSourceMediaStreamConstraints::Device(caps)) => self
+                .get_user_media(caps)
+                .map_ok(|mut tracks| {
+                    result.append(&mut tracks);
+                    result
+                })
+                .map_ok(|result| {
+                    (MediaStream::new(result, original_caps), true)
+                })
+                .right_future()
+                .left_future(),
+            Some(MultiSourceMediaStreamConstraints::DeviceAndDisplay(
+                device_caps,
+                display_caps,
+            )) => {
+                let get_user_media = self.get_user_media(device_caps);
+                let get_display_media = self.get_display_media(display_caps);
+
+                async move {
+                    let mut get_user_media = get_user_media.await?;
+                    let mut get_display_media = get_display_media.await?;
+                    result.append(&mut get_user_media);
+                    result.append(&mut get_display_media);
+
+                    Ok((MediaStream::new(result, original_caps), true))
                 }
+                .right_future()
+                .right_future()
             }
         }
     }
 
-    /// Tries to build new [MediaStream][1] from already owned tracks to avoid
-    /// redundant [getUserMedia()][2]/[getDisplayMedia()][3] calls.
+    /// Tries to find [`MediaStreamTrack`]s that satisfies
+    /// [`MediaStreamSettings`], from tracks that were acquired earlier to avoid
+    /// redundant [getUserMedia()][1]/[getDisplayMedia()][2] calls.
     ///
-    /// [1]: https://w3.org/TR/mediacapture-streams/#mediastream
-    /// [2]: https://tinyurl.com/rnxcavf
-    /// [3]: https://tinyurl.com/wotjrns
+    /// [1]: https://tinyurl.com/rnxcavf
+    /// [2]: https://w3.org/TR/screen-capture/#dom-mediadevices-getdisplaymedia
     fn get_from_storage(
         &self,
-        caps: &MediaStreamConstraints,
-    ) -> Option<SysMediaStream> {
+        caps: &mut MediaStreamSettings,
+    ) -> Vec<MediaStreamTrack> {
+        // cleanup weak links
+        self.tracks
+            .borrow_mut()
+            .retain(WeakMediaStreamTrack::can_be_upgraded);
+
         let mut tracks = Vec::new();
-        let storage = self.tracks.borrow();
+        let storage: Vec<_> = self
+            .tracks
+            .borrow()
+            .iter()
+            .map(|track| track.upgrade().unwrap())
+            .collect();
 
         if let Some(audio) = caps.get_audio() {
-            let track = storage.iter().find(|track| audio.satisfies(track));
+            let track = storage
+                .iter()
+                .find(|track| audio.satisfies(track.as_ref()))
+                .cloned();
 
             if let Some(track) = track {
+                caps.take_audio();
                 tracks.push(track);
-            } else {
-                return None;
             }
         }
 
         if let Some(video) = caps.get_video() {
-            let track = storage.iter().find(|track| video.satisfies(track));
+            let track = storage
+                .iter()
+                .find(|track| video.satisfies(track.as_ref()))
+                .cloned();
 
             if let Some(track) = track {
+                caps.take_video();
                 tracks.push(track);
-            } else {
-                return None;
             }
         }
 
-        let stream = SysMediaStream::new().unwrap();
-        for track in tracks {
-            stream.add_track(track);
-        }
-
-        Some(stream)
+        tracks
     }
 
-    /// Obtains new [MediaStream][1] making [getUserMedia()][2] call and saves
-    /// its tracks to storage.
+    /// Obtains new [MediaStream][1] making [getUserMedia()][2] call, saves
+    /// received tracks weak refs to storage, returns list of tracks strong
+    /// refs.
     ///
     /// [1]: https://w3.org/TR/mediacapture-streams/#mediastream
     /// [2]: https://tinyurl.com/rnxcavf
     fn get_user_media(
         &self,
         caps: SysMediaStreamConstraints,
-    ) -> impl Future<Output = Result<SysMediaStream>> {
-        use MediaManagerError::*;
+    ) -> impl Future<Output = Result<Vec<MediaStreamTrack>>> {
+        use MediaManagerError::{CouldNotGetMediaDevices, GetUserMediaFailed};
+
         let storage = Rc::clone(&self.tracks);
 
         async move {
@@ -238,32 +286,37 @@ impl InnerMediaManager {
                     .map_err(tracerr::from_and_wrap!())?,
             )
             .await
+            .map(SysMediaStream::from)
             .map_err(JsError::from)
             .map_err(GetUserMediaFailed)
             .map_err(tracerr::from_and_wrap!())?;
 
-            let stream = SysMediaStream::from(stream);
-
-            js_sys::try_iter(&stream.get_tracks())
+            let mut storage_mut = storage.borrow_mut();
+            let tracks: Vec<_> = js_sys::try_iter(&stream.get_tracks())
                 .unwrap()
                 .unwrap()
                 .map(|tr| MediaStreamTrack::from(tr.unwrap()))
-                .for_each(|track| storage.borrow_mut().push(track));
+                .inspect(|track| storage_mut.push(track.downgrade()))
+                .collect();
 
-            Ok(stream)
+            Ok(tracks)
         }
     }
 
-    /// Obtains new [MediaStream][1] making [getDisplayMedia()][2] call and
-    /// saves its tracks to storage.
+    /// Obtains new [MediaStream][1] making [getDisplayMedia()][2] call, saves
+    /// received tracks weak refs to storage, returns list of tracks strong
+    /// refs.
     ///
     /// [1]: https://w3.org/TR/mediacapture-streams/#mediastream
-    /// [2]: https://tinyurl.com/wotjrns
+    /// [2]: https://w3.org/TR/screen-capture/#dom-mediadevices-getdisplaymedia
     fn get_display_media(
         &self,
         caps: SysMediaStreamConstraints,
-    ) -> impl Future<Output = Result<SysMediaStream>> {
-        use MediaManagerError::*;
+    ) -> impl Future<Output = Result<Vec<MediaStreamTrack>>> {
+        use MediaManagerError::{
+            CouldNotGetMediaDevices, GetDisplayMediaFailed, GetUserMediaFailed,
+        };
+
         let storage = Rc::clone(&self.tracks);
 
         async move {
@@ -281,50 +334,44 @@ impl InnerMediaManager {
                     .map_err(tracerr::from_and_wrap!())?,
             )
             .await
+            .map(SysMediaStream::from)
             .map_err(JsError::from)
             .map_err(GetUserMediaFailed)
             .map_err(tracerr::from_and_wrap!())?;
 
-            let stream = SysMediaStream::from(stream);
-
-            js_sys::try_iter(&stream.get_tracks())
+            let mut storage_mut = storage.borrow_mut();
+            let tracks: Vec<_> = js_sys::try_iter(&stream.get_tracks())
                 .unwrap()
                 .unwrap()
                 .map(|tr| MediaStreamTrack::from(tr.unwrap()))
-                .for_each(|track| storage.borrow_mut().push(track));
-
-            Ok(stream)
-        }
-    }
-}
+                .inspect(|track| storage_mut.push(track.downgrade()))
+                .collect();
 
-impl Drop for InnerMediaManager {
-    fn drop(&mut self) {
-        for track in self.tracks.borrow_mut().drain(..) {
-            track.stop();
+            Ok(tracks)
         }
     }
 }
 
 impl MediaManager {
-    /// Obtains [MediaStream][1] basing on a provided
-    /// [MediaStreamConstraints][2].
-    /// Acquired streams are cached and cloning existing stream is preferable
-    /// over obtaining new ones.
-    ///
-    /// `on_local_stream` callback will be invoked each time new stream was
-    /// obtained.
+    /// Obtains [`MediaStream`] based on a provided [`MediaStreamSettings`].
+    /// This can be a stream built from tracks that were acquired earlier, or
+    /// from new tracks, acquired via [getUserMedia()][1] or/and
+    /// [getDisplayMedia()][2] requests.
     ///
     /// # Errors
     ///
-    /// When fails to obtain [MediaStream][1].
+    /// With [`MediaManagerError::GetUserMediaFailed`] if [getUserMedia()][1]
+    /// request failed.
     ///
-    /// [1]: https://w3.org/TR/mediacapture-streams/#mediastream
-    /// [2]: https://w3.org/TR/mediacapture-streams/#dom-mediastreamconstraints
-    pub async fn get_stream<I: Into<MediaStreamConstraints>>(
+    /// With [`MediaManagerError::GetDisplayMediaFailed`] if
+    /// [getDisplayMedia()][2] request failed.
+    ///
+    /// [1]: https://tinyurl.com/rnxcavf
+    /// [2]: https://w3.org/TR/screen-capture/#dom-mediadevices-getdisplaymedia
+    pub async fn get_stream<I: Into<MediaStreamSettings>>(
         &self,
         caps: I,
-    ) -> Result<(SysMediaStream, bool)> {
+    ) -> Result<(MediaStream, bool)> {
         self.0.get_stream(caps.into()).await
     }
 
@@ -337,17 +384,25 @@ impl MediaManager {
 
 /// JS side handle to [`MediaManager`].
 ///
-/// Actually, represents a [`Weak`]-based handle to [`InnerMediaManager`].
+/// [`MediaManager`] performs all media acquisition requests
+/// ([getUserMedia()][1]/[getDisplayMedia()][2]) and stores all received tracks
+/// for further reusage.
+///
+/// [`MediaManager`] stores weak references to [`MediaStreamTrack`]s, so if
+/// there are no strong references to some track, then this track is stopped
+/// and deleted from [`MediaManager`].
 ///
-/// For using [`MediaManagerHandle`] on Rust side,
-/// consider the [`MediaManager`].
+/// [1]: https://w3.org/TR/mediacapture-streams/#dom-mediadevices-getusermedia
+/// [2]: https://w3.org/TR/screen-capture/#dom-mediadevices-getdisplaymedia
 #[wasm_bindgen]
 pub struct MediaManagerHandle(Weak<InnerMediaManager>);
 
 #[wasm_bindgen]
 #[allow(clippy::unused_self)]
 impl MediaManagerHandle {
-    /// Returns the JS array of [`InputDeviceInfo`] objects.
+    /// Returns array of [`InputDeviceInfo`] objects, which represent available
+    /// media input and output devices, such as microphones, cameras, and so
+    /// forth.
     pub fn enumerate_devices(&self) -> Promise {
         future_to_promise(async {
             InnerMediaManager::enumerate_devices()
@@ -366,11 +421,12 @@ impl MediaManagerHandle {
         })
     }
 
-    /// Returns [MediaStream][1] object.
-    ///
-    /// [1]: https://w3.org/TR/mediacapture-streams/#mediastream
-    pub fn init_local_stream(&self, caps: MediaStreamConstraints) -> Promise {
-        match upgrade_or_detached!(self.0).map(|inner| inner.get_stream(caps)) {
+    /// Returns [`MediaStream`](LocalMediaStream) object, built from provided
+    /// [`MediaStreamSettings`].
+    pub fn init_local_stream(&self, caps: &MediaStreamSettings) -> Promise {
+        match upgrade_or_detached!(self.0)
+            .map(|inner| inner.get_stream(caps.clone()))
+        {
             Ok(stream) => future_to_promise(async {
                 stream
                     .await
@@ -382,25 +438,3 @@ impl MediaManagerHandle {
         }
     }
 }
-
-/// Builds new [`SysMediaStream`] from tracks in provided [`SysMediaStream`]s.
-fn merge_streams(
-    left: &SysMediaStream,
-    right: &SysMediaStream,
-) -> SysMediaStream {
-    let stream = SysMediaStream::new().unwrap();
-
-    js_sys::try_iter(&left.get_tracks())
-        .unwrap()
-        .unwrap()
-        .map(|tr| MediaStreamTrack::from(tr.unwrap()))
-        .for_each(|track| stream.add_track(&track));
-
-    js_sys::try_iter(&right.get_tracks())
-        .unwrap()
-        .unwrap()
-        .map(|tr| MediaStreamTrack::from(tr.unwrap()))
-        .for_each(|track| stream.add_track(&track));
-
-    stream
-}
diff --git a/jason/src/media/mod.rs b/jason/src/media/mod.rs
index 2cb3d2127..2d4e8b1fc 100644
--- a/jason/src/media/mod.rs
+++ b/jason/src/media/mod.rs
@@ -5,15 +5,17 @@
 mod constraints;
 mod device_info;
 mod manager;
+mod stream;
 
 #[doc(inline)]
 pub use self::{
     constraints::{
         AudioTrackConstraints, DeviceVideoTrackConstraints,
-        DisplayVideoTrackConstraints, MediaStreamConstraints,
+        DisplayVideoTrackConstraints, MediaStreamSettings,
         MultiSourceMediaStreamConstraints, TrackConstraints,
         VideoTrackConstraints,
     },
     device_info::InputDeviceInfo,
     manager::{MediaManager, MediaManagerError, MediaManagerHandle},
+    stream::{MediaStream, MediaStreamTrack, TrackKind},
 };
diff --git a/jason/src/media/stream.rs b/jason/src/media/stream.rs
new file mode 100644
index 000000000..7a46f5284
--- /dev/null
+++ b/jason/src/media/stream.rs
@@ -0,0 +1,172 @@
+//! [MediaStream][1] related objects.
+//!
+//! [1]: https://w3.org/TR/mediacapture-streams/#mediastream
+
+use std::rc::{Rc, Weak};
+
+use derive_more::AsRef;
+use wasm_bindgen::prelude::*;
+use web_sys::{
+    MediaStream as SysMediaStream, MediaStreamTrack as SysMediaStreamTrack,
+};
+
+use crate::MediaStreamSettings;
+
+/// Representation of [MediaStream][1] object. Contains strong references to
+/// [`MediaStreamTrack`].
+///
+/// [1]: https://w3.org/TR/mediacapture-streams/#mediastream
+#[wasm_bindgen(js_name = LocalMediaStream)]
+#[derive(AsRef, Clone)]
+pub struct MediaStream {
+    #[as_ref]
+    stream: SysMediaStream,
+    constraints: MediaStreamSettings,
+    tracks: Vec<MediaStreamTrack>,
+}
+
+impl MediaStream {
+    /// Creates new [`MediaStream`] from provided tracks and stream settings.
+    pub fn new(
+        tracks: Vec<MediaStreamTrack>,
+        constraints: MediaStreamSettings,
+    ) -> Self {
+        let stream = SysMediaStream::new().unwrap();
+        tracks
+            .iter()
+            .for_each(|track| stream.add_track(track.as_ref()));
+
+        MediaStream {
+            stream,
+            constraints,
+            tracks,
+        }
+    }
+
+    /// Consumes `self` returning all underlying [`MediaStreamTrack`]s.
+    pub fn into_tracks(self) -> Vec<MediaStreamTrack> {
+        self.tracks
+    }
+}
+
+#[wasm_bindgen(js_class = LocalMediaStream)]
+impl MediaStream {
+    /// Returns underlying [MediaStream][1].
+    ///
+    /// [1]: https://w3.org/TR/mediacapture-streams/#mediastream
+    pub fn get_media_stream(&self) -> SysMediaStream {
+        Clone::clone(&self.stream)
+    }
+
+    /// Drops all audio tracks contained in ths stream.
+    pub fn free_audio(&mut self) {
+        self.tracks.retain(|track| match track.kind() {
+            TrackKind::Audio => false,
+            TrackKind::Video => true,
+        });
+    }
+
+    /// Drops all video tracks contained in ths stream.
+    pub fn free_video(&mut self) {
+        self.tracks.retain(|track| match track.kind() {
+            TrackKind::Audio => true,
+            TrackKind::Video => false,
+        });
+    }
+}
+
+/// Weak reference to [MediaStreamTrack][1].
+///
+/// [1]: https://w3.org/TR/mediacapture-streams/#dom-mediastreamtrack
+pub struct WeakMediaStreamTrack(Weak<SysMediaStreamTrack>);
+
+impl WeakMediaStreamTrack {
+    /// Tries to upgrade this weak reference to a strong one.
+    #[inline]
+    pub fn upgrade(&self) -> Option<MediaStreamTrack> {
+        self.0.upgrade().map(MediaStreamTrack)
+    }
+
+    /// Checks whether this weak reference can be upgraded to a strong one.
+    #[inline]
+    pub fn can_be_upgraded(&self) -> bool {
+        self.0.strong_count() > 0
+    }
+}
+
+/// Strong reference to [MediaStreamTrack][1].
+///
+/// Track will be automatically stopped when there are no strong references
+/// left.
+///
+/// [1]: https://w3.org/TR/mediacapture-streams/#dom-mediastreamtrack
+#[derive(Clone)]
+pub struct MediaStreamTrack(Rc<SysMediaStreamTrack>);
+
+/// [MediaStreamTrack.kind][1] representation.
+///
+/// [1]: https://w3.org/TR/mediacapture-streams/#dom-mediastreamtrack-kind
+#[derive(Clone, Copy, Eq, PartialEq)]
+pub enum TrackKind {
+    /// Audio track.
+    Audio,
+
+    /// Video track.
+    Video,
+}
+
+impl<T> From<T> for MediaStreamTrack
+where
+    SysMediaStreamTrack: From<T>,
+{
+    #[inline]
+    fn from(track: T) -> Self {
+        MediaStreamTrack(Rc::new(<SysMediaStreamTrack as From<T>>::from(track)))
+    }
+}
+
+impl AsRef<SysMediaStreamTrack> for MediaStreamTrack {
+    #[inline]
+    fn as_ref(&self) -> &SysMediaStreamTrack {
+        &self.0
+    }
+}
+
+impl MediaStreamTrack {
+    /// Returns [`id`][1] of underlying [MediaStreamTrack][2].
+    ///
+    /// [1]: https://w3.org/TR/mediacapture-streams/#dom-mediastreamtrack-id
+    /// [2]: https://w3.org/TR/mediacapture-streams/#mediastreamtrack
+    #[inline]
+    pub fn id(&self) -> String {
+        self.0.id()
+    }
+
+    /// Returns track kind (audio/video).
+    #[inline]
+    pub fn kind(&self) -> TrackKind {
+        match self.0.kind().as_ref() {
+            "audio" => TrackKind::Audio,
+            "video" => TrackKind::Video,
+            _ => unreachable!(),
+        }
+    }
+
+    /// Creates weak reference to underlying [MediaStreamTrack][2].
+    ///
+    /// [2]: https://w3.org/TR/mediacapture-streams/#mediastreamtrack
+    #[inline]
+    pub fn downgrade(&self) -> WeakMediaStreamTrack {
+        WeakMediaStreamTrack(Rc::downgrade(&self.0))
+    }
+}
+
+impl Drop for MediaStreamTrack {
+    #[inline]
+    fn drop(&mut self) {
+        // Last strong ref being dropped, so stop underlying MediaTrack
+        if Rc::strong_count(&self.0) == 1 {
+            self.0.stop();
+        }
+    }
+}
diff --git a/jason/src/peer/conn.rs b/jason/src/peer/conn.rs
index bf7486fe0..19d3695c1 100644
--- a/jason/src/peer/conn.rs
+++ b/jason/src/peer/conn.rs
@@ -99,11 +99,13 @@ pub enum TransceiverDirection {
 }
 
 impl From<TransceiverDirection> for RtcRtpTransceiverDirection {
+    #[inline]
     fn from(direction: TransceiverDirection) -> Self {
-        use TransceiverDirection::*;
+        use TransceiverDirection as D;
+
         match direction {
-            Sendonly => Self::Sendonly,
-            Recvonly => Self::Recvonly,
+            D::Sendonly => Self::Sendonly,
+            D::Recvonly => Self::Recvonly,
         }
     }
 }
@@ -136,13 +138,13 @@ pub enum SdpType {
 /// Errors that may occur during signaling between this and remote
 /// [RTCPeerConnection][1] and event handlers setting errors.
 ///
-/// [1]: https://www.w3.org/TR/webrtc/#dom-rtcpeerconnection.
+/// [1]: https://w3.org/TR/webrtc/#dom-rtcpeerconnection
 #[derive(Debug, Display, From, JsCaused)]
 pub enum RTCPeerConnectionError {
     /// Occurs when cannot adds new remote candidate to the
     /// [RTCPeerConnection][1]'s remote description.
     ///
-    /// [1]: https://www.w3.org/TR/webrtc/#dom-rtcpeerconnection.
+    /// [1]: https://w3.org/TR/webrtc/#dom-rtcpeerconnection
     #[display(fmt = "Failed to add ICE candidate: {}", _0)]
     #[from(ignore)]
     AddIceCandidateFailed(JsError),
@@ -201,17 +203,17 @@ type Result<T> = std::result::Result<T, Traced<RTCPeerConnectionError>>;
 pub struct RtcPeerConnection {
     /// Underlying [RTCPeerConnection][1].
     ///
-    /// [1]: https://www.w3.org/TR/webrtc/#rtcpeerconnection-interface
+    /// [1]: https://w3.org/TR/webrtc/#rtcpeerconnection-interface
     peer: Rc<SysRtcPeerConnection>,
 
     /// [`onicecandidate`][2] callback of [RTCPeerConnection][1] to handle
     /// [`icecandidate`][3] event. It fires when [RTCPeerConnection][1]
     /// discovers a new [RTCIceCandidate][4].
     ///
-    /// [1]: https://www.w3.org/TR/webrtc/#rtcpeerconnection-interface
-    /// [2]: https://www.w3.org/TR/webrtc/#dom-rtcpeerconnection-onicecandidate
-    /// [3]: https://www.w3.org/TR/webrtc/#event-icecandidate
-    /// [4]: https://www.w3.org/TR/webrtc/#dom-rtcicecandidate
+    /// [1]: https://w3.org/TR/webrtc/#rtcpeerconnection-interface
+    /// [2]: https://w3.org/TR/webrtc/#dom-rtcpeerconnection-onicecandidate
+    /// [3]: https://w3.org/TR/webrtc/#event-icecandidate
+    /// [4]: https://w3.org/TR/webrtc/#dom-rtcicecandidate
     on_ice_candidate: RefCell<
         Option<EventListener<SysRtcPeerConnection, RtcPeerConnectionIceEvent>>,
     >,
@@ -235,7 +237,7 @@ pub struct RtcPeerConnection {
     /// <https://bugzilla.mozilla.org/show_bug.cgi?id=1265827>
     ///
     /// [1]: https://w3.org/TR/webrtc/#rtcpeerconnection-interface
-    /// [2]: https://www.w3.org/TR/webrtc/#event-connectionstatechange
+    /// [2]: https://w3.org/TR/webrtc/#event-connectionstatechange
     on_connection_state_changed:
         RefCell<Option<EventListener<SysRtcPeerConnection, Event>>>,
 
@@ -243,9 +245,9 @@ pub struct RtcPeerConnection {
     /// [`track`][3] event. It fires when [RTCPeerConnection][1] receives
     /// new [MediaStreamTrack][4] from remote peer.
     ///
-    /// [1]: https://www.w3.org/TR/webrtc/#rtcpeerconnection-interface
-    /// [2]: https://www.w3.org/TR/webrtc/#dom-rtcpeerconnection-ontrack
-    /// [3]: https://www.w3.org/TR/webrtc/#event-track
+    /// [1]: https://w3.org/TR/webrtc/#rtcpeerconnection-interface
+    /// [2]: https://w3.org/TR/webrtc/#dom-rtcpeerconnection-ontrack
+    /// [3]: https://w3.org/TR/webrtc/#event-track
     /// [4]: https://developer.mozilla.org/en-US/docs/Web/API/MediaStreamTrack
     on_track:
         RefCell<Option<EventListener<SysRtcPeerConnection, RtcTrackEvent>>>,
@@ -315,8 +317,8 @@ impl RtcPeerConnection {
     /// Errors with [`RTCPeerConnectionError::PeerConnectionEventBindFailed`] if
     /// [`EventListener`] binding fails.
     ///
-    /// [1]: https://www.w3.org/TR/webrtc/#rtctrackevent
-    /// [2]: https://www.w3.org/TR/webrtc/#dom-rtcpeerconnection-ontrack
+    /// [1]: https://w3.org/TR/webrtc/#rtctrackevent
+    /// [2]: https://w3.org/TR/webrtc/#dom-rtcpeerconnection-ontrack
     pub fn on_track<F>(&self, f: Option<F>) -> Result<()>
     where
         F: 'static + FnMut(RtcTrackEvent),
@@ -350,8 +352,8 @@ impl RtcPeerConnection {
     /// Errors with [`RTCPeerConnectionError::PeerConnectionEventBindFailed`] if
     /// [`EventListener`] binding fails.
     ///
-    /// [1]: https://www.w3.org/TR/webrtc/#dom-rtcpeerconnectioniceevent
-    /// [2]: https://www.w3.org/TR/webrtc/#dom-rtcpeerconnection-onicecandidate
+    /// [1]: https://w3.org/TR/webrtc/#dom-rtcpeerconnectioniceevent
+    /// [2]: https://w3.org/TR/webrtc/#dom-rtcpeerconnection-onicecandidate
     pub fn on_ice_candidate<F>(&self, f: Option<F>) -> Result<()>
     where
         F: 'static + FnMut(IceCandidate),
@@ -394,7 +396,7 @@ impl RtcPeerConnection {
     /// Will return [`RTCPeerConnectionError::PeerConnectionEventBindFailed`] if
     /// [`EventListener`] binding fails.
     ///
-    /// [1]: https://www.w3.org/TR/webrtc/#event-iceconnectionstatechange
+    /// [1]: https://w3.org/TR/webrtc/#event-iceconnectionstatechange
     pub fn on_ice_connection_state_change<F>(&self, f: Option<F>) -> Result<()>
     where
         F: 'static + FnMut(RtcIceConnectionState),
@@ -431,7 +433,7 @@ impl RtcPeerConnection {
     /// This error can be ignored, since this event is currently implemented
     /// only in Chrome and Safari.
     ///
-    /// [1]: https://www.w3.org/TR/webrtc/#event-connectionstatechange
+    /// [1]: https://w3.org/TR/webrtc/#event-connectionstatechange
     pub fn on_connection_state_change<F>(&self, f: Option<F>) -> Result<()>
     where
         F: 'static + FnMut(PeerConnectionState),
@@ -499,11 +501,12 @@ impl RtcPeerConnection {
     ///
     /// # Errors
     ///
-    /// - [`RTCPeerConnectionError::AddIceCandidateFailed`] if fails to add [ICE
-    ///   candidate][2].
+    /// With [`RTCPeerConnectionError::AddIceCandidateFailed`] if
+    /// [RtcPeerConnection.addIceCandidate()][3] fails.
     ///
-    /// [1]: https://www.w3.org/TR/webrtc/#rtcpeerconnection-interface
+    /// [1]: https://w3.org/TR/webrtc/#rtcpeerconnection-interface
     /// [2]: https://tools.ietf.org/html/rfc5245#section-2
+    /// [3]: https://w3.org/TR/webrtc/#dom-peerconnection-addicecandidate
     pub async fn add_ice_candidate(
         &self,
         candidate: &str,
@@ -534,10 +537,14 @@ impl RtcPeerConnection {
     ///
     /// # Errors
     ///
-    /// - [`RTCPeerConnectionError::CreateAnswerFailed`] if fails to obtain SDP
-    ///   answer.
-    /// - [`RTCPeerConnectionError::SetLocalDescriptionFailed`] if fails to set
-    ///   obtained SDP answer as local description.
+    /// With [`RTCPeerConnectionError::CreateAnswerFailed`] if
+    /// [RtcPeerConnection.createAnswer()][1] fails.
+    ///
+    /// With [`RTCPeerConnectionError::SetLocalDescriptionFailed`] if
+    /// [RtcPeerConnection.setLocalDescription()][2] fails.
+    ///
+    /// [1]: https://w3.org/TR/webrtc/#dom-rtcpeerconnection-createanswer
+    /// [2]: https://w3.org/TR/webrtc/#dom-peerconnection-setlocaldescription
     pub async fn create_and_set_answer(&self) -> Result<String> {
         let peer: Rc<SysRtcPeerConnection> = Rc::clone(&self.peer);
 
@@ -569,10 +576,14 @@ impl RtcPeerConnection {
     ///
     /// # Errors
     ///
-    /// - [`RTCPeerConnectionError::CreateOfferFailed`] if fails to obtain SDP
-    ///   offer.
-    /// - [`RTCPeerConnectionError::SetLocalDescriptionFailed`] if fails to set
-    ///   obtained SDP offer as local description.
+    /// With [`RTCPeerConnectionError::CreateOfferFailed`] if
+    /// [RtcPeerConnection.createOffer()][1] fails.
+    ///
+    /// With [`RTCPeerConnectionError::SetLocalDescriptionFailed`] if
+    /// [RtcPeerConnection.setLocalDescription()][2] fails.
+    ///
+    /// [1]: https://w3.org/TR/webrtc/#dom-rtcpeerconnection-createoffer
+    /// [2]: https://w3.org/TR/webrtc/#dom-peerconnection-setlocaldescription
     pub async fn create_and_set_offer(&self) -> Result<String> {
         let peer: Rc<SysRtcPeerConnection> = Rc::clone(&self.peer);
 
@@ -603,8 +614,10 @@ impl RtcPeerConnection {
     ///
     /// # Errors
     ///
-    /// - [`RTCPeerConnectionError::SetRemoteDescriptionFailed`] if applying the
-    ///   supplied [SDP] as remote description fails.
+    /// With [`RTCPeerConnectionError::SetRemoteDescriptionFailed`] if
+    /// [RTCPeerConnection.setRemoteDescription()][1] fails.
+    ///
+    /// [1]: https://w3.org/TR/webrtc/#dom-peerconnection-setremotedescription
     pub async fn set_remote_description(&self, sdp: SdpType) -> Result<()> {
         let description = match sdp {
             SdpType::Offer(offer) => {
@@ -633,8 +646,8 @@ impl RtcPeerConnection {
     /// Creates new [`RtcRtpTransceiver`] (see [RTCRtpTransceiver][1])
     /// and adds it to the [set of this RTCPeerConnection's transceivers][2].
     ///
-    /// [1]: https://www.w3.org/TR/webrtc/#dom-rtcrtptransceiver
-    /// [2]: https://www.w3.org/TR/webrtc/#transceivers-set
+    /// [1]: https://w3.org/TR/webrtc/#dom-rtcrtptransceiver
+    /// [2]: https://w3.org/TR/webrtc/#transceivers-set
     pub fn add_transceiver(
         &self,
         kind: TransceiverKind,
@@ -649,8 +662,8 @@ impl RtcPeerConnection {
     /// Returns [`RtcRtpTransceiver`] (see [RTCRtpTransceiver][1]) from a
     /// [set of this RTCPeerConnection's transceivers][2] by provided `mid`.
     ///
-    /// [1]: https://www.w3.org/TR/webrtc/#dom-rtcrtptransceiver
-    /// [2]: https://www.w3.org/TR/webrtc/#transceivers-set
+    /// [1]: https://w3.org/TR/webrtc/#dom-rtcrtptransceiver
+    /// [2]: https://w3.org/TR/webrtc/#transceivers-set
     pub fn get_transceiver_by_mid(
         &self,
         mid: &str,
@@ -680,7 +693,7 @@ impl Drop for RtcPeerConnection {
     /// and [closes][1] the underlying
     /// [RTCPeerConnection][`SysRtcPeerConnection`].
     ///
-    /// [1]: https://www.w3.org/TR/webrtc/#dom-rtcpeerconnection-close
+    /// [1]: https://w3.org/TR/webrtc/#dom-rtcpeerconnection-close
     fn drop(&mut self) {
         self.on_track.borrow_mut().take();
         self.on_ice_candidate.borrow_mut().take();
@@ -693,7 +706,7 @@ impl Drop for RtcPeerConnection {
 /// Returns [RTCPeerConnection.connectionState][1] property of provided
 /// [`SysRtcPeerConnection`] using reflection.
 ///
-/// [1]: https://www.w3.org/TR/webrtc/#dom-peerconnection-connection-state
+/// [1]: https://w3.org/TR/webrtc/#dom-peerconnection-connection-state
 fn get_peer_connection_state(peer: &SysRtcPeerConnection) -> Option<String> {
     get_property_by_name(peer, "connectionState", |v| v.as_string())
 }
diff --git a/jason/src/peer/ice_server.rs b/jason/src/peer/ice_server.rs
index 5999d3b76..ae9847256 100644
--- a/jason/src/peer/ice_server.rs
+++ b/jason/src/peer/ice_server.rs
@@ -1,6 +1,6 @@
 //! Collection of [`RtcIceServer`][1]s.
 //!
-//! [1]: https://www.w3.org/TR/webrtc/#rtciceserver-dictionary
+//! [1]: https://w3.org/TR/webrtc/#rtciceserver-dictionary
 
 use std::ops::Deref;
 
@@ -11,7 +11,7 @@ use web_sys::RtcIceServer;
 
 /// Collection of [`RtcIceServer`]s (see [RTCIceServer][1]).
 ///
-/// [1]: https://www.w3.org/TR/webrtc/#rtciceserver-dictionary
+/// [1]: https://w3.org/TR/webrtc/#rtciceserver-dictionary
 pub struct RtcIceServers(JsArray);
 
 impl<I> From<I> for RtcIceServers
diff --git a/jason/src/peer/media/mod.rs b/jason/src/peer/media/mod.rs
index edf67ebac..d07304593 100644
--- a/jason/src/peer/media/mod.rs
+++ b/jason/src/peer/media/mod.rs
@@ -8,26 +8,24 @@ use std::{
 };
 
 use derive_more::Display;
-use futures::{future, future::Either, StreamExt};
+use futures::{channel::mpsc, future, future::Either, StreamExt};
 use medea_client_api_proto as proto;
 use medea_reactive::{DroppedError, ObservableCell};
 use proto::{Direction, PeerId, Track, TrackId};
 use tracerr::Traced;
 use wasm_bindgen_futures::{spawn_local, JsFuture};
-use web_sys::{
-    MediaStreamTrack, RtcRtpTransceiver, RtcRtpTransceiverDirection,
-};
+use web_sys::{RtcRtpTransceiver, RtcRtpTransceiverDirection};
 
 use crate::{
-    media::TrackConstraints,
+    media::{MediaStreamTrack, TrackConstraints},
+    peer::PeerEvent,
     utils::{delay_for, JsCaused, JsError},
 };
 
 use super::{
     conn::{RtcPeerConnection, TransceiverDirection, TransceiverKind},
-    stream::MediaStream,
+    stream::PeerMediaStream,
     stream_request::StreamRequest,
-    track::MediaTrack,
 };
 
 pub use self::mute_state::{MuteState, MuteStateTransition, StableMuteState};
@@ -35,31 +33,30 @@ pub use self::mute_state::{MuteState, MuteStateTransition, StableMuteState};
 /// Errors that may occur in [`MediaConnections`] storage.
 #[derive(Debug, Display, JsCaused)]
 pub enum MediaConnectionsError {
-    /// Occurs when the provided [`MediaTrack`] cannot be inserted into
+    /// Occurs when the provided [`MediaStreamTrack`] cannot be inserted into
     /// provided [`Sender`]s transceiver.
     #[display(fmt = "Failed to insert Track to a sender: {}", _0)]
     CouldNotInsertTrack(JsError),
 
-    /// Occurs when creates new [`Sender`] on not existed into a
-    /// [`RtcPeerConnection`] the [`RtcRtpTransceiver`].
+    /// Could not find [`RtcRtpTransceiver`] by `mid`.
     #[display(fmt = "Unable to find Transceiver with provided mid: {}", _0)]
     TransceiverNotFound(String),
 
-    /// Occurs when cannot get the "mid" from the [`Sender`].
+    /// Occurs when cannot get the `mid` from the [`Sender`].
     #[display(fmt = "Peer has senders without mid")]
     SendersWithoutMid,
 
-    /// Occurs when cannot get the "mid" from the [`Receiver`].
+    /// Occurs when cannot get the `mid` from the [`Receiver`].
     #[display(fmt = "Peer has receivers without mid")]
     ReceiversWithoutMid,
 
-    /// Occurs when inserted [`MediaStream`] dont have all necessary
-    /// [`MediaTrack`]s.
+    /// Occurs when inserted [`PeerMediaStream`] dont have all necessary
+    /// [`MediaStreamTrack`]s.
     #[display(fmt = "Provided stream does not have all necessary Tracks")]
     InvalidMediaStream,
 
-    /// Occurs when [`MediaTrack`] of inserted [`MediaStream`] does not satisfy
-    /// [`Sender`] constraints.
+    /// Occurs when [`MediaStreamTrack`] of inserted [`PeerMediaStream`] does
+    /// not satisfy [`Sender`] constraints.
     #[display(fmt = "Provided Track does not satisfy senders constraints")]
     InvalidMediaTrack,
 
@@ -73,7 +70,8 @@ pub enum MediaConnectionsError {
                      MuteState")]
     MuteStateTransitsIntoOppositeState,
 
-    /// Invalid [`medea_client_api_proto::TrackPatch`] for [`MediaTrack`].
+    /// Invalid [`medea_client_api_proto::TrackPatch`] for
+    /// [`MediaStreamTrack`].
     #[display(fmt = "Invalid TrackPatch for Track with {} ID.", _0)]
     InvalidTrackPatch(TrackId),
 }
@@ -89,14 +87,20 @@ type Result<T> = std::result::Result<T, Traced<MediaConnectionsError>>;
 
 /// Actual data of [`MediaConnections`] storage.
 struct InnerMediaConnections {
+    /// [`PeerId`] of peer that owns this [`MediaConnections`].
+    peer_id: PeerId,
+
     /// Ref to parent [`RtcPeerConnection`]. Used to generate transceivers for
     /// [`Sender`]s and [`Receiver`]s.
     peer: Rc<RtcPeerConnection>,
 
-    /// [`MediaTrack`] to its [`Sender`].
+    /// [`PeerEvent`]s tx.
+    peer_events_sender: mpsc::UnboundedSender<PeerEvent>,
+
+    /// [`TrackId`] to its [`Sender`].
     senders: HashMap<TrackId, Rc<Sender>>,
 
-    /// [`MediaTrack`] to its [`Receiver`].
+    /// [`TrackId`] to its [`Receiver`].
     receivers: HashMap<TrackId, Receiver>,
 }
 
@@ -117,9 +121,15 @@ impl MediaConnections {
     /// Instantiates new [`MediaConnections`] storage for a given
     /// [`RtcPeerConnection`].
     #[inline]
-    pub fn new(peer: Rc<RtcPeerConnection>) -> Self {
+    pub fn new(
+        peer_id: PeerId,
+        peer: Rc<RtcPeerConnection>,
+        peer_events_sender: mpsc::UnboundedSender<PeerEvent>,
+    ) -> Self {
         Self(RefCell::new(InnerMediaConnections {
+            peer_id,
             peer,
+            peer_events_sender,
             senders: HashMap::new(),
             receivers: HashMap::new(),
         }))
@@ -150,27 +160,27 @@ impl MediaConnections {
         true
     }
 
-    /// Returns `true` if all [`MediaTrack`]s of all [`Sender`]s with
+    /// Returns `true` if all [`Sender`]s with
     /// [`TransceiverKind::Audio`] are enabled or `false` otherwise.
     pub fn is_send_audio_enabled(&self) -> bool {
         self.0
             .borrow()
             .iter_senders_with_kind(TransceiverKind::Audio)
-            .find(|s| s.is_track_muted())
+            .find(|s| s.is_muted())
             .is_none()
     }
 
-    /// Returns `true` if all [`MediaTrack`]s of all [`Sender`]s with
+    /// Returns `true` if all [`Sender`]s with
     /// [`TransceiverKind::Video`] are enabled or `false` otherwise.
     pub fn is_send_video_enabled(&self) -> bool {
         self.0
             .borrow()
             .iter_senders_with_kind(TransceiverKind::Video)
-            .find(|s| s.is_track_muted())
+            .find(|s| s.is_muted())
             .is_none()
     }
 
-    /// Returns mapping from a [`MediaTrack`] ID to a `mid` of
+    /// Returns mapping from a [`MediaStreamTrack`] ID to a `mid` of
     /// this track's [`RtcRtpTransceiver`].
     ///
     /// # Errors
@@ -216,7 +226,9 @@ impl MediaConnections {
     ///
     /// # Errors
     ///
-    /// Errors if creating new [`Sender`] or [`Receiver`] fails.
+    /// With [`MediaConnectionsError::TransceiverNotFound`] if could not create
+    /// new [`Sender`] cause transceiver with specified `mid` does not
+    /// exist.
     // TODO: Doesnt really updates anything, but only generates new senders
     //       and receivers atm.
     pub fn update_tracks<I: IntoIterator<Item = Track>>(
@@ -228,9 +240,11 @@ impl MediaConnections {
             match track.direction {
                 Direction::Send { mid, .. } => {
                     let sndr = Sender::new(
+                        inner.peer_id,
                         track.id,
                         track.media_type.into(),
                         &inner.peer,
+                        inner.peer_events_sender.clone(),
                         mid,
                         track.is_muted.into(),
                     )
@@ -240,7 +254,7 @@ impl MediaConnections {
                 Direction::Recv { sender, mid } => {
                     let recv = Receiver::new(
                         track.id,
-                        track.media_type.into(),
+                        &(track.media_type.into()),
                         sender,
                         &inner.peer,
                         mid,
@@ -258,16 +272,16 @@ impl MediaConnections {
     /// # Errors
     ///
     /// Errors with [`MediaConnectionsError::InvalidTrackPatch`] if
-    /// [`MediaTrack`] with ID from [`proto::TrackPatch`] doesn't exist.
+    /// [`MediaStreamTrack`] with ID from [`proto::TrackPatch`] doesn't exist.
     pub fn update_senders(&self, tracks: Vec<proto::TrackPatch>) -> Result<()> {
         for track_proto in tracks {
-            let track =
+            let sender =
                 self.get_sender_by_id(track_proto.id).ok_or_else(|| {
                     tracerr::new!(MediaConnectionsError::InvalidTrackPatch(
                         track_proto.id
                     ))
                 })?;
-            track.update(&track_proto);
+            sender.update(&track_proto);
         }
         Ok(())
     }
@@ -276,42 +290,55 @@ impl MediaConnections {
     pub fn get_stream_request(&self) -> Option<StreamRequest> {
         let mut stream_request = None;
         for sender in self.0.borrow().senders.values() {
-            stream_request
-                .get_or_insert_with(StreamRequest::default)
-                .add_track_request(sender.track_id, sender.caps.clone());
+            if let MuteState::Stable(StableMuteState::NotMuted) =
+                sender.mute_state.get()
+            {
+                stream_request
+                    .get_or_insert_with(StreamRequest::default)
+                    .add_track_request(sender.track_id, sender.caps.clone());
+            }
         }
         stream_request
     }
 
-    /// Inserts tracks from a provided [`MediaStream`] into [`Sender`]s
+    /// Inserts tracks from a provided [`PeerMediaStream`] into [`Sender`]s
     /// based on track IDs.
     ///
-    /// Enables or disables tracks in provided [`MediaStream`] based on current
-    /// media connections state.
-    ///
-    /// Provided [`MediaStream`] must have all required [`MediaTrack`]s.
-    /// [`MediaTrack`]s are inserted into [`Sender`]'s [`RtcRtpTransceiver`]s
-    /// via [`replaceTrack` method][1], changing its direction to `sendonly`.
+    /// Provided [`PeerMediaStream`] must have all required
+    /// [`MediaStreamTrack`]s. [`MediaStreamTrack`]s are inserted into
+    /// [`Sender`]'s [`RtcRtpTransceiver`]s via [`replaceTrack` method][1],
+    /// changing its direction to `sendonly`.
     ///
     /// # Errors
     ///
-    /// - [`MediaConnectionsError::InvalidMediaTrack`] if some [`MediaTrack`]
-    ///   doesn't satisfy [`Sender`]'s [`TrackConstraints`].
-    /// - [`MediaConnectionsError::InvalidMediaStream`] if [`MediaStream`]
-    ///   doesn't contain [`MediaTrack`] for some [`Sender`].
+    /// With [`MediaConnectionsError::InvalidMediaStream`] if provided
+    /// [`PeerMediaStream`] doesn't contain required [`MediaStreamTrack`].
+    ///
+    /// With [`MediaConnectionsError::InvalidMediaTrack`] if some
+    /// [`MediaStreamTrack`] cannot be inserted into associated [`Sender`]
+    /// because of constraints mismatch.
+    ///
+    /// With [`MediaConnectionsError::CouldNotInsertTrack`] if some
+    /// [`MediaStreamTrack`] from provided [`PeerMediaStream`] cannot be
+    /// inserted into provided [`Sender`]s transceiver.
     ///
-    /// [1]: https://www.w3.org/TR/webrtc/#dom-rtcrtpsender-replacetrack
+    /// [1]: https://w3.org/TR/webrtc/#dom-rtcrtpsender-replacetrack
     pub async fn insert_local_stream(
         &self,
-        stream: &MediaStream,
+        stream: &PeerMediaStream,
     ) -> Result<()> {
         let inner = self.0.borrow();
 
         // Build sender to track pairs to catch errors before inserting.
         let mut sender_and_track = Vec::with_capacity(inner.senders.len());
         for sender in inner.senders.values() {
+            // skip senders that are not NotMuted
+            if !sender.is_not_muted() {
+                continue;
+            }
+
             if let Some(track) = stream.get_track_by_id(sender.track_id) {
-                if sender.caps.satisfies(&track.track()) {
+                if sender.caps.satisfies(&track) {
                     sender_and_track.push((sender, track));
                 } else {
                     return Err(tracerr::new!(
@@ -350,11 +377,6 @@ impl MediaConnections {
             for receiver in &mut inner.receivers.values_mut() {
                 if let Some(recv_mid) = &receiver.mid() {
                     if recv_mid == &mid {
-                        let track = MediaTrack::new(
-                            receiver.track_id,
-                            track,
-                            receiver.caps.clone(),
-                        );
                         receiver.transceiver.replace(transceiver);
                         receiver.track.replace(track);
                         return Some(receiver.sender_id);
@@ -365,40 +387,44 @@ impl MediaConnections {
         None
     }
 
-    /// Returns [`MediaTrack`]s being received from a specified sender,
-    /// but only if all receiving [`MediaTrack`]s are present already.
-    pub fn get_tracks_by_sender(
+    /// Returns [`MediaStreamTrack`]s being received from a specified sender,
+    /// but only if all receiving [`MediaStreamTrack`]s are present already.
+    pub fn get_stream_by_sender(
         &self,
         sender_id: PeerId,
-    ) -> Option<Vec<Rc<MediaTrack>>> {
-        let s = self.0.borrow();
-        let mut tracks: Vec<Rc<MediaTrack>> = Vec::new();
-        for rcv in s.receivers.values() {
+    ) -> Option<PeerMediaStream> {
+        let inner = self.0.borrow();
+        let stream = PeerMediaStream::new();
+        for rcv in inner.receivers.values() {
             if rcv.sender_id == sender_id {
                 match rcv.track() {
                     None => return None,
-                    Some(ref t) => tracks.push(Rc::clone(t)),
+                    Some(ref track) => {
+                        stream.add_track(rcv.track_id, track.clone());
+                    }
                 }
             }
         }
-        Some(tracks)
+        Some(stream)
     }
 
-    /// Returns [`MediaTrack`] by its [`TrackId`] and [`TransceiverDirection`].
+    /// Returns [`MediaStreamTrack`] by its [`TrackId`] and
+    /// [`TransceiverDirection`].
     pub fn get_track_by_id_and_direction(
         &self,
-        direction: TransceiverDirection,
         id: TrackId,
-    ) -> Option<Rc<MediaTrack>> {
+        direction: TransceiverDirection,
+    ) -> Option<MediaStreamTrack> {
         let inner = self.0.borrow();
         match direction {
             TransceiverDirection::Sendonly => inner
                 .senders
                 .get(&id)
                 .and_then(|sndr| sndr.track.borrow().clone()),
-            TransceiverDirection::Recvonly => {
-                inner.receivers.get(&id).and_then(|recv| recv.track.clone())
-            }
+            TransceiverDirection::Recvonly => inner
+                .receivers
+                .get(&id)
+                .and_then(|recvr| recvr.track.clone()),
         }
     }
 
@@ -408,9 +434,9 @@ impl MediaConnections {
         self.0.borrow().senders.get(&id).cloned()
     }
 
-    /// Returns [`MediaTrack`] from this [`MediaConnections`] by its
+    /// Returns [`MediaStreamTrack`] from this [`MediaConnections`] by its
     /// [`TrackId`].
-    pub fn get_track_by_id(&self, id: TrackId) -> Option<Rc<MediaTrack>> {
+    pub fn get_track_by_id(&self, id: TrackId) -> Option<MediaStreamTrack> {
         let inner = self.0.borrow();
         inner
             .senders
@@ -422,12 +448,12 @@ impl MediaConnections {
     }
 }
 
-/// Representation of a local [`MediaTrack`] that is being sent to some remote
-/// peer.
+/// Representation of a local [`MediaStreamTrack`] that is being sent to some
+/// remote peer.
 pub struct Sender {
     track_id: TrackId,
     caps: TrackConstraints,
-    track: RefCell<Option<Rc<MediaTrack>>>,
+    track: RefCell<Option<MediaStreamTrack>>,
     transceiver: RtcRtpTransceiver,
     mute_state: ObservableCell<MuteState>,
 }
@@ -438,9 +464,11 @@ impl Sender {
     /// from a provided [`RtcPeerConnection`]. Errors if [`RtcRtpTransceiver`]
     /// lookup fails.
     fn new(
+        peer_id: PeerId,
         track_id: TrackId,
         caps: TrackConstraints,
         peer: &RtcPeerConnection,
+        peer_events_sender: mpsc::UnboundedSender<PeerEvent>,
         mid: Option<String>,
         mute_state: StableMuteState,
     ) -> Result<Rc<Self>> {
@@ -454,7 +482,8 @@ impl Sender {
         };
 
         let mute_state = ObservableCell::new(mute_state.into());
-        let mut subscription = mute_state.subscribe();
+        // we dont care about initial state, cause transceiver is inactive atm
+        let mut mute_state_changes = mute_state.subscribe().skip(1);
         let this = Rc::new(Self {
             track_id,
             caps,
@@ -463,15 +492,30 @@ impl Sender {
             mute_state,
         });
 
-        // TODO: remove when refactor muting to dropping tracks.
         let weak_this = Rc::downgrade(&this);
         spawn_local(async move {
-            while let Some(mute_state_update) = subscription.next().await {
+            while let Some(mute_state) = mute_state_changes.next().await {
                 if let Some(this) = weak_this.upgrade() {
-                    match mute_state_update {
+                    match mute_state {
                         MuteState::Stable(stable) => {
-                            if let Some(track) = this.track.borrow().as_ref() {
-                                track.set_enabled_by_mute_state(stable);
+                            match stable {
+                                StableMuteState::NotMuted => {
+                                    let _ = peer_events_sender.unbounded_send(
+                                        PeerEvent::NewLocalStreamRequired {
+                                            peer_id,
+                                        },
+                                    );
+                                }
+                                StableMuteState::Muted => {
+                                    // cannot fail
+                                    this.track.borrow_mut().take();
+                                    let _ = JsFuture::from(
+                                        this.transceiver
+                                            .sender()
+                                            .replace_track(None),
+                                    )
+                                    .await;
+                                }
                             }
                         }
                         MuteState::Transition(_) => {
@@ -527,47 +571,57 @@ impl Sender {
         self.mute_state.get()
     }
 
-    /// Inserts provided [`MediaTrack`] into provided [`Sender`]s transceiver
-    /// and enables transceivers sender by changing its direction to `sendonly`.
+    /// Inserts provided [`MediaStreamTrack`] into provided [`Sender`]s
+    /// transceiver and enables transceivers sender by changing its
+    /// direction to `sendonly`.
     ///
-    /// [1]: https://www.w3.org/TR/webrtc/#dom-rtcrtpsender-replacetrack
+    /// [1]: https://w3.org/TR/webrtc/#dom-rtcrtpsender-replacetrack
     async fn insert_and_enable_track(
         sender: Rc<Self>,
-        track: Rc<MediaTrack>,
+        new_track: MediaStreamTrack,
     ) -> Result<()> {
-        JsFuture::from(
+        // no-op if we try to insert same track
+        if let Some(current_track) = sender.track.borrow().as_ref() {
+            if new_track.id() == current_track.id() {
+                return Ok(());
+            }
+        }
+
+        // no-op if transceiver is not NotMuted
+        if let MuteState::Stable(StableMuteState::NotMuted) =
+            sender.mute_state()
+        {
+            JsFuture::from(
+                sender
+                    .transceiver
+                    .sender()
+                    .replace_track(Some(new_track.as_ref())),
+            )
+            .await
+            .map_err(Into::into)
+            .map_err(MediaConnectionsError::CouldNotInsertTrack)
+            .map_err(tracerr::wrap!())?;
+
+            sender.track.borrow_mut().replace(new_track);
+
             sender
                 .transceiver
-                .sender()
-                .replace_track(Some(track.track())),
-        )
-        .await
-        .map_err(Into::into)
-        .map_err(MediaConnectionsError::CouldNotInsertTrack)
-        .map_err(tracerr::wrap!())?;
-
-        sender
-            .transceiver
-            .set_direction(RtcRtpTransceiverDirection::Sendonly);
-        // TODO: this is temporary disabled, until we resolve case of muting
-        //       senders, that were added after muting room.
-        //       (instrumentisto/medea#85)
-
-        //        let stable_mute_state = match sender.mute_state() {
-        //            MuteState::Stable(stable) => stable,
-        //            MuteState::Transition(transition) =>
-        // transition.into_inner(),        };
-        //        track.set_enabled_by_mute_state(stable_mute_state);
-        sender.track.borrow_mut().replace(track);
+                .set_direction(RtcRtpTransceiverDirection::Sendonly);
+        }
 
         Ok(())
     }
 
-    /// Checks that [`Sender`] is in [`MuteState::NotMuted`].
-    pub fn is_track_muted(&self) -> bool {
+    /// Checks whether [`Sender`] is in [`MuteState::Muted`].
+    pub fn is_muted(&self) -> bool {
         self.mute_state.get() == StableMuteState::Muted.into()
     }
 
+    /// Checks whether [`Sender`] is in [`MuteState::NotMuted`].
+    pub fn is_not_muted(&self) -> bool {
+        self.mute_state.get() == StableMuteState::NotMuted.into()
+    }
+
     /// Sets current [`MuteState`] to [`MuteState::Transition`].
     pub fn mute_state_transition_to(&self, desired_state: StableMuteState) {
         let current_mute_state = self.mute_state.get();
@@ -596,13 +650,13 @@ impl Sender {
                 match state {
                     MuteState::Transition(_) => continue,
                     MuteState::Stable(s) => {
-                        if s == desired_state {
-                            return Ok(());
+                        return if s == desired_state {
+                            Ok(())
                         } else {
-                            return Err(tracerr::new!(
+                            Err(tracerr::new!(
                                 MediaConnectionsError::
                                 MuteStateTransitsIntoOppositeState
-                            ));
+                            ))
                         }
                     }
                 }
@@ -611,7 +665,8 @@ impl Sender {
         }
     }
 
-    /// Updates this [`Track`] basing on the provided [`proto::TrackPatch`].
+    /// Updates this [`Sender`]s tracks based on the provided
+    /// [`proto::TrackPatch`].
     pub fn update(&self, track: &proto::TrackPatch) {
         if track.id != self.track_id {
             return;
@@ -637,37 +692,36 @@ impl Sender {
     }
 }
 
-/// Representation of a remote [`MediaTrack`] that is being received from some
-/// remote peer. It may have two states: `waiting` and `receiving`.
+/// Representation of a remote [`MediaStreamTrack`] that is being received from
+/// some remote peer. It may have two states: `waiting` and `receiving`.
 ///
-/// We can save related [`RtcRtpTransceiver`] and the actual [`MediaTrack`]
-/// only when [`MediaTrack`] data arrives.
+/// We can save related [`RtcRtpTransceiver`] and the actual
+/// [`MediaStreamTrack`] only when [`MediaStreamTrack`] data arrives.
 pub struct Receiver {
     track_id: TrackId,
-    caps: TrackConstraints,
     sender_id: PeerId,
     transceiver: Option<RtcRtpTransceiver>,
     mid: Option<String>,
-    track: Option<Rc<MediaTrack>>,
+    track: Option<MediaStreamTrack>,
 }
 
 impl Receiver {
     /// Creates new [`RtcRtpTransceiver`] if provided `mid` is `None`,
     /// otherwise creates [`Receiver`] without [`RtcRtpTransceiver`]. It will be
-    /// injected when [`MediaTrack`] arrives.
+    /// injected when [`MediaStreamTrack`] arrives.
     ///
     /// `track` field in the created [`Receiver`] will be `None`,
-    /// since [`Receiver`] must be created before the actual [`MediaTrack`]
-    /// data arrives.
+    /// since [`Receiver`] must be created before the actual
+    /// [`MediaStreamTrack`] data arrives.
     #[inline]
     fn new(
         track_id: TrackId,
-        caps: TrackConstraints,
+        caps: &TrackConstraints,
         sender_id: PeerId,
         peer: &RtcPeerConnection,
         mid: Option<String>,
     ) -> Self {
-        let kind = TransceiverKind::from(&caps);
+        let kind = TransceiverKind::from(caps);
         let transceiver = match mid {
             None => {
                 Some(peer.add_transceiver(kind, TransceiverDirection::Recvonly))
@@ -676,7 +730,6 @@ impl Receiver {
         };
         Self {
             track_id,
-            caps,
             sender_id,
             transceiver,
             mid,
@@ -684,10 +737,10 @@ impl Receiver {
         }
     }
 
-    /// Returns associated [`MediaTrack`] with this [`Receiver`], if any.
+    /// Returns associated [`MediaStreamTrack`] with this [`Receiver`], if any.
     #[inline]
-    pub(crate) fn track(&self) -> Option<&Rc<MediaTrack>> {
-        self.track.as_ref()
+    pub(crate) fn track(&self) -> Option<MediaStreamTrack> {
+        self.track.as_ref().cloned()
     }
 
     /// Returns `mid` of this [`Receiver`].
diff --git a/jason/src/peer/mod.rs b/jason/src/peer/mod.rs
index 35c388852..c329b4cd2 100644
--- a/jason/src/peer/mod.rs
+++ b/jason/src/peer/mod.rs
@@ -1,6 +1,6 @@
 //! Adapters to [RTCPeerConnection][1] and related objects.
 //!
-//! [1]: https://www.w3.org/TR/webrtc/#rtcpeerconnection-interface
+//! [1]: https://w3.org/TR/webrtc/#rtcpeerconnection-interface
 
 mod conn;
 mod ice_server;
@@ -9,7 +9,6 @@ mod repo;
 mod stats;
 mod stream;
 mod stream_request;
-mod track;
 
 use std::{
     cell::RefCell,
@@ -27,13 +26,12 @@ use medea_client_api_proto::{
 };
 use medea_macro::dispatchable;
 use tracerr::Traced;
-use web_sys::{
-    MediaStream as SysMediaStream, RtcIceConnectionState, RtcTrackEvent,
-};
+use web_sys::{RtcIceConnectionState, RtcTrackEvent};
 
 use crate::{
-    media::{MediaManager, MediaManagerError},
+    media::{MediaManager, MediaManagerError, MediaStream},
     utils::{console_error, JasonError, JsCaused, JsError},
+    MediaStreamSettings,
 };
 
 #[cfg(feature = "mockable")]
@@ -51,9 +49,8 @@ pub use self::{
         MuteStateTransition, Sender, StableMuteState,
     },
     stats::RtcStats,
-    stream::{MediaStream, MediaStreamHandle},
+    stream::{PeerMediaStream, RemoteMediaStream},
     stream_request::{SimpleStreamRequest, StreamRequest, StreamRequestError},
-    track::MediaTrack,
 };
 
 /// Errors that may occur in [RTCPeerConnection][1].
@@ -72,7 +69,7 @@ pub enum PeerError {
     /// Errors that may occur during signaling between this and remote
     /// [RTCPeerConnection][1] and event handlers setting errors.
     ///
-    /// [1]: https://w3.org/TR/webrtc/#dom-rtcpeerconnection.
+    /// [1]: https://w3.org/TR/webrtc/#dom-rtcpeerconnection
     #[display(fmt = "{}", _0)]
     RtcPeerConnection(#[js(cause)] RTCPeerConnectionError),
 
@@ -125,7 +122,7 @@ pub enum PeerEvent {
         sender_id: Id,
 
         /// Received [`MediaStream`].
-        remote_stream: MediaStream,
+        remote_stream: PeerMediaStream,
     },
 
     /// [`RtcPeerConnection`] sent new local stream to remote members.
@@ -174,6 +171,12 @@ pub enum PeerEvent {
         /// [`RtcStats`] of this [`PeerConnection`].
         stats: RtcStats,
     },
+
+    /// [`RtcPeerConnection`] is signalling that it [`MediaStream`]
+    NewLocalStreamRequired {
+        /// ID of the [`PeerConnection`] that requested new media stream.
+        peer_id: Id,
+    },
 }
 
 /// High-level wrapper around [`RtcPeerConnection`].
@@ -236,8 +239,11 @@ impl PeerConnection {
             RtcPeerConnection::new(ice_servers, is_force_relayed)
                 .map_err(tracerr::map_from_and_wrap!())?,
         );
-        let media_connections =
-            Rc::new(MediaConnections::new(Rc::clone(&peer)));
+        let media_connections = Rc::new(MediaConnections::new(
+            id,
+            Rc::clone(&peer),
+            peer_events_sender.clone(),
+        ));
 
         let peer = Self {
             id,
@@ -298,8 +304,8 @@ impl PeerConnection {
         Ok(peer)
     }
 
-    /// Filters already sent [`RtcStat`]s and send only new [`RtcStat`]s from
-    /// the provided [`RtcStats`].
+    /// Filters out already sent stats, and send new statss from
+    /// provided [`RtcStats`].
     pub fn send_peer_stats(&self, stats: RtcStats) {
         let mut stats_cache = self.sent_stats_cache.borrow_mut();
         let stats = RtcStats(
@@ -359,7 +365,7 @@ impl PeerConnection {
             .map_err(tracerr::map_from_and_wrap!())
     }
 
-    /// Returns `true` if all [`MediaTrack`]s of this [`PeerConnection`] is in
+    /// Returns `true` if all [`Sender`]s of this [`PeerConnection`] is in
     /// the provided `mute_state`.
     #[inline]
     pub fn is_all_senders_in_mute_state(
@@ -383,7 +389,7 @@ impl PeerConnection {
     /// # Errors
     ///
     /// Errors with [`MediaConnectionsError::InvalidTrackPatch`] if
-    /// [`MediaTrack`] with ID from [`proto::TrackPatch`] doesn't exist.
+    /// provided [`proto::TrackPatch`] contains unknown ID.
     pub fn update_senders(&self, tracks: Vec<proto::TrackPatch>) -> Result<()> {
         Ok(self
             .media_connections
@@ -420,16 +426,16 @@ impl PeerConnection {
         sender: &mpsc::UnboundedSender<PeerEvent>,
         ice_connection_state: RtcIceConnectionState,
     ) {
-        use RtcIceConnectionState::*;
+        use RtcIceConnectionState as S;
 
         let ice_connection_state = match ice_connection_state {
-            New => IceConnectionState::New,
-            Checking => IceConnectionState::Checking,
-            Connected => IceConnectionState::Connected,
-            Completed => IceConnectionState::Completed,
-            Failed => IceConnectionState::Failed,
-            Disconnected => IceConnectionState::Disconnected,
-            Closed => IceConnectionState::Closed,
+            S::New => IceConnectionState::New,
+            S::Checking => IceConnectionState::Checking,
+            S::Connected => IceConnectionState::Connected,
+            S::Completed => IceConnectionState::Completed,
+            S::Failed => IceConnectionState::Failed,
+            S::Disconnected => IceConnectionState::Disconnected,
+            S::Closed => IceConnectionState::Closed,
             _ => {
                 console_error("Unknown ICE connection state");
                 return;
@@ -456,17 +462,17 @@ impl PeerConnection {
         let track = track_event.track();
 
         if let Some(sender_id) =
-            media_connections.add_remote_track(transceiver, track)
+            media_connections.add_remote_track(transceiver, track.into())
         {
-            if let Some(tracks) =
-                media_connections.get_tracks_by_sender(sender_id)
+            if let Some(remote_stream) =
+                media_connections.get_stream_by_sender(sender_id)
             {
                 // got all tracks from this sender, so emit
                 // PeerEvent::NewRemoteStream
                 let _ = sender.unbounded_send(PeerEvent::NewRemoteStream {
                     peer_id: id,
                     sender_id,
-                    remote_stream: MediaStream::from_tracks(tracks),
+                    remote_stream,
                 });
             };
         } else {
@@ -504,7 +510,7 @@ impl PeerConnection {
     /// local description if offerer, and remote if answerer.
     ///
     /// [1]: https://tools.ietf.org/html/rfc4566#section-5.14
-    /// [2]: https://www.w3.org/TR/webrtc/#rtcrtptransceiver-interface
+    /// [2]: https://w3.org/TR/webrtc/#rtcrtptransceiver-interface
     #[inline]
     pub fn get_mids(&self) -> Result<HashMap<TrackId, String>> {
         let mids = self
@@ -515,26 +521,32 @@ impl PeerConnection {
         Ok(mids)
     }
 
-    /// Sync provided tracks creating all required `Sender`s and
-    /// `Receiver`s, request local stream if required, get, set and return
-    /// SDP offer.
+    /// Syncs provided tracks creating all required `Sender`s and `Receiver`s,
+    /// request local stream if required, get, set and return SDP offer.
     ///
     /// # Errors
     ///
-    /// When:
-    /// - creating new [`Sender`] or [`Receiver`] fails;
-    /// - inserting or creating `local_stream` fails;
-    /// - creating or setting SDP offer fails.
+    /// With [`MediaConnectionsError::TransceiverNotFound`] if cannot find
+    /// transceiver by `mid`.
+    ///
+    /// With [`RTCPeerConnectionError::CreateOfferFailed`] if
+    /// [RtcPeerConnection.createOffer()][1] fails.
+    ///
+    /// With [`RTCPeerConnectionError::SetLocalDescriptionFailed`] if
+    /// [RtcPeerConnection.setLocalDescription()][2] fails.
+    ///
+    /// [1]: https://w3.org/TR/webrtc/#dom-rtcpeerconnection-createoffer
+    /// [2]: https://w3.org/TR/webrtc/#dom-peerconnection-setlocaldescription
     pub async fn get_offer(
         &self,
         tracks: Vec<Track>,
-        local_stream: Option<&SysMediaStream>,
+        local_stream: Option<MediaStreamSettings>,
     ) -> Result<String> {
         self.media_connections
             .update_tracks(tracks)
             .map_err(tracerr::map_from_and_wrap!())?;
 
-        self.insert_local_stream(local_stream)
+        self.update_local_stream(local_stream)
             .await
             .map_err(tracerr::wrap!())?;
 
@@ -547,26 +559,6 @@ impl PeerConnection {
         Ok(offer)
     }
 
-    /// Replaces local stream in the underlying [RTCPeerConnection][1]
-    /// with a provided [MediaStream][2] if its have all required tracks.
-    ///
-    /// # Errors
-    ///
-    /// When inserting [MediaStream][2] into underlying [RTCPeerConnection][1]
-    /// fails.
-    ///
-    /// [1]: https://w3.org/TR/webrtc/#rtcpeerconnection-interface
-    /// [2]: https://w3.org/TR/mediacapture-streams/#mediastream
-    #[inline]
-    pub async fn inject_local_stream(
-        &self,
-        local_stream: &SysMediaStream,
-    ) -> Result<()> {
-        self.insert_local_stream(Some(local_stream))
-            .await
-            .map_err(tracerr::wrap!())
-    }
-
     /// Inserts provided [MediaStream][1] into underlying [RTCPeerConnection][2]
     /// if it has all required tracks.
     /// Requests local stream from [`MediaManager`] if no stream was provided.
@@ -575,47 +567,62 @@ impl PeerConnection {
     ///
     /// # Errors
     ///
-    /// When:
-    /// - requesting local stream from [`MediaManager`] fails;
-    /// - inserting [MediaStream][1] into underlying [RTCPeerConnection][2]
-    ///   fails.
+    /// With [`StreamRequestError`] if current state of peer's [`Sender`]s
+    /// cannot be represented as [`SimpleStreamRequest`] (max 1 audio [`Sender`]
+    /// and max 1 video [`Sender`]), or [`MediaStream`] requested from
+    /// [`MediaManager`] does not satisfy [`Sender`]s constraints.
+    ///
+    /// With [`StreamRequestError::ExpectedAudioTracks`] or
+    /// [`StreamRequestError::ExpectedVideoTracks`] if provided
+    /// [`MediaStreamSettings`] are incompatible with this peer [`Sender`]s
+    /// constraints.
+    ///
+    /// With [`MediaManagerError::GetUserMediaFailed`] or
+    /// [`MediaManagerError::GetDisplayMediaFailed`] if corresponding request to
+    /// UA failed.
+    ///
+    /// With [`MediaConnectionsError::InvalidMediaStream`],
+    /// [`MediaConnectionsError::InvalidMediaTrack`] or
+    /// [`MediaConnectionsError::CouldNotInsertTrack`] if [`MediaStream`] cannot
+    /// be inserted into peer's [`Sender`]s.
     ///
     /// [1]: https://w3.org/TR/mediacapture-streams/#mediastream
     /// [2]: https://w3.org/TR/webrtc/#rtcpeerconnection-interface
-    async fn insert_local_stream(
+    pub async fn update_local_stream(
         &self,
-        local_stream: Option<&SysMediaStream>,
+        local_constraints: Option<MediaStreamSettings>,
     ) -> Result<()> {
         if let Some(request) = self.media_connections.get_stream_request() {
-            let caps = SimpleStreamRequest::try_from(request)
+            let mut required_caps = SimpleStreamRequest::try_from(request)
                 .map_err(tracerr::from_and_wrap!())?;
-            let (stream, is_new_stream) = if let Some(stream) = local_stream {
-                (
-                    caps.parse_stream(stream)
-                        .map_err(tracerr::map_from_and_wrap!())?,
-                    false,
-                )
-            } else {
-                let (stream, is_new) = self
-                    .media_manager
-                    .get_stream(&caps)
-                    .await
-                    .map_err(tracerr::map_from_and_wrap!())?;
-                (
-                    caps.parse_stream(&stream)
-                        .map_err(tracerr::map_from_and_wrap!())?,
-                    is_new,
-                )
+
+            let used_caps: MediaStreamSettings = match local_constraints {
+                None => (&required_caps).into(),
+                Some(local_constraints) => {
+                    required_caps
+                        .merge(local_constraints)
+                        .map_err(tracerr::map_from_and_wrap!())?;
+                    (&required_caps).into()
+                }
             };
+            let (media_stream, is_new_stream) = self
+                .media_manager
+                .get_stream(used_caps)
+                .await
+                .map_err(tracerr::map_from_and_wrap!())?;
+            let peer_stream = required_caps
+                .parse_stream(media_stream.clone())
+                .map_err(tracerr::map_from_and_wrap!())?;
             self.media_connections
-                .insert_local_stream(&stream)
+                .insert_local_stream(&peer_stream)
                 .await
                 .map_err(tracerr::map_from_and_wrap!())?;
+
             if is_new_stream {
                 let _ = self.peer_events_sender.unbounded_send(
                     PeerEvent::NewLocalStream {
                         peer_id: self.id,
-                        local_stream: stream,
+                        local_stream: media_stream,
                     },
                 );
             }
@@ -627,9 +634,11 @@ impl PeerConnection {
     ///
     /// # Errors
     ///
-    /// If setting given SDP `answer` as remote description fails.
+    /// With [`RTCPeerConnectionError::SetRemoteDescriptionFailed`] if
+    /// [RTCPeerConnection.setRemoteDescription()][2] fails.
     ///
-    /// [1]: https://www.w3.org/TR/webrtc/#rtcpeerconnection-interface
+    /// [1]: https://w3.org/TR/webrtc/#rtcpeerconnection-interface
+    /// [2]: https://w3.org/TR/webrtc/#dom-peerconnection-setremotedescription
     pub async fn set_remote_answer(&self, answer: String) -> Result<()> {
         self.set_remote_description(SdpType::Answer(answer))
             .await
@@ -638,7 +647,13 @@ impl PeerConnection {
 
     /// Updates underlying [RTCPeerConnection][1]'s remote SDP from offer.
     ///
-    /// [1]: https://www.w3.org/TR/webrtc/#rtcpeerconnection-interface
+    /// # Errors
+    ///
+    /// With [`RTCPeerConnectionError::SetRemoteDescriptionFailed`] if
+    /// [RTCPeerConnection.setRemoteDescription()][2] fails.
+    ///
+    /// [1]: https://w3.org/TR/webrtc/#rtcpeerconnection-interface
+    /// [2]: https://w3.org/TR/webrtc/#dom-peerconnection-setremotedescription
     async fn set_remote_offer(&self, offer: String) -> Result<()> {
         self.set_remote_description(SdpType::Offer(offer))
             .await
@@ -648,7 +663,18 @@ impl PeerConnection {
     /// Updates underlying [RTCPeerConnection][1]'s remote SDP with given
     /// description.
     ///
-    /// [1]: https://www.w3.org/TR/webrtc/#rtcpeerconnection-interface
+    /// # Errors
+    ///
+    /// With [`RTCPeerConnectionError::SetRemoteDescriptionFailed`] if
+    /// [RTCPeerConnection.setRemoteDescription()][2] fails.
+    ///
+    /// With [`RTCPeerConnectionError::AddIceCandidateFailed`] if
+    /// [RtcPeerConnection.addIceCandidate()][3] fails when adding buffered ICE
+    /// candidates.
+    ///
+    /// [1]: https://w3.org/TR/webrtc/#rtcpeerconnection-interface
+    /// [2]: https://w3.org/TR/webrtc/#dom-peerconnection-setremotedescription
+    /// [3]: https://w3.org/TR/webrtc/#dom-peerconnection-addicecandidate
     async fn set_remote_description(&self, desc: SdpType) -> Result<()> {
         self.peer
             .set_remote_description(desc)
@@ -684,14 +710,30 @@ impl PeerConnection {
     ///
     /// # Errors
     ///
-    /// When setting remote SDP offer or creating SDP answer fails.
+    /// With [`MediaConnectionsError::TransceiverNotFound`] if cannot create
+    /// new [`Sender`] because of transceiver with specified `mid` being absent.
     ///
-    /// [1]: https://www.w3.org/TR/webrtc/#rtcpeerconnection-interface
+    /// With [`RTCPeerConnectionError::SetRemoteDescriptionFailed`] if
+    /// [RTCPeerConnection.setRemoteDescription()][2] fails.
+    ///
+    /// With [`StreamRequestError`], [`MediaManagerError`] or
+    /// [`MediaConnectionsError`] if cannot get or insert [`MediaStream`].
+    ///
+    /// With [`RTCPeerConnectionError::CreateAnswerFailed`] if
+    /// [RtcPeerConnection.createAnswer()][3] fails.
+    ///
+    /// With [`RTCPeerConnectionError::SetLocalDescriptionFailed`] if
+    /// [RtcPeerConnection.setLocalDescription()][4] fails.
+    ///
+    /// [1]: https://w3.org/TR/webrtc/#rtcpeerconnection-interface
+    /// [2]: https://w3.org/TR/webrtc/#dom-peerconnection-setremotedescription
+    /// [3]: https://w3.org/TR/webrtc/#dom-rtcpeerconnection-createanswer
+    /// [4]: https://w3.org/TR/webrtc/#dom-peerconnection-setlocaldescription
     pub async fn process_offer(
         &self,
         offer: String,
         tracks: Vec<Track>,
-        local_stream: Option<&SysMediaStream>,
+        local_constraints: Option<MediaStreamSettings>,
     ) -> Result<String> {
         // TODO: use drain_filter when its stable
         let (recv, send): (Vec<_>, Vec<_>) =
@@ -713,7 +755,7 @@ impl PeerConnection {
             .update_tracks(send)
             .map_err(tracerr::map_from_and_wrap!())?;
 
-        self.insert_local_stream(local_stream)
+        self.update_local_stream(local_constraints)
             .await
             .map_err(tracerr::wrap!())?;
 
@@ -730,9 +772,12 @@ impl PeerConnection {
     ///
     /// # Errors
     ///
-    /// If fails to add given ICE `candidate` to this peer.
+    /// With [`RTCPeerConnectionError::AddIceCandidateFailed`] if
+    /// [RtcPeerConnection.addIceCandidate()][2] fails to add buffered
+    /// [ICE candidates][1].
     ///
     /// [1]: https://tools.ietf.org/html/rfc5245#section-2
+    /// [2]: https://w3.org/TR/webrtc/#dom-peerconnection-addicecandidate
     pub async fn add_ice_candidate(
         &self,
         candidate: String,
diff --git a/jason/src/peer/stats.rs b/jason/src/peer/stats.rs
index 740570e16..eaaaa5655 100644
--- a/jason/src/peer/stats.rs
+++ b/jason/src/peer/stats.rs
@@ -19,7 +19,7 @@ impl TryFrom<JsArray> for RtcStatsReportEntry {
     type Error = Traced<RtcStatsError>;
 
     fn try_from(value: JsArray) -> Result<Self, Self::Error> {
-        use RtcStatsError::*;
+        use RtcStatsError::{Js, UndefinedId, UndefinedStats};
 
         let id = value.get(0);
         let stats = value.get(1);
@@ -53,7 +53,7 @@ impl TryFrom<&JsValue> for RtcStats {
     type Error = Traced<RtcStatsError>;
 
     fn try_from(stats: &JsValue) -> Result<Self, Self::Error> {
-        use RtcStatsError::*;
+        use RtcStatsError::{Js, UndefinedEntries};
 
         let entries_fn =
             get_property_by_name(&stats, "entries", |func: JsValue| {
diff --git a/jason/src/peer/stream.rs b/jason/src/peer/stream.rs
index 8ebccda09..39d8b1ab0 100644
--- a/jason/src/peer/stream.rs
+++ b/jason/src/peer/stream.rs
@@ -1,8 +1,9 @@
 //! [MediaStream][1] related objects.
 //!
-//! [1]: https://www.w3.org/TR/mediacapture-streams/#mediastream
+//! [1]: https://w3.org/TR/mediacapture-streams/#mediastream
 
 use std::{
+    cell::RefCell,
     collections::HashMap,
     rc::{Rc, Weak},
 };
@@ -11,25 +12,26 @@ use medea_client_api_proto::TrackId;
 use wasm_bindgen::{prelude::*, JsValue};
 use web_sys::MediaStream as SysMediaStream;
 
-use crate::{media::TrackConstraints, utils::HandlerDetachedError};
-
-use super::MediaTrack;
+use crate::{
+    media::{MediaStreamTrack, TrackKind},
+    utils::HandlerDetachedError,
+};
 
-/// Actual data of a [`MediaStream`].
+/// Actual data of a [`PeerMediaStream`].
 ///
-/// Shared between JS side ([`MediaStreamHandle`]) and Rust side
-/// ([`MediaStream`]).
+/// Shared between JS side ([`RemoteMediaStream`]) and Rust side
+/// ([`PeerMediaStream`]).
 struct InnerStream {
     /// Actual underlying [MediaStream][1] object.
     ///
-    /// [1]: https://www.w3.org/TR/mediacapture-streams/#mediastream
+    /// [1]: https://w3.org/TR/mediacapture-streams/#mediastream
     stream: SysMediaStream,
 
     /// List of audio tracks.
-    audio_tracks: HashMap<TrackId, Rc<MediaTrack>>,
+    audio_tracks: HashMap<TrackId, MediaStreamTrack>,
 
     /// List of video tracks.
-    video_tracks: HashMap<TrackId, Rc<MediaTrack>>,
+    video_tracks: HashMap<TrackId, MediaStreamTrack>,
 }
 
 impl InnerStream {
@@ -42,85 +44,93 @@ impl InnerStream {
         }
     }
 
-    /// Adds provided [`MediaTrack`] to a stream.
-    fn add_track(&mut self, track: Rc<MediaTrack>) {
-        self.stream.add_track(track.track());
-        let caps = track.caps();
-        match caps {
-            TrackConstraints::Audio(_) => {
-                self.audio_tracks.insert(track.id(), track);
+    /// Adds provided [`MediaStreamTrack`] to a stream.
+    fn add_track(&mut self, track_id: TrackId, track: MediaStreamTrack) {
+        self.stream.add_track(track.as_ref());
+        match track.kind() {
+            TrackKind::Audio => {
+                self.audio_tracks.insert(track_id, track);
             }
-            TrackConstraints::Video(_) => {
-                self.video_tracks.insert(track.id(), track);
+            TrackKind::Video => {
+                self.video_tracks.insert(track_id, track);
             }
         }
     }
 }
 
-/// Representation of [MediaStream][1] object.
+/// Representation of [MediaStream][1] object. Each of its tracks has
+/// association with [`TrackId`].
 ///
 /// It's used on Rust side and represents a handle to [`InnerStream`] data.
 ///
-/// For using [`MediaStream`] on JS side, consider the [`MediaStreamHandle`].
+/// For using [`PeerMediaStream`] on JS side, consider the
+/// [`RemoteMediaStream`].
 ///
-/// [1]: https://www.w3.org/TR/mediacapture-streams/#mediastream
-pub struct MediaStream(Rc<InnerStream>);
-
-impl MediaStream {
-    /// Creates new [`MediaStream`] from a given collection of [`MediaTrack`]s.
-    pub fn from_tracks<I>(tracks: I) -> Self
-    where
-        I: IntoIterator<Item = Rc<MediaTrack>>,
-    {
-        let mut stream = InnerStream::new();
-        for track in tracks {
-            stream.add_track(track);
-        }
-        Self(Rc::new(stream))
+/// [1]: https://w3.org/TR/mediacapture-streams/#mediastream
+pub struct PeerMediaStream(Rc<RefCell<InnerStream>>);
+
+#[allow(clippy::new_without_default)]
+impl PeerMediaStream {
+    /// Creates empty [`PeerMediaStream`].
+    pub fn new() -> Self {
+        Self(Rc::new(RefCell::new(InnerStream::new())))
+    }
+
+    /// Adds provided [`MediaStreamTrack`] to a stream.
+    pub fn add_track(&self, track_id: TrackId, track: MediaStreamTrack) {
+        self.0.borrow_mut().add_track(track_id, track);
     }
 
-    /// Checks if [`MediaStream`] contains a [`MediaTrack`] with specified ID.
+    /// Checks if [`PeerMediaStream`] contains a [`MediaStreamTrack`] with
+    /// specified ID.
     pub fn has_track(&self, id: TrackId) -> bool {
-        self.0.video_tracks.contains_key(&id)
-            || self.0.audio_tracks.contains_key(&id)
+        let inner = self.0.borrow();
+        inner.video_tracks.contains_key(&id)
+            || inner.audio_tracks.contains_key(&id)
     }
 
-    /// Returns a [`MediaTrack`] of [`MediaStream`] by its ID, if any.
-    pub fn get_track_by_id(&self, track_id: TrackId) -> Option<Rc<MediaTrack>> {
-        match self.0.video_tracks.get(&track_id) {
-            Some(track) => Some(Rc::clone(track)),
-            None => match self.0.audio_tracks.get(&track_id) {
-                Some(track) => Some(Rc::clone(track)),
+    /// Returns a [`MediaStreamTrack`] of [`PeerMediaStream`] by its ID, if any.
+    pub fn get_track_by_id(
+        &self,
+        track_id: TrackId,
+    ) -> Option<MediaStreamTrack> {
+        let inner = self.0.borrow();
+        match inner.video_tracks.get(&track_id) {
+            Some(track) => Some(track.clone()),
+            None => match inner.audio_tracks.get(&track_id) {
+                Some(track) => Some(track.clone()),
                 None => None,
             },
         }
     }
 
-    /// Instantiates new [`MediaStreamHandle`] for use on JS side.
-    pub fn new_handle(&self) -> MediaStreamHandle {
-        MediaStreamHandle(Rc::downgrade(&self.0))
+    /// Instantiates new [`RemoteMediaStream`] for use on JS side.
+    pub fn new_handle(&self) -> RemoteMediaStream {
+        RemoteMediaStream(Rc::downgrade(&self.0))
     }
 
     /// Returns actual underlying [MediaStream][1] object.
     ///
-    /// [1]: https://www.w3.org/TR/mediacapture-streams/#mediastream
+    /// [1]: https://w3.org/TR/mediacapture-streams/#mediastream
     pub fn stream(&self) -> SysMediaStream {
-        Clone::clone(&self.0.stream)
+        Clone::clone(&self.0.borrow().stream)
     }
 }
 
-/// JS side handle to [`MediaStream`].
+/// JS side handle to [`PeerMediaStream`].
 ///
 /// Actually, represents a [`Weak`]-based handle to `InnerStream`.
 ///
-/// For using [`MediaStreamHandle`] on Rust side, consider the [`MediaStream`].
+/// For using [`RemoteMediaStream`] on Rust side, consider the
+/// [`PeerMediaStream`].
 #[wasm_bindgen]
-pub struct MediaStreamHandle(Weak<InnerStream>);
+pub struct RemoteMediaStream(Weak<RefCell<InnerStream>>);
 
 #[wasm_bindgen]
-impl MediaStreamHandle {
-    /// Returns the underlying [`MediaStream`][`SysMediaStream`] object.
+impl RemoteMediaStream {
+    /// Returns the underlying [`PeerMediaStream`][`SysMediaStream`] object.
     pub fn get_media_stream(&self) -> Result<SysMediaStream, JsValue> {
-        upgrade_or_detached!(self.0).map(|inner| inner.stream.clone())
+        upgrade_or_detached!(self.0)
+            .map(|inner| Clone::clone(&inner.borrow().stream))
     }
 }
diff --git a/jason/src/peer/stream_request.rs b/jason/src/peer/stream_request.rs
index ac7748d44..e3c079ff4 100644
--- a/jason/src/peer/stream_request.rs
+++ b/jason/src/peer/stream_request.rs
@@ -1,25 +1,22 @@
 //! [MediaStreamConstraints][1] related objects.
 //!
-//! [1]: https://www.w3.org/TR/mediacapture-streams/#dom-mediastreamconstraints
+//! [1]: https://w3.org/TR/mediacapture-streams/#dom-mediastreamconstraints
 
 use std::{collections::HashMap, convert::TryFrom};
 
 use derive_more::Display;
 use medea_client_api_proto::TrackId;
 use tracerr::Traced;
-use web_sys::{
-    MediaStream as SysMediaStream, MediaStreamTrack as SysMediaStreamTrack,
-};
 
 use crate::{
     media::{
-        AudioTrackConstraints, MediaStreamConstraints, TrackConstraints,
-        VideoTrackConstraints,
+        AudioTrackConstraints, MediaStream, MediaStreamSettings,
+        TrackConstraints, TrackKind, VideoTrackConstraints,
     },
     utils::{JsCaused, JsError},
 };
 
-use super::{MediaStream, MediaTrack};
+use super::PeerMediaStream;
 
 /// Errors that may occur when validating [`StreamRequest`] or
 /// parsing [`MediaStream`].
@@ -37,25 +34,25 @@ pub enum StreamRequestError {
     #[display(fmt = "SimpleStreamRequest should have at least one track")]
     NoTracks,
 
-    /// Provided [`MediaStream`] has multiple audio [`MediaTrack`]s.
+    /// Provided [`MediaStream`] has multiple audio tracks.
     #[display(
         fmt = "provided MediaStream was expected to have single audio track"
     )]
     ExpectedAudioTracks,
 
-    /// Provided [`MediaStream`] has multiple video [`MediaTrack`]s.
+    /// Provided [`MediaStream`] has multiple video tracks.
     #[display(
         fmt = "provided MediaStream was expected to have single video track"
     )]
     ExpectedVideoTracks,
 
-    /// Audio [`MediaTrack`] fails to satisfy specified constraints.
+    /// Audio track fails to satisfy specified constraints.
     #[display(
         fmt = "provided audio track does not satisfy specified constraints"
     )]
     InvalidAudioTrack,
 
-    /// Video [`MediaTrack`] fails to satisfy specified constraints.
+    /// Video track fails to satisfy specified constraints.
     #[display(
         fmt = "provided video track does not satisfy specified constraints"
     )]
@@ -68,12 +65,11 @@ type Result<T> = std::result::Result<T, Traced<StreamRequestError>>;
 ///
 /// It's used for invoking [getUserMedia()][2] to specify what kinds of tracks
 /// should be included into returned [`MediaStream`], and, optionally,
-/// to establish constraints for those [`MediaTrack`]'s settings.
+/// to establish constraints for those track's settings.
 ///
-/// [1]: https://www.w3.org/TR/mediacapture-streams/#dom-mediastreamconstraints
-/// [2]:
-/// https://www.w3.org/TR/mediacapture-streams/#dom-mediadevices-getusermedia
-/// [3]: https://www.w3.org/TR/mediacapture-streams/#mediastream
+/// [1]: https://w3.org/TR/mediacapture-streams/#dom-mediastreamconstraints
+/// [2]: https://w3.org/TR/mediacapture-streams/#dom-mediadevices-getusermedia
+/// [3]: https://w3.org/TR/mediacapture-streams/#mediastream
 #[derive(Default)]
 pub struct StreamRequest {
     audio: HashMap<TrackId, AudioTrackConstraints>,
@@ -106,44 +102,44 @@ pub struct SimpleStreamRequest {
 }
 
 impl SimpleStreamRequest {
-    /// Parses raw [`SysMediaStream`] and returns [`MediaStream`] wrapper.
+    /// Parses [`MediaStream`] and returns [`PeerMediaStream`] wrapper.
     ///
     /// # Errors
     ///
     /// Errors with [`StreamRequestError::InvalidAudioTrack`] if some audio
-    /// [`MediaTrack`] from provided [`SysMediaStream`] not satisfies
+    /// track from provided [`MediaStream`] not satisfies
     /// contained constrains.
     ///
     /// Errors with [`StreamRequestError::ExpectedAudioTracks`] if provided
-    /// [`SysMediaStream`] doesn't have expected audio [`MediaTrack`].
+    /// [`MediaStream`] doesn't have expected audio track.
     ///
     /// Errors with [`StreamRequestError::InvalidVideoTrack`] if some video
-    /// [`MediaTrack`] from provided [`SysMediaStream`] not satisfies
+    /// track from provided [`MediaStream`] not satisfies
     /// contained constrains.
     ///
     /// Errors with [`StreamRequestError::ExpectedVideoTracks`] if provided
-    /// [`SysMediaStream`] doesn't have expected video [`MediaTrack`].
-    pub fn parse_stream(&self, stream: &SysMediaStream) -> Result<MediaStream> {
-        use StreamRequestError::*;
+    /// [`MediaStream`] doesn't have expected video track.
+    pub fn parse_stream(&self, stream: MediaStream) -> Result<PeerMediaStream> {
+        use StreamRequestError::{
+            ExpectedAudioTracks, ExpectedVideoTracks, InvalidAudioTrack,
+            InvalidVideoTrack,
+        };
 
-        let mut tracks = Vec::new();
+        let result_stream = PeerMediaStream::new();
 
-        if let Some((id, audio)) = &self.audio {
-            let audio_tracks: Vec<_> =
-                js_sys::try_iter(&stream.get_audio_tracks())
-                    .unwrap()
-                    .unwrap()
-                    .map(|tr| SysMediaStreamTrack::from(tr.unwrap()))
-                    .collect();
+        let (video_tracks, audio_tracks): (Vec<_>, Vec<_>) = stream
+            .into_tracks()
+            .into_iter()
+            .partition(|track| match track.kind() {
+                TrackKind::Audio { .. } => false,
+                TrackKind::Video { .. } => true,
+            });
 
+        if let Some((id, audio)) = &self.audio {
             if audio_tracks.len() == 1 {
                 let track = audio_tracks.into_iter().next().unwrap();
-                if audio.satisfies(&track) {
-                    tracks.push(MediaTrack::new(
-                        *id,
-                        track,
-                        TrackConstraints::Audio(audio.clone()),
-                    ))
+                if audio.satisfies(track.as_ref()) {
+                    result_stream.add_track(*id, track);
                 } else {
                     return Err(tracerr::new!(InvalidAudioTrack));
                 }
@@ -153,21 +149,10 @@ impl SimpleStreamRequest {
         }
 
         if let Some((id, video)) = &self.video {
-            let video_tracks: Vec<_> =
-                js_sys::try_iter(&stream.get_video_tracks())
-                    .unwrap()
-                    .unwrap()
-                    .map(|tr| SysMediaStreamTrack::from(tr.unwrap()))
-                    .collect();
-
             if video_tracks.len() == 1 {
                 let track = video_tracks.into_iter().next().unwrap();
-                if video.satisfies(&track) {
-                    tracks.push(MediaTrack::new(
-                        *id,
-                        track,
-                        TrackConstraints::Video(video.clone()),
-                    ))
+                if video.satisfies(track.as_ref()) {
+                    result_stream.add_track(*id, track);
                 } else {
                     return Err(tracerr::new!(InvalidVideoTrack));
                 }
@@ -176,7 +161,49 @@ impl SimpleStreamRequest {
             }
         }
 
-        Ok(MediaStream::from_tracks(tracks))
+        Ok(result_stream)
+    }
+
+    /// Merges [`SimpleStreamRequest`] with provided [`MediaStreamSettings`].
+    ///
+    /// Applies new settings if possible, meaning that if this
+    /// [`SimpleStreamRequest`] does not have some constraint, then it will be
+    /// applied from [`MediaStreamSettings`].
+    ///
+    /// # Errors
+    ///
+    /// Errors with [`StreamRequestError::ExpectedAudioTracks`] if
+    /// [`SimpleStreamRequest`] contains [`AudioTrackConstraints`], but provided
+    /// [`MediaStreamSettings`] doesn't.
+    ///
+    /// Errors with [`StreamRequestError::ExpectedVideoTracks`] if
+    /// [`SimpleStreamRequest`] contains [`VideoTrackConstraints`], but provided
+    /// [`MediaStreamSettings`] doesn't.
+    pub fn merge<T: Into<MediaStreamSettings>>(
+        &mut self,
+        other: T,
+    ) -> Result<()> {
+        let mut other = other.into();
+
+        if let Some((_, audio)) = self.audio.as_mut() {
+            if let Some(other_audio) = other.take_audio() {
+                audio.merge(other_audio)
+            } else {
+                return Err(tracerr::new!(
+                    StreamRequestError::ExpectedAudioTracks
+                ));
+            }
+        };
+        if let Some((_, video)) = self.video.as_mut() {
+            if let Some(other_video) = other.take_video() {
+                video.merge(other_video)
+            } else {
+                return Err(tracerr::new!(
+                    StreamRequestError::ExpectedVideoTracks
+                ));
+            }
+        };
+        Ok(())
     }
 }
 
@@ -186,7 +213,9 @@ impl TryFrom<StreamRequest> for SimpleStreamRequest {
     fn try_from(
         value: StreamRequest,
     ) -> std::result::Result<Self, Self::Error> {
-        use StreamRequestError::*;
+        use StreamRequestError::{
+            NoTracks, TooManyAudioTracks, TooManyVideoTracks,
+        };
 
         if value.video.len() > 1 {
             return Err(TooManyVideoTracks);
@@ -210,7 +239,7 @@ impl TryFrom<StreamRequest> for SimpleStreamRequest {
     }
 }
 
-impl From<&SimpleStreamRequest> for MediaStreamConstraints {
+impl From<&SimpleStreamRequest> for MediaStreamSettings {
     fn from(request: &SimpleStreamRequest) -> Self {
         let mut constraints = Self::new();
 
diff --git a/jason/src/peer/track.rs b/jason/src/peer/track.rs
deleted file mode 100644
index fe4cce83b..000000000
--- a/jason/src/peer/track.rs
+++ /dev/null
@@ -1,70 +0,0 @@
-//! [MediaStreamTrack][1] representation.
-//!
-//! [1]: https://www.w3.org/TR/mediacapture-streams/#mediastreamtrack
-
-use std::rc::Rc;
-
-use medea_client_api_proto::TrackId as Id;
-use web_sys::MediaStreamTrack;
-
-use crate::{media::TrackConstraints, peer::StableMuteState};
-
-/// Representation of [MediaStreamTrack][1].
-///
-/// [1]: https://www.w3.org/TR/mediacapture-streams/#mediastreamtrack
-pub struct MediaTrack {
-    id: Id,
-    track: MediaStreamTrack,
-    caps: TrackConstraints,
-}
-
-impl MediaTrack {
-    /// Instantiates new [`MediaTrack`].
-    pub fn new(
-        id: Id,
-        track: MediaStreamTrack,
-        caps: TrackConstraints,
-    ) -> Rc<Self> {
-        Rc::new(Self { id, track, caps })
-    }
-
-    /// Returns ID of this [`MediaTrack`].
-    pub fn id(&self) -> Id {
-        self.id
-    }
-
-    /// Returns the underlying [`MediaStreamTrack`] object of this
-    /// [`MediaTrack`].
-    pub fn track(&self) -> &MediaStreamTrack {
-        &self.track
-    }
-
-    /// Returns [`TrackConstraints`] of this [`MediaTrack`].
-    pub fn caps(&self) -> &TrackConstraints {
-        &self.caps
-    }
-
-    /// Checks if underlying [`MediaStreamTrack`] is enabled.
-    pub fn is_enabled(&self) -> bool {
-        self.track.enabled()
-    }
-
-    /// Enables or disables underlying [`MediaStreamTrack`].
-    pub fn set_enabled(&self, enabled: bool) {
-        self.track.set_enabled(enabled)
-    }
-
-    /// Sets [`MediaStreamTrack`] enabled property basing on the provided
-    /// `mute_state`.
-    #[inline]
-    pub fn set_enabled_by_mute_state(&self, mute_state: StableMuteState) {
-        match mute_state {
-            StableMuteState::Muted => {
-                self.set_enabled(false);
-            }
-            StableMuteState::NotMuted => {
-                self.set_enabled(true);
-            }
-        }
-    }
-}
diff --git a/jason/src/rpc/websocket.rs b/jason/src/rpc/websocket.rs
index 1a4d83fdd..3956411ba 100644
--- a/jason/src/rpc/websocket.rs
+++ b/jason/src/rpc/websocket.rs
@@ -81,7 +81,8 @@ impl TryFrom<&MessageEvent> for ServerMessage {
     type Error = TransportError;
 
     fn try_from(msg: &MessageEvent) -> std::result::Result<Self, Self::Error> {
-        use TransportError::*;
+        use TransportError::{MessageNotString, ParseServerMessage};
+
         let payload = msg.data().as_string().ok_or(MessageNotString)?;
 
         serde_json::from_str::<ServerMsg>(&payload)
@@ -211,7 +212,14 @@ impl WebSocketRpcTransport {
     ///
     /// # Errors
     ///
-    /// If establishing WebSocket connection fails.
+    /// With [`TransportError::CreateSocket`] if cannot establish WebSocket to
+    /// specified URL.
+    ///
+    /// With [`TransportError::InitSocket`] if [WebSocket.onclose][1] callback
+    /// fired before [WebSocket.onopen][2] callback.
+    ///
+    /// [1]: https://developer.mozilla.org/en-US/docs/Web/API/WebSocket/onclose
+    /// [2]: https://developer.mozilla.org/en-US/docs/Web/API/WebSocket/onopen
     pub async fn new(url: &str) -> Result<Self> {
         let (tx_close, rx_close) = oneshot::channel();
         let (tx_open, rx_open) = oneshot::channel();
diff --git a/jason/tests/api/room.rs b/jason/tests/api/room.rs
index c9a328f5d..004aa8f98 100644
--- a/jason/tests/api/room.rs
+++ b/jason/tests/api/room.rs
@@ -6,7 +6,7 @@ use futures::channel::mpsc;
 use medea_client_api_proto::{Command, Event, IceServer, PeerId};
 use medea_jason::{
     api::Room,
-    media::{AudioTrackConstraints, MediaManager, MediaStreamConstraints},
+    media::{AudioTrackConstraints, MediaManager, MediaStreamSettings},
     peer::{
         MockPeerRepository, PeerConnection, PeerEvent, StableMuteState,
         TransceiverKind,
@@ -392,16 +392,14 @@ fn get_test_room_and_new_peer(
 //    assert!(!peer.is_send_video_enabled());
 //}
 
-// Tests Room::inject_local_stream for create new PeerConnection.
-// Setup:
-//     1. Create Room.
-//     2. Set `on_failed_local_stream` callback.
-//     3. Acquire audio track.
-//     4. Acquire local media stream without video track.
-//     5. Inject local stream to Room.
-//     6. Try create PeerConnection with injected stream.
-// Assertions:
-//     1. Invoking `on_failed_local_stream` callback.
+/// Tests RoomHandle::set_local_media_settings before creating PeerConnection.
+/// Setup:
+///     1. Create Room.
+///     2. Set `on_failed_local_stream` callback.
+///     3. Invoke `room_handle.set_local_media_settings` with one track.
+///     4. Send `PeerCreated` to room wth two tracks
+/// Assertions:
+///     1. `on_failed_local_stream` callback was invoked.
 #[wasm_bindgen_test]
 async fn error_inject_invalid_local_stream_into_new_peer() {
     let (event_tx, event_rx) = mpsc::unbounded();
@@ -420,13 +418,12 @@ async fn error_inject_invalid_local_stream_into_new_peer() {
 
     let (audio_track, video_track) = get_test_tracks(false, false);
 
-    let media_manager = MediaManager::default();
-    let mut constraints = MediaStreamConstraints::new();
-    let audio_constraints = AudioTrackConstraints::new();
-    constraints.audio(audio_constraints);
-    let (stream, _) = media_manager.get_stream(constraints).await.unwrap();
+    let mut constraints = MediaStreamSettings::new();
+    constraints.audio(AudioTrackConstraints::new());
 
-    room_handle.inject_local_stream(stream).unwrap();
+    JsFuture::from(room_handle.set_local_media_settings(&constraints))
+        .await
+        .unwrap();
 
     event_tx
         .unbounded_send(Event::PeerCreated {
@@ -441,15 +438,14 @@ async fn error_inject_invalid_local_stream_into_new_peer() {
     wait_and_check_test_result(test_result, || {}).await;
 }
 
-// Tests Room::inject_local_stream for existing PeerConnection.
-// Setup:
-//     1. Create Room.
-//     2. Set `on_failed_local_stream` callback.
-//     3. Acquire audio track.
-//     4. Acquire local media stream without video track.
-//     5. Inject local stream to Room and try change stream into existing peer.
-// Assertions:
-//     1. Invoking `on_failed_local_stream` callback.
+/// Tests RoomHandle::set_local_media_settings for existing PeerConnection.
+/// Setup:
+///     1. Create Room.
+///     2. Set `on_failed_local_stream` callback.
+///     3. Invoke `peer.get_offer` with two tracks.
+///     4. Invoke `room_handle.set_local_media_settings` with only one track.
+/// Assertions:
+///     1. `on_failed_local_stream` was invoked.
 #[wasm_bindgen_test]
 async fn error_inject_invalid_local_stream_into_room_on_exists_peer() {
     let (cb, test_result) = js_callback!(|err: JasonError| {
@@ -466,14 +462,13 @@ async fn error_inject_invalid_local_stream_into_room_on_exists_peer() {
         .await
         .unwrap();
 
-    let media_manager = MediaManager::default();
-    let mut constraints = MediaStreamConstraints::new();
-    let audio_constraints = AudioTrackConstraints::new();
-    constraints.audio(audio_constraints);
-    let (stream, _) = media_manager.get_stream(constraints).await.unwrap();
+    let mut constraints = MediaStreamSettings::new();
+    constraints.audio(AudioTrackConstraints::new());
     let room_handle = room.new_handle();
     room_handle.on_failed_local_stream(cb.into()).unwrap();
-    room_handle.inject_local_stream(stream).unwrap();
+    JsFuture::from(room_handle.set_local_media_settings(&constraints))
+        .await
+        .unwrap();
 
     wait_and_check_test_result(test_result, || {}).await;
 }
@@ -515,13 +510,13 @@ async fn error_get_local_stream_on_new_peer() {
         .await;
 }
 
-// Tests Room::join without set `on_failed_local_stream` callback.
-// Setup:
-//     1. Create Room.
-//     2. DO NOT set `on_failed_local_stream` callback.
-//     3. Try join to Room.
-// Assertions:
-//     1. Room::join returns error.
+/// Tests `Room::join` if `on_failed_local_stream` callback was not set.
+/// Setup:
+///     1. Create Room.
+///     2. DO NOT set `on_failed_local_stream` callback.
+///     3. Try join to Room.
+/// Assertions:
+///     1. Room::join returns error.
 #[wasm_bindgen_test]
 async fn error_join_room_without_on_failed_stream_callback() {
     let (_, event_rx) = mpsc::unbounded();
@@ -551,13 +546,13 @@ async fn error_join_room_without_on_failed_stream_callback() {
     }
 }
 
-// Tests Room::join without set `on_connection_loss` callback.
-// Setup:
-//     1. Create Room.
-//     2. DO NOT set `on_connection_loss` callback.
-//     3. Try join to Room.
-// Assertions:
-//     1. Room::join returns error.
+/// Tests `Room::join` if `on_connection_loss` callback was not set.
+/// Setup:
+///     1. Create Room.
+///     2. DO NOT set `on_connection_loss` callback.
+///     3. Try join to Room.
+/// Assertions:
+///     1. Room::join returns error.
 #[wasm_bindgen_test]
 async fn error_join_room_without_on_connection_loss_callback() {
     let (_, event_rx) = mpsc::unbounded();
diff --git a/jason/tests/media/constraints.rs b/jason/tests/media/constraints.rs
index fdae49da6..bcbeed8ea 100644
--- a/jason/tests/media/constraints.rs
+++ b/jason/tests/media/constraints.rs
@@ -3,15 +3,13 @@
 use wasm_bindgen::JsValue;
 use wasm_bindgen_futures::JsFuture;
 use wasm_bindgen_test::*;
-use web_sys::{
-    MediaDeviceInfo, MediaDeviceKind, MediaStream, MediaStreamTrack,
-};
+use web_sys::{MediaDeviceInfo, MediaDeviceKind};
 
 use medea_client_api_proto::VideoSettings;
 use medea_jason::{
     media::{
         AudioTrackConstraints, DeviceVideoTrackConstraints, MediaManager,
-        MediaStreamConstraints, MultiSourceMediaStreamConstraints,
+        MediaStreamSettings, MultiSourceMediaStreamConstraints, TrackKind,
         VideoTrackConstraints,
     },
     utils::{get_property_by_name, window},
@@ -20,50 +18,6 @@ use medea_jason::{
 
 wasm_bindgen_test_configure!(run_in_browser);
 
-#[wasm_bindgen_test]
-async fn not_satisfies_stopped_video_track() {
-    let video_device = video_devices().await.unwrap().pop().unwrap();
-
-    let mut constraints = MediaStreamConstraints::new();
-    let mut track_constraints = DeviceVideoTrackConstraints::new();
-    track_constraints.device_id(video_device.device_id());
-    constraints.device_video(track_constraints.clone());
-
-    let media_manager = MediaManager::default();
-    let (stream, _) =
-        media_manager.get_stream(constraints.clone()).await.unwrap();
-
-    assert!(stream.get_tracks().length() == 1);
-
-    let track = MediaStreamTrack::from(stream.get_tracks().pop());
-    track.stop();
-
-    assert!(track.kind() == "video");
-    assert!(!VideoTrackConstraints::from(track_constraints).satisfies(&track));
-}
-
-#[wasm_bindgen_test]
-async fn not_satisfies_stopped_audio_track() {
-    let audio_device = audio_devices().await.unwrap().pop().unwrap();
-
-    let mut constraints = MediaStreamConstraints::new();
-    let mut track_constraints = AudioTrackConstraints::new();
-    track_constraints.device_id(audio_device.device_id());
-    constraints.audio(track_constraints.clone());
-
-    let media_manager = MediaManager::default();
-    let (stream, _) =
-        media_manager.get_stream(constraints.clone()).await.unwrap();
-
-    assert!(stream.get_tracks().length() == 1);
-
-    let track = MediaStreamTrack::from(stream.get_tracks().pop());
-    track.stop();
-
-    assert!(track.kind() == "audio");
-    assert!(!track_constraints.satisfies(&track));
-}
-
 // 1. Get device id of non default video device from enumerate_devices();
 // 2. Add it to constraints;
 // 3. Get stream by constraints;
@@ -72,7 +26,7 @@ async fn not_satisfies_stopped_audio_track() {
 async fn video_constraints_satisfies() {
     let video_device = video_devices().await.unwrap().pop().unwrap();
 
-    let mut constraints = MediaStreamConstraints::new();
+    let mut constraints = MediaStreamSettings::new();
     let mut track_constraints = DeviceVideoTrackConstraints::new();
     track_constraints.device_id(video_device.device_id());
     constraints.device_video(track_constraints.clone());
@@ -80,12 +34,13 @@ async fn video_constraints_satisfies() {
     let media_manager = MediaManager::default();
     let (stream, _) =
         media_manager.get_stream(constraints.clone()).await.unwrap();
+    let mut tracks = stream.into_tracks();
 
-    assert!(stream.get_tracks().length() == 1);
+    assert_eq!(tracks.len(), 1);
 
-    let track = MediaStreamTrack::from(stream.get_tracks().pop());
+    let track = tracks.pop().unwrap();
 
-    assert!(track.kind() == "video");
+    assert!(track.kind() == TrackKind::Video);
     assert!(VideoTrackConstraints::from(track_constraints).satisfies(&track));
 }
 
@@ -97,7 +52,7 @@ async fn video_constraints_satisfies() {
 async fn audio_constraints_satisfies() {
     let audio_device = audio_devices().await.unwrap().pop().unwrap();
 
-    let mut constraints = MediaStreamConstraints::new();
+    let mut constraints = MediaStreamSettings::new();
     let mut track_constraints = AudioTrackConstraints::new();
     track_constraints.device_id(audio_device.device_id());
     constraints.audio(track_constraints.clone());
@@ -106,11 +61,12 @@ async fn audio_constraints_satisfies() {
     let (stream, _) =
         media_manager.get_stream(constraints.clone()).await.unwrap();
 
-    assert!(stream.get_tracks().length() == 1);
+    let mut tracks = stream.into_tracks();
+    assert_eq!(tracks.len(), 1);
 
-    let track = MediaStreamTrack::from(stream.get_tracks().pop());
+    let track = tracks.pop().unwrap();
 
-    assert!(track.kind() == "audio");
+    assert!(track.kind() == TrackKind::Audio);
     assert!(track_constraints.satisfies(&track));
 }
 
@@ -127,7 +83,7 @@ async fn both_constraints_satisfies() {
     let video_device = video_devices().await.unwrap().pop().unwrap();
 
     let constraints = {
-        let mut constraints = MediaStreamConstraints::new();
+        let mut constraints = MediaStreamSettings::new();
 
         let mut audio_constraints = AudioTrackConstraints::new();
         audio_constraints.device_id(audio_device.device_id());
@@ -145,18 +101,25 @@ async fn both_constraints_satisfies() {
     let (stream, _) =
         media_manager.get_stream(constraints.clone()).await.unwrap();
 
-    assert!(stream.get_tracks().length() == 2);
-
     let video_constraints = constraints.get_video().clone().unwrap();
     let audio_constraints = constraints.get_audio().clone().unwrap();
 
-    let audio_track = MediaStreamTrack::from(stream.get_audio_tracks().pop());
-    let video_track = MediaStreamTrack::from(stream.get_video_tracks().pop());
+    let tracks = stream.into_tracks();
+    assert_eq!(tracks.len(), 2);
+
+    let (mut audio, mut video): (Vec<_>, Vec<_>) =
+        tracks.into_iter().partition(|track| match track.kind() {
+            TrackKind::Audio => true,
+            TrackKind::Video => false,
+        });
 
-    assert!(audio_track.kind() == "audio");
+    let audio_track = audio.pop().unwrap();
+    let video_track = video.pop().unwrap();
+
+    assert!(audio_track.kind() == TrackKind::Audio);
     assert!(audio_constraints.satisfies(&audio_track));
 
-    assert!(video_track.kind() == "video");
+    assert!(video_track.kind() == TrackKind::Video);
     assert!(video_constraints.satisfies(&video_track));
 }
 
@@ -179,40 +142,40 @@ async fn equal_constraints_produce_equal_streams() {
     let manager = MediaManager::default();
 
     let (stream, _) = manager.get_stream(constraints.clone()).await.unwrap();
-    let stream_tracks = get_stream_tracks(stream);
+    let stream_tracks = stream.into_tracks();
 
     let (stream, _) = manager.get_stream(constraints.clone()).await.unwrap();
-    let another_stream_tracks = get_stream_tracks(stream);
+    let another_stream_tracks = stream.into_tracks();
 
     let audio_track = stream_tracks
         .iter()
-        .find(|track| track.kind() == "audio")
+        .find(|track| track.kind() == TrackKind::Audio)
         .unwrap();
     let some_audio_track = another_stream_tracks
         .iter()
-        .find(|track| track.kind() == "audio")
+        .find(|track| track.kind() == TrackKind::Audio)
         .unwrap();
     assert_eq!(audio_track.id(), some_audio_track.id());
 
     let video_track = stream_tracks
         .iter()
-        .find(|track| track.kind() == "video")
+        .find(|track| track.kind() == TrackKind::Video)
         .unwrap();
     let some_video_track = another_stream_tracks
         .iter()
-        .find(|track| track.kind() == "video")
+        .find(|track| track.kind() == TrackKind::Video)
         .unwrap();
     assert_eq!(video_track.id(), some_video_track.id());
 }
 
-// 0. If audio_devices.len() > 1 (otherwise this test makes no sense);
-// 1. Get device id of non default audio device from enumerate_devices();
-// 2. Add it to constraints;
-// 3. Get stream1 by constraints;
-// 4. Get next device id of non default audio device from enumerate_devices();
-// 5. Create new constraints;
-// 6. Get stream2 by constraints;
-// 7. Assert (stream1.track().id() != stream2.track().id());
+/// 1. If audio_devices.len() > 1 (otherwise this test makes no sense);
+/// 2. Get device id of non default audio device from enumerate_devices();
+/// 3. Add it to constraints;
+/// 4. Get stream1 by constraints;
+/// 5. Get next device id of non default audio device from
+/// `enumerate_devices()`; 6. Create new constraints;
+/// 7. Get stream2 by constraints;
+/// 8. Assert `(stream1.track().id() != stream2.track().id())`.
 #[wasm_bindgen_test]
 async fn different_constraints_produce_different_streams() {
     let mut audio_devices = audio_devices().await.unwrap().into_iter();
@@ -223,20 +186,20 @@ async fn different_constraints_produce_different_streams() {
         let manager = MediaManager::default();
 
         let (stream, _) = manager.get_stream(constraints).await.unwrap();
-        let stream_tracks = get_stream_tracks(stream);
+        let stream_tracks = stream.into_tracks();
 
         let constraints = build_constraints(audio_devices.next(), None);
         let (another_stream, _) =
             manager.get_stream(constraints).await.unwrap();
-        let another_stream_tracks = get_stream_tracks(another_stream);
+        let another_stream_tracks = another_stream.into_tracks();
 
         let audio_track = stream_tracks
             .iter()
-            .find(|track| track.kind() == "audio")
+            .find(|track| track.kind() == TrackKind::Audio)
             .unwrap();
         let another_audio_track = another_stream_tracks
             .iter()
-            .find(|track| track.kind() == "audio")
+            .find(|track| track.kind() == TrackKind::Audio)
             .unwrap();
         assert_ne!(audio_track.id(), another_audio_track.id());
     }
@@ -246,32 +209,24 @@ async fn different_constraints_produce_different_streams() {
 // Device({audio:false, video:false})
 #[wasm_bindgen_test]
 async fn multi_source_media_stream_constraints_build1() {
-    match MultiSourceMediaStreamConstraints::from(MediaStreamConstraints::new())
-    {
-        MultiSourceMediaStreamConstraints::Device(constraints) => {
-            let has_video =
-                get_property_by_name(&constraints, "video", js_val_to_option)
-                    .is_some();
-            let has_audio =
-                get_property_by_name(&constraints, "audio", js_val_to_option)
-                    .is_some();
+    let constraints: Option<MultiSourceMediaStreamConstraints> =
+        MediaStreamSettings::new().into();
 
-            assert!(!has_video);
-            assert!(!has_audio);
-        }
-        _ => unreachable!(),
-    };
+    assert!(constraints.is_none());
 }
 
 // Make sure that MediaStreamConstraints{audio:true, video:false} =>
 // Device({audio:true, video:false})
 #[wasm_bindgen_test]
 async fn multi_source_media_stream_constraints_build2() {
-    let mut constraints = MediaStreamConstraints::new();
+    let mut constraints = MediaStreamSettings::new();
     constraints.audio(AudioTrackConstraints::new());
 
-    match MultiSourceMediaStreamConstraints::from(constraints) {
-        MultiSourceMediaStreamConstraints::Device(constraints) => {
+    let constraints: Option<MultiSourceMediaStreamConstraints> =
+        constraints.into();
+
+    match constraints {
+        Some(MultiSourceMediaStreamConstraints::Device(constraints)) => {
             let has_video =
                 get_property_by_name(&constraints, "video", js_val_to_option)
                     .is_some();
@@ -290,12 +245,15 @@ async fn multi_source_media_stream_constraints_build2() {
 // Device({audio:true, video:true})
 #[wasm_bindgen_test]
 async fn multi_source_media_stream_constraints_build3() {
-    let mut constraints = MediaStreamConstraints::new();
+    let mut constraints = MediaStreamSettings::new();
     constraints.audio(AudioTrackConstraints::new());
     constraints.device_video(DeviceVideoTrackConstraints::new());
 
-    match MultiSourceMediaStreamConstraints::from(constraints) {
-        MultiSourceMediaStreamConstraints::Device(constraints) => {
+    let constraints: Option<MultiSourceMediaStreamConstraints> =
+        constraints.into();
+
+    match constraints {
+        Some(MultiSourceMediaStreamConstraints::Device(constraints)) => {
             let has_video =
                 get_property_by_name(&constraints, "video", js_val_to_option)
                     .is_some();
@@ -314,15 +272,18 @@ async fn multi_source_media_stream_constraints_build3() {
 // DeviceAndDisplay({audio:true, video:false}, {audio:false, video:display})
 #[wasm_bindgen_test]
 async fn multi_source_media_stream_constraints_build4() {
-    let mut constraints = MediaStreamConstraints::new();
+    let mut constraints = MediaStreamSettings::new();
     constraints.audio(AudioTrackConstraints::new());
     constraints.display_video(DisplayVideoTrackConstraints::new());
 
-    match MultiSourceMediaStreamConstraints::from(constraints) {
-        MultiSourceMediaStreamConstraints::DeviceAndDisplay(
+    let constraints: Option<MultiSourceMediaStreamConstraints> =
+        constraints.into();
+
+    match constraints {
+        Some(MultiSourceMediaStreamConstraints::DeviceAndDisplay(
             device,
             display,
-        ) => {
+        )) => {
             let device_has_video =
                 get_property_by_name(&device, "video", js_val_to_option)
                     .is_some();
@@ -349,11 +310,14 @@ async fn multi_source_media_stream_constraints_build4() {
 // Device({audio:false, video:true})
 #[wasm_bindgen_test]
 async fn multi_source_media_stream_constraints_build5() {
-    let mut constraints = MediaStreamConstraints::new();
+    let mut constraints = MediaStreamSettings::new();
     constraints.device_video(DeviceVideoTrackConstraints::new());
 
-    match MultiSourceMediaStreamConstraints::from(constraints) {
-        MultiSourceMediaStreamConstraints::Device(constraints) => {
+    let constraints: Option<MultiSourceMediaStreamConstraints> =
+        constraints.into();
+
+    match constraints {
+        Some(MultiSourceMediaStreamConstraints::Device(constraints)) => {
             let has_video =
                 get_property_by_name(&constraints, "video", js_val_to_option)
                     .is_some();
@@ -372,11 +336,14 @@ async fn multi_source_media_stream_constraints_build5() {
 // Display({audio:false, video:true})
 #[wasm_bindgen_test]
 async fn multi_source_media_stream_constraints_build6() {
-    let mut constraints = MediaStreamConstraints::new();
+    let mut constraints = MediaStreamSettings::new();
     constraints.display_video(DisplayVideoTrackConstraints::new());
 
-    match MultiSourceMediaStreamConstraints::from(constraints) {
-        MultiSourceMediaStreamConstraints::Display(constraints) => {
+    let constraints: Option<MultiSourceMediaStreamConstraints> =
+        constraints.into();
+
+    match constraints {
+        Some(MultiSourceMediaStreamConstraints::Display(constraints)) => {
             let has_video =
                 get_property_by_name(&constraints, "video", js_val_to_option)
                     .is_some();
@@ -395,12 +362,15 @@ async fn multi_source_media_stream_constraints_build6() {
 // Device({audio:true, video:true})
 #[wasm_bindgen_test]
 async fn multi_source_media_stream_constraints_build7() {
-    let mut constraints = MediaStreamConstraints::new();
+    let mut constraints = MediaStreamSettings::new();
     constraints.audio(AudioTrackConstraints::new());
     constraints.video(VideoTrackConstraints::from(VideoSettings {}));
 
-    match MultiSourceMediaStreamConstraints::from(constraints) {
-        MultiSourceMediaStreamConstraints::Device(constraints) => {
+    let constraints: Option<MultiSourceMediaStreamConstraints> =
+        constraints.into();
+
+    match constraints {
+        Some(MultiSourceMediaStreamConstraints::Device(constraints)) => {
             let has_video =
                 get_property_by_name(&constraints, "video", js_val_to_option)
                     .is_some();
@@ -415,6 +385,38 @@ async fn multi_source_media_stream_constraints_build7() {
     };
 }
 
+// Make sure that MediaStreamConstraints{audio:false, video:any} =>
+// Device({audio:false, video:true})
+#[wasm_bindgen_test]
+async fn multi_source_media_stream_constraints_build8() {
+    let mut constraints = MediaStreamSettings::new();
+    constraints.video(VideoTrackConstraints::from(VideoSettings {}));
+
+    let constraints: Option<MultiSourceMediaStreamConstraints> =
+        constraints.into();
+
+    match constraints {
+        Some(MultiSourceMediaStreamConstraints::Device(constraints)) => {
+            let has_video =
+                get_property_by_name(&constraints, "video", js_val_to_option)
+                    .is_some();
+            let has_audio =
+                get_property_by_name(&constraints, "audio", js_val_to_option)
+                    .is_some();
+
+            assert!(has_video);
+            assert!(!has_audio);
+        }
+        _ => unreachable!(),
+    };
+}
+
+#[wasm_bindgen_test]
+async fn merge_audio() {}
+
+#[wasm_bindgen_test]
+async fn merge_video() {}
+
 // Maps undefined to None.
 fn js_val_to_option(val: JsValue) -> Option<JsValue> {
     if val.is_undefined() {
@@ -467,8 +469,8 @@ async fn video_devices() -> Result<Vec<MediaDeviceInfo>, JsValue> {
 fn build_constraints(
     audio_device: Option<MediaDeviceInfo>,
     video_device: Option<MediaDeviceInfo>,
-) -> MediaStreamConstraints {
-    let mut constraints = MediaStreamConstraints::new();
+) -> MediaStreamSettings {
+    let mut constraints = MediaStreamSettings::new();
     if let Some(audio) = audio_device {
         let mut track_constraints = AudioTrackConstraints::new();
         track_constraints.device_id(audio.device_id());
@@ -481,12 +483,3 @@ fn build_constraints(
     }
     constraints
 }
-
-/// Returns [MediaStreamTrack]s of given [MediaStream].
-fn get_stream_tracks(stream: MediaStream) -> Vec<MediaStreamTrack> {
-    js_sys::try_iter(&stream.get_tracks())
-        .unwrap()
-        .unwrap()
-        .map(|tr| web_sys::MediaStreamTrack::from(tr.unwrap()))
-        .collect()
-}
diff --git a/jason/tests/media/manager.rs b/jason/tests/media/manager.rs
index 50b2c5701..986d5b656 100644
--- a/jason/tests/media/manager.rs
+++ b/jason/tests/media/manager.rs
@@ -5,11 +5,12 @@ use wasm_bindgen_futures::JsFuture;
 use wasm_bindgen_test::*;
 
 use medea_jason::{
-    media::MediaManager, AudioTrackConstraints, DeviceVideoTrackConstraints,
-    MediaStreamConstraints,
+    media::{MediaManager, TrackKind},
+    AudioTrackConstraints, DeviceVideoTrackConstraints,
+    DisplayVideoTrackConstraints, MediaStreamSettings,
 };
 
-use crate::{get_jason_error, MockNavigator};
+use crate::{get_jason_error, is_firefox, MockNavigator};
 
 wasm_bindgen_test_configure!(run_in_browser);
 
@@ -54,17 +55,13 @@ async fn failed_get_user_media() {
     mock_navigator.error_get_user_media("failed_get_user_media".into());
     let media_manager = MediaManager::default();
     let constraints = {
-        let mut constraints = MediaStreamConstraints::new();
-        let audio_constraints = AudioTrackConstraints::new();
-        let video_constraints = DeviceVideoTrackConstraints::new();
-
-        constraints.audio(audio_constraints);
-        constraints.device_video(video_constraints);
-
+        let mut constraints = MediaStreamSettings::new();
+        constraints.audio(AudioTrackConstraints::new());
+        constraints.device_video(DeviceVideoTrackConstraints::new());
         constraints
     };
     let result = JsFuture::from(
-        media_manager.new_handle().init_local_stream(constraints),
+        media_manager.new_handle().init_local_stream(&constraints),
     )
     .await;
     mock_navigator.stop();
@@ -92,17 +89,13 @@ async fn failed_get_user_media2() {
     mock_navigator.error_get_user_media(error.into());
     let media_manager = MediaManager::default();
     let constraints = {
-        let mut constraints = MediaStreamConstraints::new();
-        let audio_constraints = AudioTrackConstraints::new();
-        let video_constraints = DeviceVideoTrackConstraints::new();
-
-        constraints.audio(audio_constraints);
-        constraints.device_video(video_constraints);
-
+        let mut constraints = MediaStreamSettings::new();
+        constraints.audio(AudioTrackConstraints::new());
+        constraints.device_video(DeviceVideoTrackConstraints::new());
         constraints
     };
     let result = JsFuture::from(
-        media_manager.new_handle().init_local_stream(constraints),
+        media_manager.new_handle().init_local_stream(&constraints),
     )
     .await;
     mock_navigator.stop();
@@ -119,3 +112,202 @@ async fn failed_get_user_media2() {
         }
     }
 }
+
+/// 1. Do `media_manager.get_stream(caps)`
+/// 2. Only one `getUserMedia` request
+/// 3. Do `media_manager.get_stream(caps)`
+/// 4. Got same track, still one `getUserMedia` request
+#[wasm_bindgen_test]
+async fn same_track_for_same_constraints() {
+    let mock_navigator = MockNavigator::new();
+
+    let media_manager = MediaManager::default();
+    let constraints = {
+        let mut constraints = MediaStreamSettings::new();
+        constraints.audio(AudioTrackConstraints::new());
+        constraints
+    };
+
+    // first request
+    let (stream, is_new) =
+        media_manager.get_stream(constraints.clone()).await.unwrap();
+    let mut tracks = stream.into_tracks();
+
+    assert_eq!(tracks.len(), 1);
+    let track1 = tracks.pop().unwrap();
+
+    assert!(is_new);
+    assert!(track1.kind() == TrackKind::Audio);
+    assert_eq!(mock_navigator.get_user_media_requests_count(), 1);
+
+    // second request, same track, no additional getUserMedia requests
+    let (stream, is_new) =
+        media_manager.get_stream(constraints.clone()).await.unwrap();
+    let mut tracks = stream.into_tracks();
+
+    assert_eq!(tracks.len(), 1);
+    let track2 = tracks.pop().unwrap();
+
+    assert!(!is_new);
+    assert_eq!(track1.id(), track2.id());
+    assert!(track2.kind() == TrackKind::Audio);
+    assert_eq!(mock_navigator.get_user_media_requests_count(), 1);
+}
+
+/// 1. Do `media_manager.get_stream(caps)`
+/// 2. Only one `getUserMedia` request
+/// 3. Drop track,
+/// 4. Do `media_manager.get_stream(caps)`
+/// 5. Got new track and `getUserMedia` requests count = 2.
+#[wasm_bindgen_test]
+async fn new_track_if_previous_dropped() {
+    let mock_navigator = MockNavigator::new();
+
+    let media_manager = MediaManager::default();
+    let constraints = {
+        let mut constraints = MediaStreamSettings::new();
+        constraints.audio(AudioTrackConstraints::new());
+        constraints
+    };
+
+    // first request
+    let (stream, is_new) =
+        media_manager.get_stream(constraints.clone()).await.unwrap();
+    let mut tracks = stream.into_tracks();
+
+    assert_eq!(tracks.len(), 1);
+    let track1 = tracks.pop().unwrap();
+
+    assert!(track1.kind() == TrackKind::Audio);
+    assert!(is_new);
+    assert_eq!(mock_navigator.get_user_media_requests_count(), 1);
+
+    // now drop track, and we got new track and second getUserMedia request
+    let track1_id = track1.id();
+    drop(track1);
+    let (stream, is_new) = media_manager.get_stream(constraints).await.unwrap();
+    let mut tracks = stream.into_tracks();
+
+    assert_eq!(tracks.len(), 1);
+    let track2 = tracks.pop().unwrap();
+
+    assert!(is_new);
+    assert_ne!(track2.id(), track1_id);
+    assert!(track2.kind() == TrackKind::Audio);
+    assert_eq!(mock_navigator.get_user_media_requests_count(), 2);
+
+    mock_navigator.stop();
+}
+
+/// 1. Do `media_manager.get_stream({audio:true, video:true}})`;
+/// 2. Do `media_manager.get_stream({audio:true}})`;
+/// 3. Do `media_manager.get_stream({video:true}})`;
+/// 4. Assert that same tracks were returned and no additional `getUserMedia`
+///    request were made.
+#[wasm_bindgen_test]
+async fn request_audio_video_then_audio_then_video() {
+    let mock_navigator = MockNavigator::new();
+
+    let media_manager = MediaManager::default();
+    let constraints = {
+        let mut constraints = MediaStreamSettings::new();
+        constraints.audio(AudioTrackConstraints::new());
+        constraints.device_video(DeviceVideoTrackConstraints::new());
+        constraints
+    };
+
+    let (stream, is_new) = media_manager.get_stream(constraints).await.unwrap();
+    let (mut audio_tracks, mut video_tracks): (Vec<_>, Vec<_>) = stream
+        .into_tracks()
+        .into_iter()
+        .partition(|track| track.kind() == TrackKind::Audio);
+    assert!(is_new);
+    assert_eq!(audio_tracks.len(), 1);
+    assert_eq!(video_tracks.len(), 1);
+
+    let audio_track = audio_tracks.pop().unwrap();
+    let video_track = video_tracks.pop().unwrap();
+
+    // request audio only
+    let audio_constraints = {
+        let mut constraints = MediaStreamSettings::new();
+        constraints.audio(AudioTrackConstraints::new());
+        constraints
+    };
+    let (stream, is_new) =
+        media_manager.get_stream(audio_constraints).await.unwrap();
+    assert!(!is_new);
+    let mut tracks = stream.into_tracks();
+    assert_eq!(tracks.len(), 1);
+    let audio_track2 = tracks.pop().unwrap();
+
+    // request video only
+    let video_constraints = {
+        let mut constraints = MediaStreamSettings::new();
+        constraints.device_video(DeviceVideoTrackConstraints::new());
+        constraints
+    };
+    let (stream, is_new) =
+        media_manager.get_stream(video_constraints).await.unwrap();
+    assert!(!is_new);
+    let mut tracks = stream.into_tracks();
+    assert_eq!(tracks.len(), 1);
+    let video_track2 = tracks.pop().unwrap();
+
+    assert_eq!(audio_track.id(), audio_track2.id());
+    assert_eq!(video_track.id(), video_track2.id());
+    assert_eq!(mock_navigator.get_user_media_requests_count(), 1);
+    mock_navigator.stop();
+}
+
+/// 1. Do `media_manager.get_stream({audio:true, video:display}})`;
+/// 2. Do `media_manager.get_stream({video:display}})`;
+/// 3. Assert that same track is removed and only one getDisplayMedia request
+///    were made.
+#[wasm_bindgen_test]
+async fn display_track_is_cached() {
+    if is_firefox() {
+        // getDisplayMedia is not mockable in ff atm
+        return;
+    }
+    let mock_navigator = MockNavigator::new();
+
+    let media_manager = MediaManager::default();
+    let constraints = {
+        let mut constraints = MediaStreamSettings::new();
+        constraints.audio(AudioTrackConstraints::new());
+        constraints.display_video(DisplayVideoTrackConstraints::new());
+        constraints
+    };
+
+    let (stream, is_new) = media_manager.get_stream(constraints).await.unwrap();
+    let tracks = stream.into_tracks();
+
+    assert!(is_new);
+    assert_eq!(tracks.len(), 2);
+
+    let video_track = tracks
+        .into_iter()
+        .find(|track| track.kind() == TrackKind::Video)
+        .unwrap();
+
+    // do second request
+    let constraints = {
+        let mut constraints = MediaStreamSettings::new();
+        constraints.display_video(DisplayVideoTrackConstraints::new());
+        constraints
+    };
+
+    let (stream, is_new) = media_manager.get_stream(constraints).await.unwrap();
+    let mut tracks = stream.into_tracks();
+
+    assert!(!is_new);
+    assert_eq!(tracks.len(), 1);
+
+    let video_track2 = tracks.pop().unwrap();
+    assert_eq!(video_track.id(), video_track2.id());
+
+    assert_eq!(mock_navigator.get_display_media_requests_count(), 1);
+    assert_eq!(mock_navigator.get_user_media_requests_count(), 1);
+    mock_navigator.stop();
+}
diff --git a/jason/tests/media/mod.rs b/jason/tests/media/mod.rs
index 1274c372e..3bd03c6b2 100644
--- a/jason/tests/media/mod.rs
+++ b/jason/tests/media/mod.rs
@@ -1,2 +1,3 @@
 mod constraints;
 mod manager;
+mod stream;
diff --git a/jason/tests/media/stream.rs b/jason/tests/media/stream.rs
new file mode 100644
index 000000000..c705cab0a
--- /dev/null
+++ b/jason/tests/media/stream.rs
@@ -0,0 +1,29 @@
+#![cfg(target_arch = "wasm32")]
+
+use medea_jason::{
+    media::MediaManager, DeviceVideoTrackConstraints, MediaStreamSettings,
+};
+use wasm_bindgen_test::*;
+use web_sys::MediaStreamTrackState;
+
+/// Assert that track is stopped when all strong refs are dropped.
+#[wasm_bindgen_test]
+async fn track_autostop() {
+    let media_manager = MediaManager::default();
+    let mut caps = MediaStreamSettings::new();
+    caps.device_video(DeviceVideoTrackConstraints::new());
+
+    let (stream, is_new) = media_manager.get_stream(caps).await.unwrap();
+    assert!(is_new);
+
+    let mut tracks = stream.into_tracks();
+    assert_eq!(1, tracks.len());
+    let strong_track = tracks.pop().unwrap();
+    let sys_track = Clone::clone(strong_track.as_ref());
+    let weak_track = strong_track.downgrade();
+
+    assert!(sys_track.ready_state() == MediaStreamTrackState::Live);
+    drop(strong_track);
+    assert!(sys_track.ready_state() == MediaStreamTrackState::Ended);
+    assert!(!weak_track.can_be_upgraded());
+}
diff --git a/jason/tests/mock_navigator.js b/jason/tests/mock_navigator.js
index 85eb92242..66db48ea5 100644
--- a/jason/tests/mock_navigator.js
+++ b/jason/tests/mock_navigator.js
@@ -1,20 +1,55 @@
 export class MockNavigator {
-  set errorEnumerateDevices(err) {
+  constructor() {
+    let self = this;
+
+    this.getUserMediaInvocations = 0;
+    this.getDisplayMediaInvocations = 0;
+
     this._enumerateDevices = window.navigator.mediaDevices.enumerateDevices;
+    this._getUserMedia = window.navigator.mediaDevices.getUserMedia;
+    this._getDisplayMedia = window.navigator.mediaDevices.getDisplayMedia;
+
+
+    window.navigator.mediaDevices.getUserMedia = async function(arg) {
+      self.getUserMediaInvocations++;
+      return await self._getUserMedia.call(
+        window.navigator.mediaDevices,
+        arg
+      );
+    }
+
+    window.navigator.mediaDevices.getDisplayMedia = async function(arg) {
+      self.getDisplayMediaInvocations++;
+      return await self._getDisplayMedia.call(
+        window.navigator.mediaDevices,
+        arg
+      );
+    }
+  }
+
+  set errorEnumerateDevices(err) {
     window.navigator.mediaDevices.enumerateDevices = async function() {throw err}
   }
 
   set errorGetUserMedia(err) {
-    this._getUserMedia = window.navigator.mediaDevices.getUserMedia;
     window.navigator.mediaDevices.getUserMedia = async function() {throw err}
   }
 
+  set errorGetDisplayMedia(err) {
+    window.navigator.mediaDevices.getDisplayMedia = async function() {throw err}
+  }
+
+  get getUserMediaRequestsCount() {
+    return this.getUserMediaInvocations;
+  }
+
+  get getDisplayMediaRequestsCount() {
+    return this.getDisplayMediaInvocations;
+  }
+
   stop() {
-    if (this._getUserMedia) {
-      window.navigator.mediaDevices.getUserMedia = this._getUserMedia;
-    }
-    if (this._enumerateDevices) {
-      window.navigator.mediaDevices.enumerateDevices = this._enumerateDevices;
-    }
+    window.navigator.mediaDevices.getUserMedia = this._getUserMedia;
+    window.navigator.mediaDevices.getDisplayMedia = this._getDisplayMedia;
+    window.navigator.mediaDevices.enumerateDevices = this._enumerateDevices;
   }
 }
diff --git a/jason/tests/peer/media.rs b/jason/tests/peer/media.rs
index 8226a227e..355dc0564 100644
--- a/jason/tests/peer/media.rs
+++ b/jason/tests/peer/media.rs
@@ -1,8 +1,9 @@
 #![cfg(target_arch = "wasm32")]
 
-use std::{convert::TryFrom, rc::Rc};
+use std::{convert::TryFrom, mem, rc::Rc};
 
-use medea_client_api_proto::{TrackId, TrackPatch};
+use futures::channel::mpsc;
+use medea_client_api_proto::{PeerId, TrackId, TrackPatch};
 use medea_jason::{
     media::MediaManager,
     peer::{
@@ -20,9 +21,13 @@ async fn get_test_media_connections(
     enabled_audio: bool,
     enabled_video: bool,
 ) -> (MediaConnections, TrackId, TrackId) {
-    let media_connections = MediaConnections::new(Rc::new(
-        RtcPeerConnection::new(vec![], false).unwrap(),
-    ));
+    let (tx, rx) = mpsc::unbounded();
+    mem::forget(rx);
+    let media_connections = MediaConnections::new(
+        PeerId(0),
+        Rc::new(RtcPeerConnection::new(vec![], false).unwrap()),
+        tx,
+    );
     let (audio_track, video_track) =
         get_test_tracks(!enabled_audio, !enabled_video);
     let audio_track_id = audio_track.id;
@@ -36,7 +41,7 @@ async fn get_test_media_connections(
     let (stream, _) = manager.get_stream(&caps).await.unwrap();
 
     media_connections
-        .insert_local_stream(&caps.parse_stream(&stream).unwrap())
+        .insert_local_stream(&caps.parse_stream(stream).unwrap())
         .await
         .unwrap();
 
@@ -53,20 +58,31 @@ async fn get_test_media_connections(
 }
 
 #[wasm_bindgen_test]
-fn get_stream_request() {
-    let media_connections = MediaConnections::new(Rc::new(
-        RtcPeerConnection::new(vec![], false).unwrap(),
-    ));
+fn get_stream_request1() {
+    let (tx, rx) = mpsc::unbounded();
+    mem::forget(rx);
+    let media_connections = MediaConnections::new(
+        PeerId(0),
+        Rc::new(RtcPeerConnection::new(vec![], false).unwrap()),
+        tx,
+    );
     let (audio_track, video_track) = get_test_tracks(false, false);
     media_connections
         .update_tracks(vec![audio_track, video_track])
         .unwrap();
     let request = media_connections.get_stream_request();
     assert!(request.is_some());
+}
 
-    let media_connections = MediaConnections::new(Rc::new(
-        RtcPeerConnection::new(vec![], false).unwrap(),
-    ));
+#[wasm_bindgen_test]
+fn get_stream_request2() {
+    let (tx, rx) = mpsc::unbounded();
+    mem::forget(rx);
+    let media_connections = MediaConnections::new(
+        PeerId(0),
+        Rc::new(RtcPeerConnection::new(vec![], false).unwrap()),
+        tx,
+    );
     media_connections.update_tracks(vec![]).unwrap();
     let request = media_connections.get_stream_request();
     assert!(request.is_none());
@@ -91,8 +107,8 @@ async fn disable_and_enable_all_tracks_in_media_manager() {
     let video_track =
         media_connections.get_sender_by_id(video_track_id).unwrap();
 
-    assert!(!audio_track.is_track_muted());
-    assert!(!video_track.is_track_muted());
+    assert!(!audio_track.is_muted());
+    assert!(!video_track.is_muted());
 
     audio_track.mute_state_transition_to(StableMuteState::Muted);
     media_connections
@@ -101,8 +117,8 @@ async fn disable_and_enable_all_tracks_in_media_manager() {
             is_muted: Some(true),
         }])
         .unwrap();
-    assert!(audio_track.is_track_muted());
-    assert!(!video_track.is_track_muted());
+    assert!(audio_track.is_muted());
+    assert!(!video_track.is_muted());
 
     video_track.mute_state_transition_to(StableMuteState::Muted);
     media_connections
@@ -111,8 +127,8 @@ async fn disable_and_enable_all_tracks_in_media_manager() {
             is_muted: Some(true),
         }])
         .unwrap();
-    assert!(audio_track.is_track_muted());
-    assert!(video_track.is_track_muted());
+    assert!(audio_track.is_muted());
+    assert!(video_track.is_muted());
 
     audio_track.mute_state_transition_to(StableMuteState::NotMuted);
     media_connections
@@ -121,8 +137,8 @@ async fn disable_and_enable_all_tracks_in_media_manager() {
             is_muted: Some(false),
         }])
         .unwrap();
-    assert!(!audio_track.is_track_muted());
-    assert!(video_track.is_track_muted());
+    assert!(!audio_track.is_muted());
+    assert!(video_track.is_muted());
 
     video_track.mute_state_transition_to(StableMuteState::NotMuted);
     media_connections
@@ -131,8 +147,8 @@ async fn disable_and_enable_all_tracks_in_media_manager() {
             is_muted: Some(false),
         }])
         .unwrap();
-    assert!(!audio_track.is_track_muted());
-    assert!(!video_track.is_track_muted());
+    assert!(!audio_track.is_muted());
+    assert!(!video_track.is_muted());
 }
 
 #[wasm_bindgen_test]
@@ -145,8 +161,8 @@ async fn new_media_connections_with_disabled_audio_tracks() {
     let video_track =
         media_connections.get_sender_by_id(video_track_id).unwrap();
 
-    assert!(audio_track.is_track_muted());
-    assert!(!video_track.is_track_muted());
+    assert!(audio_track.is_muted());
+    assert!(!video_track.is_muted());
 }
 
 #[wasm_bindgen_test]
@@ -159,8 +175,8 @@ async fn new_media_connections_with_disabled_video_tracks() {
     let video_track =
         media_connections.get_sender_by_id(video_track_id).unwrap();
 
-    assert!(!audio_track.is_track_muted());
-    assert!(video_track.is_track_muted());
+    assert!(!audio_track.is_muted());
+    assert!(video_track.is_muted());
 }
 
 /// Tests for [`Sender::update`] function.
@@ -189,7 +205,7 @@ mod sender_patch {
             is_muted: Some(true),
         });
 
-        assert!(!sender.is_track_muted());
+        assert!(!sender.is_muted());
     }
 
     #[wasm_bindgen_test]
@@ -200,7 +216,7 @@ mod sender_patch {
             is_muted: Some(true),
         });
 
-        assert!(sender.is_track_muted());
+        assert!(sender.is_muted());
     }
 
     #[wasm_bindgen_test]
@@ -211,7 +227,7 @@ mod sender_patch {
             is_muted: Some(false),
         });
 
-        assert!(!sender.is_track_muted());
+        assert!(!sender.is_muted());
     }
 
     #[wasm_bindgen_test]
@@ -221,14 +237,14 @@ mod sender_patch {
             id: track_id,
             is_muted: Some(true),
         });
-        assert!(sender.is_track_muted());
+        assert!(sender.is_muted());
 
         sender.update(&TrackPatch {
             id: track_id,
             is_muted: Some(true),
         });
 
-        assert!(sender.is_track_muted());
+        assert!(sender.is_muted());
     }
 
     #[wasm_bindgen_test]
@@ -239,6 +255,6 @@ mod sender_patch {
             is_muted: None,
         });
 
-        assert!(!sender.is_track_muted());
+        assert!(!sender.is_muted());
     }
 }
diff --git a/jason/tests/web.rs b/jason/tests/web.rs
index 478a3c46e..e0a78fe75 100644
--- a/jason/tests/web.rs
+++ b/jason/tests/web.rs
@@ -104,9 +104,18 @@ extern "C" {
     #[wasm_bindgen(method, setter = errorGetUserMedia)]
     fn error_get_user_media(this: &MockNavigator, err: JsValue);
 
+    #[wasm_bindgen(method, setter = errorGetDisplayMedia)]
+    fn error_get_display_media(this: &MockNavigator, err: JsValue);
+
     #[wasm_bindgen(method, setter = errorEnumerateDevices)]
     fn error_enumerate_devices(this: &MockNavigator, err: JsValue);
 
+    #[wasm_bindgen(method, getter = getUserMediaRequestsCount)]
+    fn get_user_media_requests_count(this: &MockNavigator) -> i32;
+
+    #[wasm_bindgen(method, getter = getDisplayMediaRequestsCount)]
+    fn get_display_media_requests_count(this: &MockNavigator) -> i32;
+
     #[wasm_bindgen(method)]
     fn stop(this: &MockNavigator);
 }
@@ -191,3 +200,11 @@ async fn await_with_timeout<T>(
         Either::Right((_, _)) => Err("Future timed out.".to_string()),
     }
 }
+
+// TODO: Might be extended to proc macro at some point.
+#[wasm_bindgen(inline_js = "export function is_firefox() { return \
+                            navigator.userAgent.toLowerCase().indexOf('\
+                            firefox') > -1; }")]
+extern "C" {
+    fn is_firefox() -> bool;
+}
diff --git a/jason/webdriver.json b/jason/webdriver.json
index 8cbf06329..c2d6865e6 100644
--- a/jason/webdriver.json
+++ b/jason/webdriver.json
@@ -1,7 +1,8 @@
 {
   "moz:firefoxOptions": {
     "prefs": {
-      "media.navigator.streams.fake": true
+      "media.navigator.streams.fake": true,
+      "media.navigator.permission.disabled": true
     },
     "args": []
   },
diff --git a/mock/control-api/src/api/endpoint.rs b/mock/control-api/src/api/endpoint.rs
index b2f88ba47..b750d5371 100644
--- a/mock/control-api/src/api/endpoint.rs
+++ b/mock/control-api/src/api/endpoint.rs
@@ -13,22 +13,24 @@ pub enum P2pMode {
 
 impl Into<proto::web_rtc_publish_endpoint::P2p> for P2pMode {
     fn into(self) -> proto::web_rtc_publish_endpoint::P2p {
-        use proto::web_rtc_publish_endpoint::P2p::*;
+        use proto::web_rtc_publish_endpoint::P2p;
+
         match self {
-            Self::Always => Always,
-            Self::IfPossible => IfPossible,
-            Self::Never => Never,
+            Self::Always => P2p::Always,
+            Self::IfPossible => P2p::IfPossible,
+            Self::Never => P2p::Never,
         }
     }
 }
 
 impl From<proto::web_rtc_publish_endpoint::P2p> for P2pMode {
     fn from(proto: proto::web_rtc_publish_endpoint::P2p) -> Self {
-        use proto::web_rtc_publish_endpoint::P2p::*;
+        use proto::web_rtc_publish_endpoint::P2p;
+
         match proto {
-            Always => Self::Always,
-            IfPossible => Self::IfPossible,
-            Never => Self::Never,
+            P2p::Always => Self::Always,
+            P2p::IfPossible => Self::IfPossible,
+            P2p::Never => Self::Never,
         }
     }
 }
diff --git a/mock/control-api/src/api/mod.rs b/mock/control-api/src/api/mod.rs
index efac05a78..3c755fcc1 100644
--- a/mock/control-api/src/api/mod.rs
+++ b/mock/control-api/src/api/mod.rs
@@ -143,7 +143,7 @@ pub async fn get_callbacks(state: Data<Context>) -> Result<HttpResponse, ()> {
 /// [Control API]: https://tinyurl.com/yxsqplq7
 #[allow(clippy::needless_pass_by_value)]
 mod delete {
-    use super::*;
+    use super::{error, Context, Data, HttpResponse, Response};
 
     gen_request_macro!(delete, Response);
 
@@ -157,7 +157,7 @@ mod delete {
 /// [Control API]: https://tinyurl.com/yxsqplq7
 #[allow(clippy::needless_pass_by_value)]
 mod get {
-    use super::*;
+    use super::{error, Context, Data, HttpResponse, SingleGetResponse};
 
     gen_request_macro!(get, SingleGetResponse);
 
@@ -171,7 +171,9 @@ mod get {
 /// [Control API]: https://tinyurl.com/yxsqplq7
 #[allow(clippy::needless_pass_by_value)]
 mod create {
-    use super::*;
+    use super::{
+        error, Context, CreateResponse, Data, Element, Fid, HttpResponse, Json,
+    };
 
     pub async fn create1(
         path: actix_web::web::Path<String>,
@@ -345,14 +347,15 @@ impl Element {
 
 impl From<proto::Element> for Element {
     fn from(proto: proto::Element) -> Self {
-        use proto::element::El::*;
+        use proto::element::El;
+
         match proto.el.unwrap() {
-            Room(room) => Self::Room(room.into()),
-            Member(member) => Self::Member(member.into()),
-            WebrtcPub(webrtc_pub) => {
+            El::Room(room) => Self::Room(room.into()),
+            El::Member(member) => Self::Member(member.into()),
+            El::WebrtcPub(webrtc_pub) => {
                 Self::WebRtcPublishEndpoint(webrtc_pub.into())
             }
-            WebrtcPlay(webrtc_play) => {
+            El::WebrtcPlay(webrtc_play) => {
                 Self::WebRtcPlayEndpoint(webrtc_play.into())
             }
         }
diff --git a/mock/control-api/src/callback/mod.rs b/mock/control-api/src/callback/mod.rs
index 9102bc72d..7834ed174 100644
--- a/mock/control-api/src/callback/mod.rs
+++ b/mock/control-api/src/callback/mod.rs
@@ -102,11 +102,12 @@ mod leave {
 
     impl From<proto::on_leave::Reason> for OnLeaveReason {
         fn from(proto: proto::on_leave::Reason) -> Self {
-            use proto::on_leave::Reason::*;
+            use proto::on_leave::Reason as R;
+
             match proto {
-                ServerShutdown => Self::ServerShutdown,
-                LostConnection => Self::LostConnection,
-                Disconnected => Self::Disconnected,
+                R::ServerShutdown => Self::ServerShutdown,
+                R::LostConnection => Self::LostConnection,
+                R::Disconnected => Self::Disconnected,
             }
         }
     }
diff --git a/mock/control-api/src/client.rs b/mock/control-api/src/client.rs
index fbc350c05..e81d20e4e 100644
--- a/mock/control-api/src/client.rs
+++ b/mock/control-api/src/client.rs
@@ -94,16 +94,16 @@ impl ControlClient {
         fid: Fid,
         element: Element,
     ) -> Result<proto::CreateResponse, Status> {
-        use proto::create_request::El::*;
+        use proto::create_request::El;
 
         let el = match element {
-            Element::Room(room) => Room(room.into_proto(id)),
-            Element::Member(member) => Member(member.into_proto(id)),
+            Element::Room(room) => El::Room(room.into_proto(id)),
+            Element::Member(member) => El::Member(member.into_proto(id)),
             Element::WebRtcPlayEndpoint(webrtc_play) => {
-                WebrtcPlay(webrtc_play.into_proto(id))
+                El::WebrtcPlay(webrtc_play.into_proto(id))
             }
             Element::WebRtcPublishEndpoint(webrtc_pub) => {
-                WebrtcPub(webrtc_pub.into_proto(id))
+                El::WebrtcPub(webrtc_pub.into_proto(id))
             }
         };
         let req = proto::CreateRequest {
diff --git a/src/api/control/callback/clients/grpc.rs b/src/api/control/callback/clients/grpc.rs
index b6d510996..c57c58b0f 100644
--- a/src/api/control/callback/clients/grpc.rs
+++ b/src/api/control/callback/clients/grpc.rs
@@ -29,7 +29,8 @@ impl GrpcCallbackClient {
     ///
     /// # Errors
     ///
-    /// If establishing gRPC connection fails.
+    /// With [`CallbackClientError::TonicTransport`] if [`tonic`] transport
+    /// cannot be created (so gRPC connection cannot be established).
     pub async fn new(
         addr: &GrpcCallbackUrl,
     ) -> Result<Self, CallbackClientError> {
diff --git a/src/api/control/endpoints/mod.rs b/src/api/control/endpoints/mod.rs
index 6708b990a..ea6ecd3db 100644
--- a/src/api/control/endpoints/mod.rs
+++ b/src/api/control/endpoints/mod.rs
@@ -72,13 +72,14 @@ impl TryFrom<(Id, proto::member::element::El)> for EndpointSpec {
     fn try_from(
         (_, proto): (Id, proto::member::element::El),
     ) -> Result<Self, Self::Error> {
-        use proto::member::element::El::*;
+        use proto::member::element::El;
+
         match proto {
-            WebrtcPlay(elem) => {
+            El::WebrtcPlay(elem) => {
                 let play = WebRtcPlayEndpoint::try_from(&elem)?;
                 Ok(Self::WebRtcPlay(play))
             }
-            WebrtcPub(elem) => {
+            El::WebrtcPub(elem) => {
                 let publish = WebRtcPublishEndpoint::from(&elem);
                 Ok(Self::WebRtcPublish(publish))
             }
@@ -92,17 +93,18 @@ impl TryFrom<(Id, proto::create_request::El)> for EndpointSpec {
     fn try_from(
         (id, proto): (Id, proto::create_request::El),
     ) -> Result<Self, Self::Error> {
-        use proto::create_request::El::*;
+        use proto::create_request::El;
+
         match proto {
-            WebrtcPlay(elem) => {
+            El::WebrtcPlay(elem) => {
                 let play = WebRtcPlayEndpoint::try_from(&elem)?;
                 Ok(Self::WebRtcPlay(play))
             }
-            WebrtcPub(elem) => {
+            El::WebrtcPub(elem) => {
                 let publish = WebRtcPublishEndpoint::from(&elem);
                 Ok(Self::WebRtcPublish(publish))
             }
-            Member(_) | Room(_) => {
+            El::Member(_) | El::Room(_) => {
                 Err(TryFromProtobufError::ExpectedOtherElement(
                     String::from("Endpoint"),
                     id.0,
diff --git a/src/api/control/endpoints/webrtc_publish_endpoint.rs b/src/api/control/endpoints/webrtc_publish_endpoint.rs
index 521a32365..59724a34c 100644
--- a/src/api/control/endpoints/webrtc_publish_endpoint.rs
+++ b/src/api/control/endpoints/webrtc_publish_endpoint.rs
@@ -28,22 +28,24 @@ pub enum P2pMode {
 
 impl From<proto::web_rtc_publish_endpoint::P2p> for P2pMode {
     fn from(value: proto::web_rtc_publish_endpoint::P2p) -> Self {
-        use proto::web_rtc_publish_endpoint::P2p::*;
+        use proto::web_rtc_publish_endpoint::P2p;
+
         match value {
-            Always => Self::Always,
-            IfPossible => Self::IfPossible,
-            Never => Self::Never,
+            P2p::Always => Self::Always,
+            P2p::IfPossible => Self::IfPossible,
+            P2p::Never => Self::Never,
         }
     }
 }
 
 impl Into<proto::web_rtc_publish_endpoint::P2p> for P2pMode {
     fn into(self) -> proto::web_rtc_publish_endpoint::P2p {
-        use proto::web_rtc_publish_endpoint::P2p::*;
+        use proto::web_rtc_publish_endpoint::P2p;
+
         match self {
-            Self::Always => Always,
-            Self::IfPossible => IfPossible,
-            Self::Never => Never,
+            Self::Always => P2p::Always,
+            Self::IfPossible => P2p::IfPossible,
+            Self::Never => P2p::Never,
         }
     }
 }
diff --git a/src/api/control/error_codes.rs b/src/api/control/error_codes.rs
index f3947f1e5..1885a81cb 100644
--- a/src/api/control/error_codes.rs
+++ b/src/api/control/error_codes.rs
@@ -298,7 +298,9 @@ pub enum ErrorCode {
 
 impl From<ParticipantServiceErr> for ErrorResponse {
     fn from(err: ParticipantServiceErr) -> Self {
-        use ParticipantServiceErr::*;
+        use ParticipantServiceErr::{
+            EndpointNotFound, MemberError, ParticipantNotFound,
+        };
 
         match err {
             EndpointNotFound(id) => Self::new(ErrorCode::EndpointNotFound, &id),
@@ -312,12 +314,12 @@ impl From<ParticipantServiceErr> for ErrorResponse {
 
 impl From<TryFromProtobufError> for ErrorResponse {
     fn from(err: TryFromProtobufError) -> Self {
-        use TryFromProtobufError::*;
+        use TryFromProtobufError as E;
 
         match err {
-            SrcUriError(e) => e.into(),
-            CallbackUrlParseErr(e) => e.into(),
-            NotMemberElementInRoomElement(id) => Self::with_explanation(
+            E::SrcUriError(e) => e.into(),
+            E::CallbackUrlParseErr(e) => e.into(),
+            E::NotMemberElementInRoomElement(id) => Self::with_explanation(
                 ErrorCode::UnimplementedCall,
                 String::from(
                     "Not Member elements in Room element currently is \
@@ -325,12 +327,12 @@ impl From<TryFromProtobufError> for ErrorResponse {
                 ),
                 Some(id),
             ),
-            UnimplementedEndpoint(id) => Self::with_explanation(
+            E::UnimplementedEndpoint(id) => Self::with_explanation(
                 ErrorCode::UnimplementedCall,
                 String::from("Endpoint is not implemented."),
                 Some(id),
             ),
-            ExpectedOtherElement(element, id) => Self::with_explanation(
+            E::ExpectedOtherElement(element, id) => Self::with_explanation(
                 ErrorCode::ElementIdMismatch,
                 format!(
                     "Provided fid can not point to element of type [{}]",
@@ -338,12 +340,12 @@ impl From<TryFromProtobufError> for ErrorResponse {
                 ),
                 Some(id),
             ),
-            EmptyElement(id) => Self::with_explanation(
+            E::EmptyElement(id) => Self::with_explanation(
                 ErrorCode::NoElement,
                 String::from("No element was provided"),
                 Some(id),
             ),
-            NegativeDuration(id, field) => Self::with_explanation(
+            E::NegativeDuration(id, field) => Self::with_explanation(
                 ErrorCode::NegativeDuration,
                 format!(
                     "Element [id = {}] contains negative duration field `{}`",
@@ -357,25 +359,29 @@ impl From<TryFromProtobufError> for ErrorResponse {
 
 impl From<LocalUriParseError> for ErrorResponse {
     fn from(err: LocalUriParseError) -> Self {
-        use LocalUriParseError::*;
+        use LocalUriParseError as E;
 
         match err {
-            NotLocal(text) => Self::new(ErrorCode::ElementIdIsNotLocal, &text),
-            TooManyPaths(text) => {
+            E::NotLocal(text) => {
+                Self::new(ErrorCode::ElementIdIsNotLocal, &text)
+            }
+            E::TooManyPaths(text) => {
                 Self::new(ErrorCode::ElementIdIsTooLong, &text)
             }
-            Empty => Self::without_id(ErrorCode::EmptyElementId),
-            MissingPaths(text) => {
+            E::Empty => Self::without_id(ErrorCode::EmptyElementId),
+            E::MissingPaths(text) => {
                 Self::new(ErrorCode::MissingFieldsInSrcUri, &text)
             }
-            UrlParseErr(id, _) => Self::new(ErrorCode::InvalidSrcUri, &id),
+            E::UrlParseErr(id, _) => Self::new(ErrorCode::InvalidSrcUri, &id),
         }
     }
 }
 
 impl From<CallbackUrlParseError> for ErrorResponse {
     fn from(err: CallbackUrlParseError) -> Self {
-        use CallbackUrlParseError::*;
+        use CallbackUrlParseError::{
+            MissingHost, UnsupportedScheme, UrlParseErr,
+        };
 
         match err {
             MissingHost => {
@@ -391,7 +397,7 @@ impl From<CallbackUrlParseError> for ErrorResponse {
 
 impl From<ParseFidError> for ErrorResponse {
     fn from(err: ParseFidError) -> Self {
-        use ParseFidError::*;
+        use ParseFidError::{Empty, MissingPath, TooManyPaths};
 
         match err {
             TooManyPaths(text) => {
@@ -405,42 +411,41 @@ impl From<ParseFidError> for ErrorResponse {
 
 impl From<RoomError> for ErrorResponse {
     fn from(err: RoomError) -> Self {
-        use RoomError::*;
+        use RoomError as E;
 
         match err {
-            MemberError(e) => e.into(),
-            MembersLoadError(e) => e.into(),
-            ParticipantServiceErr(e) => e.into(),
-            MemberAlreadyExists(id) => {
+            E::MemberError(e) => e.into(),
+            E::MembersLoadError(e) => e.into(),
+            E::ParticipantServiceErr(e) => e.into(),
+            E::MemberAlreadyExists(id) => {
                 Self::new(ErrorCode::MemberAlreadyExists, &id)
             }
-            EndpointAlreadyExists(id) => {
+            E::EndpointAlreadyExists(id) => {
                 Self::new(ErrorCode::EndpointAlreadyExists, &id)
             }
-            WrongRoomId(_, _)
-            | PeerNotFound(_)
-            | NoTurnCredentials(_)
-            | ConnectionNotExists(_)
-            | UnableToSendEvent(_)
-            | PeerError(_)
-            | BadRoomSpec(_)
-            | TurnServiceErr(_) => Self::unexpected(&err),
+            E::WrongRoomId(_, _)
+            | E::PeerNotFound(_)
+            | E::NoTurnCredentials(_)
+            | E::ConnectionNotExists(_)
+            | E::UnableToSendEvent(_)
+            | E::PeerError(_)
+            | E::BadRoomSpec(_)
+            | E::TurnServiceErr(_) => Self::unexpected(&err),
         }
     }
 }
 
 impl From<MembersLoadError> for ErrorResponse {
     fn from(err: MembersLoadError) -> Self {
-        use MembersLoadError::*;
+        use MembersLoadError::{
+            EndpointNotFound, MemberNotFound, TryFromError,
+        };
+        use TryFromElementError::{NotMember, NotRoom};
 
         match err {
             TryFromError(e, id) => match e {
-                TryFromElementError::NotMember => {
-                    Self::new(ErrorCode::NotMemberInSpec, &id)
-                }
-                TryFromElementError::NotRoom => {
-                    Self::new(ErrorCode::NotRoomInSpec, &id)
-                }
+                NotMember => Self::new(ErrorCode::NotMemberInSpec, &id),
+                NotRoom => Self::new(ErrorCode::NotRoomInSpec, &id),
             },
             MemberNotFound(id) => Self::new(ErrorCode::MemberNotFound, &id),
             EndpointNotFound(id) => Self::new(ErrorCode::EndpointNotFound, &id),
@@ -460,7 +465,7 @@ impl From<MemberError> for ErrorResponse {
 
 impl From<SrcParseError> for ErrorResponse {
     fn from(err: SrcParseError) -> Self {
-        use SrcParseError::*;
+        use SrcParseError::{LocalUriParseError, NotSrcUri};
 
         match err {
             NotSrcUri(text) => Self::new(ErrorCode::NotSourceUri, &text),
@@ -471,16 +476,16 @@ impl From<SrcParseError> for ErrorResponse {
 
 impl From<RoomServiceError> for ErrorResponse {
     fn from(err: RoomServiceError) -> Self {
-        use RoomServiceError::*;
+        use RoomServiceError as E;
 
         match err {
-            RoomNotFound(id) => Self::new(ErrorCode::RoomNotFound, &id),
-            RoomAlreadyExists(id) => {
+            E::RoomNotFound(id) => Self::new(ErrorCode::RoomNotFound, &id),
+            E::RoomAlreadyExists(id) => {
                 Self::new(ErrorCode::RoomAlreadyExists, &id)
             }
-            RoomError(e) => e.into(),
-            EmptyUrisList => Self::without_id(ErrorCode::EmptyElementsList),
-            NotSameRoomIds(id1, id2) => Self::with_explanation(
+            E::RoomError(e) => e.into(),
+            E::EmptyUrisList => Self::without_id(ErrorCode::EmptyElementsList),
+            E::NotSameRoomIds(id1, id2) => Self::with_explanation(
                 ErrorCode::ProvidedNotSameRoomIds,
                 format!(
                     "All FID's must have equal room_id. Provided Id's are \
@@ -489,22 +494,22 @@ impl From<RoomServiceError> for ErrorResponse {
                 ),
                 None,
             ),
-            RoomMailboxErr(_)
-            | FailedToLoadStaticSpecs(_)
-            | TryFromElement(_) => Self::unexpected(&err),
+            E::RoomMailboxErr(_)
+            | E::FailedToLoadStaticSpecs(_)
+            | E::TryFromElement(_) => Self::unexpected(&err),
         }
     }
 }
 
 impl From<GrpcControlApiError> for ErrorResponse {
     fn from(err: GrpcControlApiError) -> Self {
-        use GrpcControlApiError::*;
+        use GrpcControlApiError as E;
 
         match err {
-            Fid(e) => e.into(),
-            TryFromProtobuf(e) => e.into(),
-            RoomServiceError(e) => e.into(),
-            RoomServiceMailboxError(_) => Self::unexpected(&err),
+            E::Fid(e) => e.into(),
+            E::TryFromProtobuf(e) => e.into(),
+            E::RoomServiceError(e) => e.into(),
+            E::RoomServiceMailboxError(_) => Self::unexpected(&err),
         }
     }
 }
diff --git a/src/signalling/room.rs b/src/signalling/room.rs
index b693c52cf..a718dc267 100644
--- a/src/signalling/room.rs
+++ b/src/signalling/room.rs
@@ -631,15 +631,17 @@ impl Room {
         &self,
         command: &CommandMessage,
     ) -> Result<(), CommandValidationError> {
-        use Command::*;
-        use CommandValidationError::*;
+        use Command as C;
+        use CommandValidationError::{
+            PeerBelongsToAnotherMember, PeerNotFound,
+        };
 
         let peer_id = match command.command {
-            MakeSdpOffer { peer_id, .. }
-            | MakeSdpAnswer { peer_id, .. }
-            | SetIceCandidate { peer_id, .. }
-            | AddPeerConnectionMetrics { peer_id, .. }
-            | UpdateTracks { peer_id, .. } => peer_id,
+            C::MakeSdpOffer { peer_id, .. }
+            | C::MakeSdpAnswer { peer_id, .. }
+            | C::SetIceCandidate { peer_id, .. }
+            | C::AddPeerConnectionMetrics { peer_id, .. }
+            | C::UpdateTracks { peer_id, .. } => peer_id,
         };
 
         let peer = self
diff --git a/src/turn/allocation_event.rs b/src/turn/allocation_event.rs
index 73bba2404..e68f1bb14 100644
--- a/src/turn/allocation_event.rs
+++ b/src/turn/allocation_event.rs
@@ -101,23 +101,24 @@ impl CoturnEvent {
     pub fn parse(
         msg: &redis_pub_sub::Msg,
     ) -> Result<Self, CoturnEventParseError> {
-        use CoturnEventParseError::*;
+        use CoturnEventParseError as E;
 
-        let channel: String = msg.get_channel().map_err(|_| NoChannelInfo)?;
+        let channel: String =
+            msg.get_channel().map_err(|_| E::NoChannelInfo)?;
         let mut channel_splitted = channel.split('/').skip(4);
 
         let (room_id, peer_id) = {
-            let user = channel_splitted.next().ok_or(NoUserInfo)?;
+            let user = channel_splitted.next().ok_or(E::NoUserInfo)?;
             let mut user_splitted = user.split('_');
             let room_id = RoomId::from(
-                user_splitted.next().ok_or(NoMemberId)?.to_string(),
+                user_splitted.next().ok_or(E::NoMemberId)?.to_string(),
             );
             let peer_id = PeerId(
                 user_splitted
                     .next()
-                    .ok_or(NoPeerId)?
+                    .ok_or(E::NoPeerId)?
                     .parse()
-                    .map_err(|_| NoPeerId)?,
+                    .map_err(|_| E::NoPeerId)?,
             );
 
             (room_id, peer_id)
@@ -127,15 +128,15 @@ impl CoturnEvent {
 
         let allocation_id: u64 = channel_splitted
             .next()
-            .ok_or(NoAllocationId)?
+            .ok_or(E::NoAllocationId)?
             .parse()
-            .map_err(|_| NoAllocationId)?;
-        let event_type = channel_splitted.next().ok_or(NoEventType)?;
+            .map_err(|_| E::NoAllocationId)?;
+        let event_type = channel_splitted.next().ok_or(E::NoEventType)?;
 
         let event = CoturnAllocationEvent::parse(
             event_type,
             msg.get_payload::<String>()
-                .map_err(|_| WrongPayloadType)?
+                .map_err(|_| E::WrongPayloadType)?
                 .as_str(),
         )?;
 
@@ -194,7 +195,10 @@ impl CoturnAllocationEvent {
         event_type: &str,
         body: &str,
     ) -> Result<Self, CoturnEventParseError> {
-        use CoturnEventParseError::*;
+        use CoturnEventParseError::{
+            EmptyStatus, FailedLifetimeParsing, NoMetadataInStatus,
+            UnsupportedEventType, UnsupportedStatus,
+        };
 
         match event_type {
             "total_traffic" => Ok(CoturnAllocationEvent::TotalTraffic {
@@ -262,7 +266,9 @@ impl Traffic {
     /// All errors from this function should never happen, so there is no sense
     /// to catch them individually.
     pub fn parse(body: &str) -> Result<Self, CoturnEventParseError> {
-        use CoturnEventParseError::*;
+        use CoturnEventParseError::{
+            FailedToParseTrafficMap, FieldNotFoundInTrafficUpdate,
+        };
 
         let mut items: HashMap<&str, u64> = body
             .split(", ")
diff --git a/src/turn/cli.rs b/src/turn/cli.rs
index c0f82bba3..7c70963d0 100644
--- a/src/turn/cli.rs
+++ b/src/turn/cli.rs
@@ -61,6 +61,14 @@ impl CoturnTelnetClient {
     /// - deleting all retrieved `users`' sessions fails.
     ///
     /// [Coturn]: https://github.com/coturn/coturn
+    ///
+    /// # Errors
+    ///
+    /// With [`CoturnCliError::PoolError`] if could not get or establish new
+    /// connection in pool.
+    ///
+    /// With [`CoturnCliError::CoturnTelnetError`] in case of unexpected
+    /// protocol error.
     pub async fn delete_sessions(
         &self,
         users: &[&IceUser],