diff --git a/cms/djangoapps/contentstore/tests/test_libraries.py b/cms/djangoapps/contentstore/tests/test_libraries.py
index bb692c016033..e7dcc3647886 100644
--- a/cms/djangoapps/contentstore/tests/test_libraries.py
+++ b/cms/djangoapps/contentstore/tests/test_libraries.py
@@ -96,9 +96,9 @@ def _add_simple_content_block(self):
             user_id=self.user.id, publish_item=False
         )
 
-    def _refresh_children(self, lib_content_block, status_code_expected=200):
+    def _upgrade_and_sync(self, lib_content_block, status_code_expected=200):
         """
-        Helper method: Uses the REST API to call the 'refresh_children' handler
+        Helper method: Uses the REST API to call the 'upgrade_and_sync' handler
         of a LibraryContent block
         """
         if 'user' not in lib_content_block.runtime._services:  # pylint: disable=protected-access
@@ -106,9 +106,9 @@ def _refresh_children(self, lib_content_block, status_code_expected=200):
             lib_content_block.runtime._services['user'] = user_service  # pylint: disable=protected-access
 
         handler_url = reverse_usage_url(
-            'component_handler',
+            'preview_handler',
             lib_content_block.location,
-            kwargs={'handler': 'refresh_children'}
+            kwargs={'handler': 'upgrade_and_sync'}
         )
         response = self.client.ajax_post(handler_url)
         self.assertEqual(response.status_code, status_code_expected)
@@ -171,7 +171,7 @@ def test_max_items(self, num_to_create, num_to_select, num_expected):
 
         lc_block = self._add_library_content_block(course, self.lib_key, other_settings={'max_count': num_to_select})
         self.assertEqual(len(lc_block.children), 0)
-        lc_block = self._refresh_children(lc_block)
+        lc_block = self._upgrade_and_sync(lc_block)
 
         # Now, we want to make sure that .children has the total # of potential
         # children, and that get_child_blocks() returns the actual children
@@ -198,7 +198,7 @@ def test_consistent_children(self):
 
         lc_block = self._add_library_content_block(course, self.lib_key, {'max_count': 1})
         lc_block_key = lc_block.location
-        lc_block = self._refresh_children(lc_block)
+        lc_block = self._upgrade_and_sync(lc_block)
 
         def get_child_of_lc_block(block):
             """
@@ -231,7 +231,7 @@ def check():
 
         check()
         # Refresh the children:
-        lc_block = self._refresh_children(lc_block)
+        lc_block = self._upgrade_and_sync(lc_block)
         # Now re-load the block and try yet again, in case refreshing the children changed anything:
         check()
 
@@ -251,7 +251,7 @@ def test_definition_shared_with_library(self):
 
         # Add a LibraryContent block to the course:
         lc_block = self._add_library_content_block(course, self.lib_key)
-        lc_block = self._refresh_children(lc_block)
+        lc_block = self._upgrade_and_sync(lc_block)
         for child_key in lc_block.children:
             child = modulestore().get_item(child_key)
             def_id = child.definition_locator.definition_id
@@ -281,7 +281,7 @@ def test_fields(self):
 
         # Add a LibraryContent block to the course:
         lc_block = self._add_library_content_block(course, self.lib_key)
-        lc_block = self._refresh_children(lc_block)
+        lc_block = self._upgrade_and_sync(lc_block)
         course_block = modulestore().get_item(lc_block.children[0])
 
         self.assertEqual(course_block.data, data_value)
@@ -317,7 +317,7 @@ def test_block_with_children(self):
 
         # Add a LibraryContent block to the course:
         lc_block = self._add_library_content_block(course, self.lib_key)
-        lc_block = self._refresh_children(lc_block)
+        lc_block = self._upgrade_and_sync(lc_block)
         self.assertEqual(len(lc_block.children), 1)
         course_vert_block = modulestore().get_item(lc_block.children[0])
         self.assertEqual(len(course_vert_block.children), 1)
@@ -326,10 +326,11 @@ def test_block_with_children(self):
         self.assertEqual(course_child_block.data, data_value)
         self.assertEqual(course_child_block.display_name, name_value)
 
-    def test_change_after_first_sync(self):
+    def test_switch_to_unknown_source_library_preserves_settings(self):
         """
-        Check that nothing goes wrong if we (A) Set up a LibraryContent block
-        and use it successfully, then (B) Give it an invalid configuration.
+        Check that nothing goes wrong if we (A) set up a LibraryContent block
+        and use it successfully, then (B) give it an invalid source lib, and then
+        (C) try to upgrade the source library version.
         No children should be deleted until the configuration is fixed.
         """
         # Add a block to the library:
@@ -348,31 +349,58 @@ def test_change_after_first_sync(self):
 
         # Add a LibraryContent block to the course:
         lc_block = self._add_library_content_block(course, self.lib_key)
-        lc_block = self._refresh_children(lc_block)
+        lc_block = self._upgrade_and_sync(lc_block)
+        good_library_id = lc_block.source_library_id
+        good_library_version = lc_block.source_library_version
+        assert good_library_id
+        assert good_library_version
         self.assertEqual(len(lc_block.children), 1)
+        self.assertEqual(modulestore().get_item(lc_block.children[0]).data, data_value)
 
         # Now, change the block settings to have an invalid library key:
+        bad_library_id = "library-v1:NOT+FOUND"
         resp = self._update_block(
             lc_block.location,
-            {"source_library_id": "library-v1:NOT+FOUND"},
+            {"source_library_id": bad_library_id},
         )
         self.assertEqual(resp.status_code, 200)
+
         lc_block = modulestore().get_item(lc_block.location)
-        self.assertEqual(len(lc_block.children), 1)  # Children should not be deleted due to a bad setting.
-        html_block = modulestore().get_item(lc_block.children[0])
-        self.assertEqual(html_block.data, data_value)
+        # Source library id should be set to the new bad one...
+        assert lc_block.source_library_id == bad_library_id
+        # ...but old source library version should be preserved...
+        assert lc_block.source_library_version == good_library_version
+        # ...and children should not be deleted due to a bad setting.
+        self.assertEqual(len(lc_block.children), 1)
+        self.assertEqual(modulestore().get_item(lc_block.children[0]).data, data_value)
 
-    def test_refreshes_children_if_libraries_change(self):
-        """ Tests that children are automatically refreshed if libraries list changes """
+        # Attempting to force an upgrade (the user would have to do this through the API, as
+        # the UI wouldn't give them the option) returns a 400 and preserves the LC block's state.
+        self._upgrade_and_sync(lc_block, status_code_expected=400)
+
+        # (Repeat the exact same checks)
+        lc_block = modulestore().get_item(lc_block.location)
+        # Source library id should be set to the new bad one...
+        assert lc_block.source_library_id == bad_library_id
+        # ...but old source library version should be preserved...
+        assert lc_block.source_library_version == good_library_version
+        # ...and children should not be deleted due to a bad setting.
+        self.assertEqual(len(lc_block.children), 1)
+        self.assertEqual(modulestore().get_item(lc_block.children[0]).data, data_value)
+
+    def test_sync_if_source_library_changed(self):
+        """
+        Tests that children are automatically synced with new lib if source library id is changed.
+        """
         library2key = self._create_library("org2", "lib2", "Library2")
         library2 = modulestore().get_library(library2key)
-        data1, data2 = "Hello world!", "Hello other world!"
+        data1, data2 = "Hello world from lib 1!", "Hello other world from lib 2"
         BlockFactory.create(
             category="html",
             parent_location=self.library.location,
             user_id=self.user.id,
             publish_item=False,
-            display_name="Lib1: HTML BLock",
+            display_name="Lib 1: HTML BLock",
             data=data1,
         )
 
@@ -389,25 +417,34 @@ def test_refreshes_children_if_libraries_change(self):
         with modulestore().default_store(ModuleStoreEnum.Type.split):
             course = CourseFactory.create()
 
-        # Add a LibraryContent block to the course:
+        # Add a LibraryContent block to the course.
         lc_block = self._add_library_content_block(course, self.lib_key)
-        lc_block = self._refresh_children(lc_block)
+        lc_block = self._upgrade_and_sync(lc_block)
+
+        # Sanity check the initial condition.
         self.assertEqual(len(lc_block.children), 1)
+        html_block_1 = modulestore().get_item(lc_block.children[0])
+        self.assertEqual(html_block_1.data, data1)
 
-        # Now, change the block settings to have an invalid library key:
+        # Now, switch over to new library. Don't call upgrade_and_sync, because we are
+        # testing that it happens automatically.
         resp = self._update_block(
             lc_block.location,
             {"source_library_id": str(library2key)},
         )
         self.assertEqual(resp.status_code, 200)
-        lc_block = modulestore().get_item(lc_block.location)
 
+        # Check that the course now has the new lib's new block.
+        lc_block = modulestore().get_item(lc_block.location)
         self.assertEqual(len(lc_block.children), 1)
-        html_block = modulestore().get_item(lc_block.children[0])
-        self.assertEqual(html_block.data, data2)
+        html_block_2 = modulestore().get_item(lc_block.children[0])
+        self.assertEqual(html_block_2.data, data2)
 
-    @patch("xmodule.library_tools.SearchEngine.get_search_engine", Mock(return_value=None, autospec=True))
-    def test_refreshes_children_if_capa_type_change(self):
+    @patch(
+        'openedx.core.djangoapps.content_libraries.tasks.SearchEngine.get_search_engine',
+        Mock(return_value=None, autospec=True),
+    )
+    def test_sync_if_capa_type_changed(self):
         """ Tests that children are automatically refreshed if capa type field changes """
         name1, name2 = "Option Problem", "Multiple Choice Problem"
         BlockFactory.create(
@@ -433,7 +470,7 @@ def test_refreshes_children_if_capa_type_change(self):
 
         # Add a LibraryContent block to the course:
         lc_block = self._add_library_content_block(course, self.lib_key)
-        lc_block = self._refresh_children(lc_block)
+        lc_block = self._upgrade_and_sync(lc_block)
         self.assertEqual(len(lc_block.children), 2)
 
         resp = self._update_block(
@@ -458,26 +495,6 @@ def test_refreshes_children_if_capa_type_change(self):
         html_block = modulestore().get_item(lc_block.children[0])
         self.assertEqual(html_block.display_name, name2)
 
-    def test_refresh_fails_for_unknown_library(self):
-        """ Tests that refresh children fails if unknown library is configured """
-        # Create a course:
-        with modulestore().default_store(ModuleStoreEnum.Type.split):
-            course = CourseFactory.create()
-
-        # Add a LibraryContent block to the course:
-        lc_block = self._add_library_content_block(course, self.lib_key)
-        lc_block = self._refresh_children(lc_block)
-        self.assertEqual(len(lc_block.children), 0)
-
-        # Now, change the block settings to have an invalid library key:
-        resp = self._update_block(
-            lc_block.location,
-            {"source_library_id": "library-v1:NOT+FOUND"},
-        )
-        self.assertEqual(resp.status_code, 200)
-        with self.assertRaises(ValueError):
-            self._refresh_children(lc_block, status_code_expected=400)
-
     def test_library_filters(self):
         """
         Test the filters in the list libraries API
@@ -742,9 +759,9 @@ def test_duplicate_across_courses(self, library_role, course_role, expected_resu
         (LibraryUserRole, None, False),
     )
     @ddt.unpack
-    def test_refresh_library_content_permissions(self, library_role, course_role, expected_result):
+    def test_upgrade_and_sync_handler_content_permissions(self, library_role, course_role, expected_result):
         """
-        Test that the LibraryContent block's 'refresh_children' handler will correctly
+        Test that the LibraryContent block's 'upgrade_library' handler will correctly
         handle permissions and allow/refuse when updating its content with the latest
         version of a library. We try updating from a library with (write, read, or no)
         access to a course with (write or no) access.
@@ -767,7 +784,7 @@ def test_refresh_library_content_permissions(self, library_role, course_role, ex
         lc_block = self._add_library_content_block(course, self.lib_key)
         # We must use the CMS's module system in order to get permissions checks.
         self._bind_block(lc_block, user=self.non_staff_user)
-        lc_block = self._refresh_children(lc_block, status_code_expected=200 if expected_result else 403)
+        lc_block = self._upgrade_and_sync(lc_block, status_code_expected=200 if expected_result else 403)
         self.assertEqual(len(lc_block.children), 1 if expected_result else 0)
 
     def test_studio_user_permissions(self):
@@ -860,7 +877,7 @@ def setUp(self):
 
         # Add a LibraryContent block to the course:
         self.lc_block = self._add_library_content_block(self.course, self.lib_key)
-        self.lc_block = self._refresh_children(self.lc_block)
+        self.lc_block = self._upgrade_and_sync(self.lc_block)
         self.problem_in_course = modulestore().get_item(self.lc_block.children[0])
 
     def test_overrides(self):
@@ -875,7 +892,7 @@ def test_overrides(self):
 
         # Add a second LibraryContent block to the course, with no override:
         lc_block2 = self._add_library_content_block(self.course, self.lib_key)
-        lc_block2 = self._refresh_children(lc_block2)
+        lc_block2 = self._upgrade_and_sync(lc_block2)
         # Re-load the two problem blocks - one with and one without an override:
         self.problem_in_course = modulestore().get_item(self.lc_block.children[0])
         problem2_in_course = modulestore().get_item(lc_block2.children[0])
@@ -925,7 +942,7 @@ def test_consistent_definitions(self):
         self.problem.weight = 20
         self.problem.display_name = "NEW"
         modulestore().update_item(self.problem, self.user.id)
-        self.lc_block = self._refresh_children(self.lc_block)
+        self.lc_block = self._upgrade_and_sync(self.lc_block)
         self.problem_in_course = modulestore().get_item(self.problem_in_course.location)
 
         self.assertEqual(self.problem.definition_locator.definition_id, definition_id)
@@ -962,7 +979,7 @@ def test_persistent_overrides(self, duplicate):
         self.problem.data = new_data_value
         modulestore().update_item(self.problem, self.user.id)
 
-        self.lc_block = self._refresh_children(self.lc_block)
+        self.lc_block = self._upgrade_and_sync(self.lc_block)
         self.problem_in_course = modulestore().get_item(self.problem_in_course.location)
 
         self.assertEqual(self.problem_in_course.display_name, new_display_name)
@@ -992,14 +1009,11 @@ def test_duplicated_version(self):
         # Refresh our reference to the library
         self.library = store.get_library(self.lib_key)
 
-        # Refresh our reference to the block
-        self.lc_block = store.get_item(self.lc_block.location)
-        self.problem_in_course = store.get_item(self.problem_in_course.location)
-
         # The library has changed...
         self.assertEqual(len(self.library.children), 2)
 
         # But the block hasn't.
+        self.lc_block = store.get_item(self.lc_block.location)
         self.assertEqual(len(self.lc_block.children), 1)
         self.assertEqual(self.problem_in_course.location, self.lc_block.children[0])
         self.assertEqual(self.problem_in_course.display_name, self.original_display_name)
@@ -1009,8 +1023,15 @@ def test_duplicated_version(self):
             duplicate_block(self.course.location, self.lc_block.location, self.user)
         )
         # The duplicate should have identical children to the original:
-        self.assertEqual(len(duplicate.children), 1)
         self.assertTrue(self.lc_block.source_library_version)
         self.assertEqual(self.lc_block.source_library_version, duplicate.source_library_version)
+        self.assertEqual(len(duplicate.children), 1)
         problem2_in_course = store.get_item(duplicate.children[0])
         self.assertEqual(problem2_in_course.display_name, self.original_display_name)
+
+        # Refresh our reference to the block
+        self.lc_block = self._upgrade_and_sync(self.lc_block)
+        self.problem_in_course = store.get_item(self.problem_in_course.location)
+
+        # and the block has changed too.
+        self.assertEqual(len(self.lc_block.children), 2)
diff --git a/cms/djangoapps/contentstore/views/component.py b/cms/djangoapps/contentstore/views/component.py
index 3c31637d4c78..b815a14ed171 100644
--- a/cms/djangoapps/contentstore/views/component.py
+++ b/cms/djangoapps/contentstore/views/component.py
@@ -195,6 +195,9 @@ def container_handler(request, usage_key_string):
 
             # Get the status of the user's clipboard so they can paste components if they have something to paste
             user_clipboard = content_staging_api.get_user_clipboard_json(request.user.id, request)
+            library_block_types = [problem_type['component'] for problem_type in LIBRARY_BLOCK_TYPES]
+            is_library_xblock = xblock.location.block_type in library_block_types
+
             return render_to_response('container.html', {
                 'language_code': request.LANGUAGE_CODE,
                 'context_course': course,  # Needed only for display of menus at top of page.
@@ -203,6 +206,7 @@ def container_handler(request, usage_key_string):
                 'xblock_locator': xblock.location,
                 'unit': unit,
                 'is_unit_page': is_unit_page,
+                'is_collapsible': is_library_xblock,
                 'subsection': subsection,
                 'section': section,
                 'position': index,
@@ -218,6 +222,7 @@ def container_handler(request, usage_key_string):
                 'templates': CONTAINER_TEMPLATES,
                 # Status of the user's clipboard, exactly as would be returned from the "GET clipboard" REST API.
                 'user_clipboard': user_clipboard,
+                'is_fullwidth_content': is_library_xblock,
             })
     else:
         return HttpResponseBadRequest("Only supports HTML requests")
diff --git a/cms/djangoapps/contentstore/views/preview.py b/cms/djangoapps/contentstore/views/preview.py
index 48c323c1aa88..acab35471813 100644
--- a/cms/djangoapps/contentstore/views/preview.py
+++ b/cms/djangoapps/contentstore/views/preview.py
@@ -45,7 +45,7 @@
     wrap_xblock_aside
 )
 
-from ..utils import get_visibility_partition_info
+from ..utils import get_visibility_partition_info, StudioPermissionsService
 from .access import get_user_role
 from .session_kv_store import SessionKeyValueStore
 
@@ -198,6 +198,7 @@ def _prepare_runtime_for_preview(request, block):
         deprecated_anonymous_user_id = anonymous_id_for_user(request.user, None)
 
     services = {
+        "studio_user_permissions": StudioPermissionsService(request.user),
         "i18n": XBlockI18nService,
         'mako': mako_service,
         "settings": SettingsService(),
@@ -310,6 +311,9 @@ def _studio_wrap_xblock(xblock, view, frag, context, display_name_only=False):
             'is_reorderable': is_reorderable,
             'can_edit': can_edit,
             'can_edit_visibility': context.get('can_edit_visibility', is_course),
+            'is_loading': context.get('is_loading', False),
+            'is_selected': context.get('is_selected', False),
+            'selectable': context.get('selectable', False),
             'selected_groups_label': selected_groups_label,
             'can_add': context.get('can_add', True),
             'can_move': context.get('can_move', is_course),
diff --git a/cms/djangoapps/contentstore/views/tests/test_block.py b/cms/djangoapps/contentstore/views/tests/test_block.py
index 26b3f91a0bd7..a90187ef605d 100644
--- a/cms/djangoapps/contentstore/views/tests/test_block.py
+++ b/cms/djangoapps/contentstore/views/tests/test_block.py
@@ -211,7 +211,7 @@ def test_get_empty_container_fragment(self):
         self.assertNotRegex(html, r"wrapper-xblock[^-]+")
 
         # Verify that the header and article tags are still added
-        self.assertIn('<header class="xblock-header xblock-header-vertical">', html)
+        self.assertIn('<header class="xblock-header xblock-header-vertical ">', html)
         self.assertIn('<article class="xblock-render">', html)
 
     def test_get_container_fragment(self):
@@ -233,7 +233,7 @@ def test_get_container_fragment(self):
 
         # Verify that the Studio nesting wrapper has been added
         self.assertIn("level-nesting", html)
-        self.assertIn('<header class="xblock-header xblock-header-vertical">', html)
+        self.assertIn('<header class="xblock-header xblock-header-vertical ">', html)
         self.assertIn('<article class="xblock-render">', html)
 
         # Verify that the Studio element wrapper has been added
@@ -950,6 +950,135 @@ def test_shallow_duplicate(self):
         self.assertEqual(len(destination_chapter.get_children()), 0)
         self.assertEqual(destination_chapter.display_name, "Source Chapter")
 
+    def test_duplicate_library_content_block(self):  # pylint: disable=too-many-statements
+        """
+        Test the LibraryContentBlock's special duplication process.
+        """
+        store = modulestore()
+
+        # Create a library with two blocks (HTML 1 and HTML 2).
+        # These are the "Original" version of the blocks.
+        lib = LibraryFactory()
+        BlockFactory(
+            parent=lib,
+            category="html",
+            display_name="HTML 1 Title (Original)",
+            data="HTML 1 Content (Original)",
+            publish_item=False,
+        )
+        BlockFactory(
+            parent=lib,
+            category="html",
+            display_name="HTML 2 Title (Original)",
+            data="HTML 2 Content (Original)",
+            publish_item=False,
+        )
+        original_lib_version = store.get_library(
+            lib.location.library_key, remove_version=False, remove_branch=False,
+        ).location.library_key.version_guid
+        assert original_lib_version is not None
+
+        # Create a library content block (lc), point it out our library, and sync it.
+        unit = BlockFactory(
+            parent_location=self.seq_usage_key,
+            category="vertical",
+            display_name="Parent Unit of LC and its Dupe",
+            publish_item=False,
+        )
+        lc = BlockFactory(
+            parent=unit,
+            category="library_content",
+            source_library_id=str(lib.location.library_key),
+            display_name="LC Block",
+            max_count=1,
+            publish_item=False,
+        )
+        lc.sync_from_library()
+        lc = store.get_item(lc.location)  # we must reload because sync_from_library happens out-of-thread
+        assert lc.source_library_version == str(original_lib_version)
+        lc_html_1 = store.get_item(lc.children[0])
+        lc_html_2 = store.get_item(lc.children[1])
+        assert lc_html_1.display_name == "HTML 1 Title (Original)"
+        assert lc_html_2.display_name == "HTML 2 Title (Original)"
+        assert lc_html_1.data == "HTML 1 Content (Original)"
+        assert lc_html_2.data == "HTML 2 Content (Original)"
+
+        # Override the title and data of HTML 1 under lc ("Course Override").
+        # Note that title is settings-scoped and data is content-scoped.
+        lc_html_1.display_name = "HTML 1 Title (Course Override)"
+        lc_html_1.data = "HTML 1 Content (Course Override)"
+        store.update_item(lc_html_1, self.user.id)
+
+        # Now, update the titles and contents of both HTML 1 and HTML 2 ("Lib Update").
+        # This will yield a new version of the library (updated_lib_version).
+        lib_html_1 = store.get_item(lib.children[0])
+        lib_html_2 = store.get_item(lib.children[1])
+        assert lib_html_1.display_name == "HTML 1 Title (Original)"
+        assert lib_html_2.display_name == "HTML 2 Title (Original)"
+        lib_html_1.display_name = "HTML 1 Title (Lib Update)"
+        lib_html_2.display_name = "HTML 2 Title (Lib Update)"
+        lib_html_1.data = "HTML 1 Content (Lib Update)"
+        lib_html_2.data = "HTML 2 Content (Lib Update)"
+        store.update_item(lib_html_1, self.user.id)
+        store.update_item(lib_html_2, self.user.id)
+        updated_lib_version = store.get_library(
+            lib.location.library_key, remove_version=False, remove_branch=False,
+        ).location.library_key.version_guid
+        assert updated_lib_version is not None
+        assert updated_lib_version != original_lib_version
+
+        # DUPLICATE lc.
+        # Unit should now contain both lc and dupe.
+        # All settings should match between lc and dupe.
+        dupe = store.get_item(
+            self._duplicate_item(
+                parent_usage_key=unit.location,
+                source_usage_key=lc.location,
+                display_name="Dupe LC Block",
+            )
+        )
+        lc = store.get_item(lc.location)
+        unit = store.get_item(unit.location)
+        assert unit.children == [lc.location, dupe.location]
+        assert len(lc.children) == len(dupe.children) == 2
+        assert lc.max_count == dupe.max_count == 1
+        assert lc.source_library_id == dupe.source_library_id == str(lib.location.library_key)
+        assert lc.source_library_version == dupe.source_library_version == str(original_lib_version)
+
+        # The lc block's children should remain unchanged.
+        # That is: HTML 1 has overrides, HTML 2 has originals.
+        lc_html_1 = store.get_item(lc.children[0])
+        assert lc_html_1.display_name == "HTML 1 Title (Course Override)"
+        assert lc_html_1.data == "HTML 1 Content (Course Override)"
+        lc_html_2 = store.get_item(lc.children[1])
+        assert lc_html_2.display_name == "HTML 2 Title (Original)"
+        assert lc_html_2.data == "HTML 2 Content (Original)"
+
+        # Now, the dupe's children should copy *settings* overrides over from the lc block,
+        # but we don't actually expect it to copy *content* overrides over from the lc block.
+        # (Yes, this is weird. One would expect it to copy all fields from the lc block, whether settings or content.
+        #  But that's the existing behavior, so we're going to test for it, for now at least.
+        #  We may change this in the future: https://github.com/openedx/edx-platform/issues/33739)
+        dupe_html_1 = store.get_item(dupe.children[0])
+        assert dupe_html_1.display_name == "HTML 1 Title (Course Override)"  # <- as you'd expect
+        assert dupe_html_1.data == "HTML 1 Content (Original)"  # <- weird!
+        dupe_html_2 = store.get_item(dupe.children[1])
+        assert dupe_html_2.display_name == "HTML 2 Title (Original)"  # <- as you'd expect
+        assert dupe_html_2.data == "HTML 2 Content (Original)"  # <- as you'd expect
+
+        # Finally, upgrade the dupe's library version, and make sure it pulls in updated library block *content*,
+        # whilst preserving *settings overrides* (specifically, HTML 1's title override).
+        dupe.sync_from_library(upgrade_to_latest=True)
+        dupe = store.get_item(dupe.location)
+        assert dupe.source_library_version == str(updated_lib_version)
+        assert len(dupe.children) == 2
+        dupe_html_1 = store.get_item(dupe.children[0])
+        dupe_html_2 = store.get_item(dupe.children[1])
+        assert dupe_html_1.display_name == "HTML 1 Title (Course Override)"
+        assert dupe_html_1.data == "HTML 1 Content (Lib Update)"
+        assert dupe_html_2.display_name == "HTML 2 Title (Lib Update)"
+        assert dupe_html_2.data == "HTML 2 Content (Lib Update)"
+
 
 @ddt.ddt
 class TestMoveItem(ItemTest):
diff --git a/cms/djangoapps/contentstore/views/tests/test_container_page.py b/cms/djangoapps/contentstore/views/tests/test_container_page.py
index b78c0cce8347..1d5b52905357 100644
--- a/cms/djangoapps/contentstore/views/tests/test_container_page.py
+++ b/cms/djangoapps/contentstore/views/tests/test_container_page.py
@@ -167,7 +167,7 @@ def test_library_content_preview_html(self):
         self.assertEqual(len(lc_block.children), 0)
 
         # Refresh children to be reflected in lc_block
-        lc_block = self._refresh_children(lc_block)
+        lc_block = self._upgrade_and_sync(lc_block)
         self.assertEqual(len(lc_block.children), 1)
 
         self.validate_preview_html(
diff --git a/cms/djangoapps/contentstore/views/tests/test_import_export.py b/cms/djangoapps/contentstore/views/tests/test_import_export.py
index d01f6800c105..0744c436cf99 100644
--- a/cms/djangoapps/contentstore/views/tests/test_import_export.py
+++ b/cms/djangoapps/contentstore/views/tests/test_import_export.py
@@ -1112,7 +1112,7 @@ def _setup_source_course_with_library_content(self, publish=False, version=None)
         lc_block = self._add_library_content_block(
             vertical, self.lib_key, publish_item=publish, other_settings=dict(source_library_version=version)
         )
-        self._refresh_children(lc_block)
+        lc_block.sync_from_library(upgrade_to_latest=True)
 
     def get_lib_content_block_children(self, block_location):
         """
diff --git a/cms/djangoapps/contentstore/xblock_storage_handlers/view_handlers.py b/cms/djangoapps/contentstore/xblock_storage_handlers/view_handlers.py
index dca25695a29d..37dbee4507a9 100644
--- a/cms/djangoapps/contentstore/xblock_storage_handlers/view_handlers.py
+++ b/cms/djangoapps/contentstore/xblock_storage_handlers/view_handlers.py
@@ -8,7 +8,6 @@
 contentstore/views/block.py to this file, because the logic is reused in another view now.
 Along with it, we moved the business logic of the other views in that file, since that is related.
 """
-
 import logging
 from datetime import datetime
 from uuid import uuid4
@@ -16,7 +15,7 @@
 from attrs import asdict
 from django.conf import settings
 from django.contrib.auth.decorators import login_required
-from django.contrib.auth.models import (User)  # lint-amnesty, pylint: disable=imported-auth-user
+from django.contrib.auth.models import User  # pylint: disable=imported-auth-user
 from django.core.exceptions import PermissionDenied
 from django.http import HttpResponse, HttpResponseBadRequest
 from django.utils.timezone import timezone
@@ -57,37 +56,15 @@
 from openedx.core.lib.gating import api as gating_api
 from openedx.core.lib.cache_utils import request_cached
 from openedx.core.toggles import ENTRANCE_EXAMS
-from xmodule.course_block import (
-    DEFAULT_START_DATE,
-)  # lint-amnesty, pylint: disable=wrong-import-order
-from xmodule.library_tools import (
-    LibraryToolsService,
-)  # lint-amnesty, pylint: disable=wrong-import-order
-from xmodule.modulestore import (
-    EdxJSONEncoder,
-    ModuleStoreEnum,
-)  # lint-amnesty, pylint: disable=wrong-import-order
-from xmodule.modulestore.django import (
-    modulestore,
-)  # lint-amnesty, pylint: disable=wrong-import-order
-from xmodule.modulestore.draft_and_published import (
-    DIRECT_ONLY_CATEGORIES,
-)  # lint-amnesty, pylint: disable=wrong-import-order
-from xmodule.modulestore.exceptions import (
-    InvalidLocationError,
-    ItemNotFoundError,
-)  # lint-amnesty, pylint: disable=wrong-import-order
-from xmodule.modulestore.inheritance import (
-    own_metadata,
-)  # lint-amnesty, pylint: disable=wrong-import-order
-from xmodule.services import (
-    ConfigurationService,
-    SettingsService,
-    TeamsConfigurationService,
-)  # lint-amnesty, pylint: disable=wrong-import-order
-from xmodule.tabs import (
-    CourseTabList,
-)  # lint-amnesty, pylint: disable=wrong-import-order
+from xmodule.course_block import DEFAULT_START_DATE
+from xmodule.library_tools import LibraryToolsService
+from xmodule.modulestore import EdxJSONEncoder, ModuleStoreEnum
+from xmodule.modulestore.django import modulestore
+from xmodule.modulestore.draft_and_published import DIRECT_ONLY_CATEGORIES
+from xmodule.modulestore.exceptions import InvalidLocationError, ItemNotFoundError
+from xmodule.modulestore.inheritance import own_metadata
+from xmodule.services import ConfigurationService, SettingsService, TeamsConfigurationService
+from xmodule.tabs import CourseTabList
 
 from ..utils import (
     ancestor_has_staff_lock,
@@ -180,6 +157,7 @@ def handle_xblock(request, usage_key_string=None):
     the public CMS API.
     """
     if usage_key_string:
+
         usage_key = usage_key_with_run(usage_key_string)
 
         access_check = (
@@ -220,7 +198,8 @@ def handle_xblock(request, usage_key_string=None):
             _delete_item(usage_key, request.user)
             return JsonResponse()
         else:  # Since we have a usage_key, we are updating an existing xblock.
-            return modify_xblock(usage_key, request)
+            modified_xblock = modify_xblock(usage_key, request)
+            return modified_xblock
 
     elif request.method in ("PUT", "POST"):
         if "duplicate_source_locator" in request.json:
@@ -228,7 +207,6 @@ def handle_xblock(request, usage_key_string=None):
             duplicate_source_usage_key = usage_key_with_run(
                 request.json["duplicate_source_locator"]
             )
-
             source_course = duplicate_source_usage_key.course_key
             dest_course = parent_usage_key.course_key
             if not has_studio_write_access(
@@ -255,6 +233,7 @@ def handle_xblock(request, usage_key_string=None):
                 request.user,
                 request.json.get("display_name"),
             )
+
             return JsonResponse(
                 {
                     "locator": str(dest_usage_key),
@@ -298,7 +277,6 @@ def handle_xblock(request, usage_key_string=None):
 
 def modify_xblock(usage_key, request):
     request_data = request.json
-    print(f'In modify_xblock with data = {request_data.get("data")}, fields = {request_data.get("fields")}')
     return _save_xblock(
         request.user,
         get_xblock(usage_key, request.user),
@@ -360,21 +338,27 @@ def load_services_for_studio(runtime, user):
 def _update_with_callback(xblock, user, old_metadata=None, old_content=None):
     """
     Updates the xblock in the modulestore.
-    But before doing so, it calls the xblock's editor_saved callback function.
+    But before doing so, it calls the xblock's editor_saved callback function,
+    and after doing so, it calls the xblock's post_editor_saved callback function.
+
+    TODO: Remove getattrs from this function.
+          See https://github.com/openedx/edx-platform/issues/33715
     """
-    if callable(getattr(xblock, "editor_saved", None)):
-        if old_metadata is None:
-            old_metadata = own_metadata(xblock)
-        if old_content is None:
-            old_content = xblock.get_explicitly_set_fields_by_scope(Scope.content)
+    if old_metadata is None:
+        old_metadata = own_metadata(xblock)
+    if old_content is None:
+        old_content = xblock.get_explicitly_set_fields_by_scope(Scope.content)
+    if hasattr(xblock, "editor_saved"):
         load_services_for_studio(xblock.runtime, user)
         xblock.editor_saved(user, old_metadata, old_content)
-
-    # Update after the callback so any changes made in the callback will get persisted.
-    return modulestore().update_item(xblock, user.id)
+    xblock_updated = modulestore().update_item(xblock, user.id)
+    if hasattr(xblock_updated, "post_editor_saved"):
+        load_services_for_studio(xblock_updated.runtime, user)
+        xblock_updated.post_editor_saved(user, old_metadata, old_content)
+    return xblock_updated
 
 
-def _save_xblock(  # lint-amnesty, pylint: disable=too-many-statements
+def _save_xblock(
     user,
     xblock,
     data=None,
@@ -389,12 +373,11 @@ def _save_xblock(  # lint-amnesty, pylint: disable=too-many-statements
     publish=None,
     fields=None,
     summary_configuration_enabled=None,
-):
+):  # lint-amnesty, pylint: disable=too-many-statements
     """
     Saves xblock w/ its fields. Has special processing for grader_type, publish, and nullout and Nones in metadata.
     nullout means to truly set the field to None whereas nones in metadata mean to unset them (so they revert
     to default).
-
     """
     store = modulestore()
     # Perform all xblock changes within a (single-versioned) transaction
@@ -881,6 +864,8 @@ def _duplicate_block(
             # Allow an XBlock to do anything fancy it may need to when duplicated from another block.
             # These blocks may handle their own children or parenting if needed. Let them return booleans to
             # let us know if we need to handle these or not.
+            # TODO: Make this a proper method in the base class so we don't need getattr.
+            #       See https://github.com/openedx/edx-platform/issues/33715
             load_services_for_studio(dest_block.runtime, user)
             children_handled = dest_block.studio_post_duplicate(store, source_item)
 
diff --git a/cms/envs/common.py b/cms/envs/common.py
index a007424cf18f..11afd870a016 100644
--- a/cms/envs/common.py
+++ b/cms/envs/common.py
@@ -1994,8 +1994,6 @@
 ]
 
 LIBRARY_BLOCK_TYPES = [
-    # Per https://github.com/openedx/build-test-release-wg/issues/231
-    # we removed the library source content block from defaults until complete.
     {
         'component': 'library_content',
         'boilerplate_name': None
diff --git a/cms/lib/xblock/tagging/test.py b/cms/lib/xblock/tagging/test.py
index f00d1a53c89b..173523452d54 100644
--- a/cms/lib/xblock/tagging/test.py
+++ b/cms/lib/xblock/tagging/test.py
@@ -148,9 +148,12 @@ def test_preview_html(self):
         tree = etree.parse(StringIO(problem_html), parser)
 
         main_div_nodes = tree.xpath('/html/body/div/section/div')
-        self.assertEqual(len(main_div_nodes), 1)
+        self.assertEqual(len(main_div_nodes), 2)
 
-        div_node = main_div_nodes[0]
+        loader_div_node = main_div_nodes[0]
+        self.assertIn('ui-loading', loader_div_node.get('class'))
+
+        div_node = main_div_nodes[1]
         self.assertEqual(div_node.get('data-init'), 'StructuredTagsInit')
         self.assertEqual(div_node.get('data-runtime-class'), 'PreviewRuntime')
         self.assertEqual(div_node.get('data-block-type'), 'tagging_aside')
diff --git a/cms/static/js/views/pages/container.js b/cms/static/js/views/pages/container.js
index 8f296ebb6b58..8495bfd27180 100644
--- a/cms/static/js/views/pages/container.js
+++ b/cms/static/js/views/pages/container.js
@@ -7,11 +7,14 @@ define(['jquery', 'underscore', 'backbone', 'gettext', 'js/views/pages/base_page
     'js/views/components/add_xblock', 'js/views/modals/edit_xblock', 'js/views/modals/move_xblock_modal',
     'js/models/xblock_info', 'js/views/xblock_string_field_editor', 'js/views/xblock_access_editor',
     'js/views/pages/container_subviews', 'js/views/unit_outline', 'js/views/utils/xblock_utils',
-    'common/js/components/views/feedback_notification', 'common/js/components/views/feedback_prompt',
+    'common/js/components/views/feedback_notification', 'common/js/components/views/feedback_prompt', 'js/utils/module',
 ],
-function($, _, Backbone, gettext, BasePage, ViewUtils, ContainerView, XBlockView, AddXBlockComponent,
-    EditXBlockModal, MoveXBlockModal, XBlockInfo, XBlockStringFieldEditor, XBlockAccessEditor,
-    ContainerSubviews, UnitOutlineView, XBlockUtils, NotificationView, PromptView) {
+function($, _, Backbone, gettext, BasePage,
+    ViewUtils, ContainerView, XBlockView,
+    AddXBlockComponent, EditXBlockModal, MoveXBlockModal,
+    XBlockInfo, XBlockStringFieldEditor, XBlockAccessEditor,
+    ContainerSubviews, UnitOutlineView, XBlockUtils,
+    NotificationView, PromptView,  ModuleUtils) {
     'use strict';
 
     var XBlockContainerPage = BasePage.extend({
@@ -26,7 +29,10 @@ function($, _, Backbone, gettext, BasePage, ViewUtils, ContainerView, XBlockView
             'click .delete-button': 'deleteXBlock',
             'click .show-actions-menu-button': 'showXBlockActionsMenu',
             'click .new-component-button': 'scrollToNewComponentButtons',
+            'click .save-button': 'saveSelectedLibraryComponents',
             'click .paste-component-button': 'pasteComponent',
+            'change .header-library-checkbox': 'toggleLibraryComponent',
+            'click .collapse-button': 'collapseXBlock',
         },
 
         options: {
@@ -102,6 +108,7 @@ function($, _, Backbone, gettext, BasePage, ViewUtils, ContainerView, XBlockView
                     model: this.model
                 });
                 this.unitOutlineView.render();
+
             }
 
             this.listenTo(Backbone, 'move:onXBlockMoved', this.onXBlockMoved);
@@ -521,6 +528,78 @@ function($, _, Backbone, gettext, BasePage, ViewUtils, ContainerView, XBlockView
                 });
         },
 
+        duplicateXBlock: function(event) {
+            event.preventDefault();
+            this.duplicateComponent(this.findXBlockElement(event.target));
+        },
+
+        showMoveXBlockModal: function(event) {
+            var xblockElement = this.findXBlockElement(event.target),
+                parentXBlockElement = xblockElement.parents('.studio-xblock-wrapper'),
+                modal = new MoveXBlockModal({
+                sourceXBlockInfo: XBlockUtils.findXBlockInfo(xblockElement, this.model),
+                sourceParentXBlockInfo: XBlockUtils.findXBlockInfo(parentXBlockElement, this.model),
+                XBlockURLRoot: this.getURLRoot(),
+                outlineURL: this.options.outlineURL
+            });
+
+            event.preventDefault();
+            modal.show();
+        },
+
+        deleteXBlock: function(event) {
+            event.preventDefault();
+            this.deleteComponent(this.findXBlockElement(event.target));
+        },
+
+        createPlaceholderElement: function() {
+            return $('<div/>', {class: 'studio-xblock-wrapper'});
+        },
+
+        createComponent: function(template, target) {
+            // A placeholder element is created in the correct location for the new xblock
+            // and then onNewXBlock will replace it with a rendering of the xblock. Note that
+            // for xblocks that can't be replaced inline, the entire parent will be refreshed.
+            var parentElement = this.findXBlockElement(target),
+                parentLocator = parentElement.data('locator'),
+                buttonPanel = target.closest('.add-xblock-component'),
+                listPanel = buttonPanel.prev(),
+                scrollOffset = ViewUtils.getScrollOffset(buttonPanel),
+                $placeholderEl = $(this.createPlaceholderElement()),
+                requestData = _.extend(template, {
+                    parent_locator: parentLocator
+                }),
+                placeholderElement;
+            placeholderElement = $placeholderEl.appendTo(listPanel);
+            return $.postJSON(this.getURLRoot() + '/', requestData,
+                _.bind(this.onNewXBlock, this, placeholderElement, scrollOffset, false))
+                .fail(function() {
+                    // Remove the placeholder if the update failed
+                    placeholderElement.remove();
+            });
+        },
+
+        duplicateComponent: function(xblockElement) {
+            // A placeholder element is created in the correct location for the duplicate xblock
+            // and then onNewXBlock will replace it with a rendering of the xblock. Note that
+            // for xblocks that can't be replaced inline, the entire parent will be refreshed.
+            var self = this,
+                parentElement = self.findXBlockElement(xblockElement.parent()),
+                scrollOffset = ViewUtils.getScrollOffset(xblockElement),
+                $placeholderEl = $(self.createPlaceholderElement()),
+                placeholderElement;
+
+            placeholderElement = $placeholderEl.insertAfter(xblockElement);
+            XBlockUtils.duplicateXBlock(xblockElement, parentElement)
+                .done(function(data) {
+                    self.onNewXBlock(placeholderElement, scrollOffset, true, data);
+                })
+                .fail(function() {
+                    // Remove the placeholder if the update failed
+                    placeholderElement.remove();
+                });
+        },
+
         deleteComponent: function(xblockElement) {
             var self = this,
                 xblockInfo = new XBlockInfo({
@@ -531,6 +610,61 @@ function($, _, Backbone, gettext, BasePage, ViewUtils, ContainerView, XBlockView
             });
         },
 
+        getSelectedLibraryComponents: function() {
+            var self = this;
+            var locator = this.$el.find('.studio-xblock-wrapper').data('locator');
+            console.log(ModuleUtils);
+            $.getJSON(
+                ModuleUtils.getUpdateUrl(locator) + '/handler/get_block_ids',
+                function(data) {
+                    self.selectedLibraryComponents = Array.from(data.source_block_ids);
+                    self.storedSelectedLibraryComponents = Array.from(data.source_block_ids);
+                }
+            );
+        },
+
+        saveSelectedLibraryComponents: function(e) {
+            var self = this;
+            var locator = this.$el.find('.studio-xblock-wrapper').data('locator');
+            e.preventDefault();
+            $.postJSON(
+                ModuleUtils.getUpdateUrl(locator) + '/handler/submit_studio_edits',
+                {values: {source_block_ids: self.storedSelectedLibraryComponents}},
+                function() {
+                    self.selectedLibraryComponents = Array.from(self.storedSelectedLibraryComponents);
+                    self.toggleSaveButton();
+                }
+            );
+        },
+
+        toggleLibraryComponent: function(event) {
+            var componentId = $(event.target).closest('.studio-xblock-wrapper').data('locator');
+            var storeIndex = this.storedSelectedLibraryComponents.indexOf(componentId);
+            if (storeIndex > -1) {
+                this.storedSelectedLibraryComponents.splice(storeIndex, 1);
+                this.toggleSaveButton();
+            } else {
+                this.storedSelectedLibraryComponents.push(componentId);
+                this.toggleSaveButton();
+            }
+        },
+
+        toggleSaveButton: function() {
+            var $saveButton = $('.nav-actions .save-button');
+            if (JSON.stringify(this.selectedLibraryComponents.sort()) === JSON.stringify(this.storedSelectedLibraryComponents.sort())) {
+                $saveButton.addClass('is-hidden');
+                window.removeEventListener('beforeunload', this.onBeforePageUnloadCallback);
+            } else {
+                $saveButton.removeClass('is-hidden');
+                window.addEventListener('beforeunload', this.onBeforePageUnloadCallback);
+            }
+        },
+
+        onBeforePageUnloadCallback: function (event) {
+            event.preventDefault();
+            event.returnValue = '';
+        },
+
         onDelete: function(xblockElement) {
             // get the parent so we can remove this component from its parent.
             var xblockView = this.xblockView,
diff --git a/cms/static/sass/elements/_layout.scss b/cms/static/sass/elements/_layout.scss
index d4240b450f47..ae1090fe4623 100644
--- a/cms/static/sass/elements/_layout.scss
+++ b/cms/static/sass/elements/_layout.scss
@@ -223,6 +223,10 @@
     box-shadow: none;
     border: 0;
     background-color: $white;
+
+    &-fullwidth {
+      width: flex-grid(12, 12);
+    }
   }
 
   .content-supplementary {
diff --git a/cms/static/sass/elements/_xblocks.scss b/cms/static/sass/elements/_xblocks.scss
index 87dcb8c7d7c6..119a14826c63 100644
--- a/cms/static/sass/elements/_xblocks.scss
+++ b/cms/static/sass/elements/_xblocks.scss
@@ -43,6 +43,19 @@
     display: flex;
     align-items: center;
 
+    .header-library-checkbox {
+      margin-right: 10px;
+      width: 17px;
+      height: 17px;
+      cursor: pointer;
+      vertical-align: middle;
+    }
+
+    .header-library-checkbox-label {
+      vertical-align: middle;
+      cursor: pointer;
+    }
+
     .header-details {
       @extend %cont-truncated;
 
@@ -433,7 +446,17 @@
       border-color: $blue;
     }
 
-    .xblock-header {
+    &.is-collapsed {
+      .xblock-render {
+        display: none;
+      }
+
+      .collapse-button .fa {
+        transform: scale(1, -1);
+      }
+    }
+
+    .xblock-header:not(.is-hidden) {
       display: block;
     }
 
diff --git a/cms/templates/container.html b/cms/templates/container.html
index 2f83c0c6d5e1..6650d66a7f7d 100644
--- a/cms/templates/container.html
+++ b/cms/templates/container.html
@@ -152,6 +152,14 @@ <h3 class="sr">${_("Page Actions")}</h3>
                             <span class="action-button-text">${_("Edit")}</span>
                         </a>
                     </li>
+                    % if is_collapsible:
+                        <li class="action-item action-toggle-preview nav-item">
+                            <a href="#" class="button button-toggle-preview action-button">
+                                <span class="icon fa fa-arrow-up" aria-hidden="true"></span>
+                                <span class="action-button-text preview-text">${_("Collapse All")}</span>
+                            </a>
+                        </li>
+                    % endif
                 % endif
             </ul>
         </nav>
@@ -164,8 +172,7 @@ <h3 class="sr">${_("Page Actions")}</h3>
 <div class="wrapper-content wrapper">
     <div class="inner-wrapper">
         <section class="content-area">
-
-            <article class="content-primary">
+            <article class="content-primary ${'content-primary-fullwidth' if is_fullwidth_content else ''}">
                 <div class="container-message wrapper-message"></div>
                 <%
                     assets_url = reverse('assets_handler', kwargs={'course_key_string': str(xblock_locator.course_key)})
diff --git a/cms/templates/studio_xblock_wrapper.html b/cms/templates/studio_xblock_wrapper.html
index a027cc764bd7..2741879b999c 100644
--- a/cms/templates/studio_xblock_wrapper.html
+++ b/cms/templates/studio_xblock_wrapper.html
@@ -17,7 +17,6 @@
 xblock_url = xblock_studio_url(xblock)
 show_inline = xblock.has_children and not xblock_url
 section_class = "level-nesting" if show_inline else "level-element"
-collapsible_class = "is-collapsible" if xblock.has_children else ""
 label = determine_label(xblock.display_name_with_default, xblock.scope_ids.block_type)
 messages = xblock.validate().to_json()
 block_is_unit = is_unit(xblock)
@@ -48,14 +47,17 @@
     <div class="studio-xblock-wrapper" data-locator="${xblock.location}" data-course-key="${xblock.location.course_key}">
     % endif
 
-    <section class="wrapper-xblock ${section_class} ${collapsible_class}
+    <section class="wrapper-xblock is-collapsible ${section_class}
     % if is_visible_to_specific_partition_groups(xblock):
         has-group-visibility-set
     % endif
     ">
+    <div class="ui-loading ${'is-hidden' if not is_loading else ''}">
+        <p><span class="spin"><span class="icon fa fa-refresh" aria-hidden="true"></span></span> <span class="copy">${_("Importing components")}</span></p>
+    </div>
 % endif
 
-<header class="xblock-header xblock-header-${xblock.category}">
+<header class="xblock-header xblock-header-${xblock.category} ${'is-hidden' if is_loading else ''}">
     <div class="xblock-header-primary
     % if not show_preview:
         is-collapsed
@@ -77,7 +79,16 @@
             </a>
             % endif
             <div class="xblock-display-title">
+                % if selectable:
+                <input type="checkbox" name="library-component" id="${xblock.location}"
+                       class="header-library-checkbox" ${'checked="checked"' if is_selected else ''}>
+                <label for="${xblock.location}" class="xblock-display-name header-library-checkbox-label">
+                    <span class="sr-only">${_("Select this problem")}</span>
+                    ${label}
+                </label>
+                % else:
                 <span class="xblock-display-name">${label}</span>
+                % endif
                 % if selected_groups_label:
                 <p class="xblock-group-visibility-label">${selected_groups_label}</p>
                 % endif
@@ -164,7 +175,7 @@
                 <li class="action-item action-view">
                     <a href="${xblock_url}" class="action-button">
                         ## Translators: this is a verb describing the action of viewing more details
-                        <span class="action-button-text">${_('View')}</span>
+                        <span class="action-button-text">${('View')}</span>
                         <span class="icon fa fa-arrow-right" aria-hidden="true"></span>
                     </a>
                 </li>
diff --git a/docs/docs_settings.py b/docs/docs_settings.py
index 8c1b813df17d..5bc9b1594697 100644
--- a/docs/docs_settings.py
+++ b/docs/docs_settings.py
@@ -37,7 +37,6 @@
     'cms.djangoapps.course_creators',
     'cms.djangoapps.xblock_config.apps.XBlockConfig',
     'lms.djangoapps.lti_provider',
-    'user_tasks',
 ])
 
 
diff --git a/lms/envs/common.py b/lms/envs/common.py
index a2f1c5759963..4c03afe1c289 100644
--- a/lms/envs/common.py
+++ b/lms/envs/common.py
@@ -3224,6 +3224,9 @@ def _make_locale_paths(settings):  # pylint: disable=missing-function-docstring
     'rules.apps.AutodiscoverRulesConfig',
     'bridgekeeper',
 
+    # management of user-triggered async tasks (course import/export, etc.)
+    'user_tasks',
+
     # Customized celery tasks, including persisting failed tasks so they can
     # be retried
     'celery_utils',
diff --git a/openedx/core/djangoapps/content_libraries/api.py b/openedx/core/djangoapps/content_libraries/api.py
index 737673b32e3f..33d43cdc64f2 100644
--- a/openedx/core/djangoapps/content_libraries/api.py
+++ b/openedx/core/djangoapps/content_libraries/api.py
@@ -48,7 +48,7 @@
 there are Celery-based interfaces suitable for background processing controlled
 through RESTful APIs (see :mod:`.views`).
 """
-
+from __future__ import annotations
 
 import abc
 import collections
@@ -76,6 +76,7 @@
     LibraryUsageLocatorV2,
     LibraryLocator as LibraryLocatorV1
 )
+from opaque_keys import InvalidKeyError
 from openedx_events.content_authoring.data import ContentLibraryData, LibraryBlockData
 from openedx_events.content_authoring.signals import (
     CONTENT_LIBRARY_CREATED,
@@ -85,11 +86,11 @@
     LIBRARY_BLOCK_DELETED,
     LIBRARY_BLOCK_UPDATED,
 )
-
 from organizations.models import Organization
 from xblock.core import XBlock
 from xblock.exceptions import XBlockNotFoundError
 from edx_rest_api_client.client import OAuthAPIClient
+
 from openedx.core.djangoapps.content_libraries import permissions
 from openedx.core.djangoapps.content_libraries.constants import DRAFT_NAME, COMPLEX
 from openedx.core.djangoapps.content_libraries.library_bundle import LibraryBundle
@@ -99,7 +100,6 @@
     ContentLibraryPermission,
     ContentLibraryBlockImportTask,
 )
-
 from openedx.core.djangoapps.xblock.api import (
     get_block_display_name,
     get_learning_context_impl,
@@ -124,7 +124,10 @@
 )
 from openedx.core.djangolib import blockstore_cache
 from openedx.core.djangolib.blockstore_cache import BundleCache
-from xmodule.modulestore.django import modulestore  # lint-amnesty, pylint: disable=wrong-import-order
+from xmodule.library_root_xblock import LibraryRoot as LibraryRootV1
+from xmodule.modulestore import ModuleStoreEnum
+from xmodule.modulestore.django import modulestore
+from xmodule.modulestore.exceptions import ItemNotFoundError
 
 from . import tasks
 
@@ -639,7 +642,7 @@ def delete_library(library_key):
         raise
 
 
-def get_library_blocks(library_key, text_search=None, block_types=None):
+def get_library_blocks(library_key, text_search=None, block_types=None) -> list[LibraryXBlockMetadata]:
     """
     Get the list of top-level XBlocks in the specified library.
 
@@ -668,7 +671,7 @@ def get_library_blocks(library_key, text_search=None, block_types=None):
     # If indexing is disabled, or connection to elastic failed
     if metadata is None:
         metadata = []
-        ref = ContentLibrary.objects.get_by_key(library_key)
+        ref = ContentLibrary.objects.get_by_key(library_key)  # type: ignore[attr-defined]
         lib_bundle = LibraryBundle(library_key, ref.bundle_uuid, draft_name=DRAFT_NAME)
         usages = lib_bundle.get_top_level_usages()
 
@@ -701,7 +704,7 @@ def get_library_blocks(library_key, text_search=None, block_types=None):
     ]
 
 
-def _lookup_usage_key(usage_key):
+def _lookup_usage_key(usage_key) -> tuple[BundleDefinitionLocator, LibraryBundle]:
     """
     Given a LibraryUsageLocatorV2 (usage key for an XBlock in a content library)
     return the definition key and LibraryBundle
@@ -716,7 +719,7 @@ def _lookup_usage_key(usage_key):
     return def_key, lib_bundle
 
 
-def get_library_block(usage_key):
+def get_library_block(usage_key) -> LibraryXBlockMetadata:
     """
     Get metadata (LibraryXBlockMetadata) about one specific XBlock in a library
 
@@ -888,7 +891,7 @@ def delete_library_block(usage_key, remove_from_parent=True):
     )
 
 
-def create_library_block_child(parent_usage_key, block_type, definition_id):
+def create_library_block_child(parent_usage_key, block_type, definition_id) -> LibraryXBlockMetadata:
     """
     Create a new XBlock definition in this library of the specified type (e.g.
     "html"), and add it as a child of the specified existing block.
@@ -908,7 +911,7 @@ def create_library_block_child(parent_usage_key, block_type, definition_id):
     include_data = XBlockInclude(link_id=None, block_type=block_type, definition_id=definition_id, usage_hint=None)
     parent_block.runtime.add_child_include(parent_block, include_data)
     parent_block.save()
-    ref = ContentLibrary.objects.get_by_key(parent_usage_key.context_key)
+    ref = ContentLibrary.objects.get_by_key(parent_usage_key.context_key)  # type: ignore[attr-defined]
     LIBRARY_BLOCK_UPDATED.send_event(
         library_block=LibraryBlockData(
             library_key=ref.library_key,
@@ -1165,6 +1168,77 @@ def revert_changes(library_key):
     )
 
 
+# V1/V2 Compatibility Helpers
+# (Should be removed as part of
+#  https://github.com/openedx/edx-platform/issues/32457)
+# ======================================================
+
+def get_v1_or_v2_library(
+    library_id: str | LibraryLocatorV1 | LibraryLocatorV2,
+    version: str | int | None,
+) -> LibraryRootV1 | ContentLibraryMetadata | None:
+    """
+    Fetch either a V1 or V2 content library from a V1/V2 key (or key string) and version.
+
+    V1 library versions are Mongo ObjectID strings.
+    V2 library versions can be positive ints, or strings of positive ints.
+    Passing version=None will return the latest version the library.
+
+    Returns None if not found.
+    If key is invalid, raises InvalidKeyError.
+    For V1, if key has a version, it is ignored in favor of `version`.
+    For V2, if version is provided but it isn't an int or parseable to one, we raise a ValueError.
+
+    Examples:
+    * get_v1_or_v2_library("library-v1:ProblemX+PR0B", None)       -> <LibraryRootV1>
+    * get_v1_or_v2_library("library-v1:ProblemX+PR0B", "65ff...")  -> <LibraryRootV1>
+    * get_v1_or_v2_library("lib:RG:rg-1", None)                    -> <ContentLibraryMetadata>
+    * get_v1_or_v2_library("lib:RG:rg-1", "36")                    -> <ContentLibraryMetadata>
+    * get_v1_or_v2_library("lib:RG:rg-1", "xyz")                   -> <ValueError>
+    * get_v1_or_v2_library("notakey", "xyz")                       -> <InvalidKeyError>
+
+    If you just want to get a V2 library, use `get_library` instead.
+    """
+    library_key: LibraryLocatorV1 | LibraryLocatorV2
+    if isinstance(library_id, str):
+        try:
+            library_key = LibraryLocatorV1.from_string(library_id)
+        except InvalidKeyError:
+            library_key = LibraryLocatorV2.from_string(library_id)
+    else:
+        library_key = library_id
+    if isinstance(library_key, LibraryLocatorV2):
+        v2_version: int | None
+        if version:
+            v2_version = int(version)
+        else:
+            v2_version = None
+        try:
+            library = get_library(library_key)
+            if v2_version is not None and library.version != v2_version:
+                raise NotImplementedError(
+                    f"Tried to load version {v2_version} of blockstore-based library {library_key}. "
+                    f"Currently, only the latest version ({library.version}) may be loaded. "
+                    "This is a known issue. "
+                    "It will be fixed before the production release of blockstore-based (V2) content libraries. "
+                )
+            return library
+        except ContentLibrary.DoesNotExist:
+            return None
+    elif isinstance(library_key, LibraryLocatorV1):
+        v1_version: str | None
+        if version:
+            v1_version = str(version)
+        else:
+            v1_version = None
+        store = modulestore()
+        library_key = library_key.for_branch(ModuleStoreEnum.BranchName.library).for_version(v1_version)
+        try:
+            return store.get_library(library_key, remove_version=False, remove_branch=False, head_validation=False)
+        except ItemNotFoundError:
+            return None
+
+
 # Import from Courseware
 # ======================
 
diff --git a/openedx/core/djangoapps/content_libraries/management/commands/content_libraries_import.py b/openedx/core/djangoapps/content_libraries/management/commands/content_libraries_import.py
index ca1b6e9d0fbf..9b57b42e6aec 100644
--- a/openedx/core/djangoapps/content_libraries/management/commands/content_libraries_import.py
+++ b/openedx/core/djangoapps/content_libraries/management/commands/content_libraries_import.py
@@ -18,7 +18,7 @@
 
 class Command(BaseCommand):
     """
-    Import modulestore content, references by a course, into a Content Libraries
+    Import modulestore content references from a course into a Content Libraries
     library.
     """
 
diff --git a/openedx/core/djangoapps/content_libraries/tasks.py b/openedx/core/djangoapps/content_libraries/tasks.py
index 195de23fde46..f098966b0583 100644
--- a/openedx/core/djangoapps/content_libraries/tasks.py
+++ b/openedx/core/djangoapps/content_libraries/tasks.py
@@ -1,20 +1,58 @@
 """
 Celery tasks for Content Libraries.
-"""
 
+Architecture note:
+
+    Several functions in this file manage the copying/updating of blocks in modulestore
+    and blockstore. These operations should only be performed within the context of CMS.
+    However, due to existing edx-platform code structure, we've had to define the functions
+    in shared source tree (openedx/) and the tasks are registered in both LMS and CMS.
+
+    To ensure that we're not accidentally importing things from blockstore in the LMS context,
+    we use ensure_cms throughout this module.
+
+    A longer-term solution to this issue would be to move the content_libraries app to cms:
+    https://github.com/openedx/edx-platform/issues/33428
+"""
+from __future__ import annotations
 
 import logging
+import hashlib
 
 from celery import shared_task
 from celery_utils.logged_task import LoggedTask
-from edx_django_utils.monitoring import set_code_owner_attribute
+from celery.utils.log import get_task_logger
+from django.contrib.auth.models import User  # lint-amnesty, pylint: disable=imported-auth-user
+from django.core.exceptions import PermissionDenied
+from edx_django_utils.monitoring import set_code_owner_attribute, set_code_owner_attribute_from_module
+from opaque_keys.edx.keys import UsageKey
+from opaque_keys.edx.locator import (
+    BlockUsageLocator,
+    LibraryUsageLocator,
+    LibraryUsageLocatorV2
+)
+from search.search_engine_base import SearchEngine
+
+from user_tasks.tasks import UserTask, UserTaskStatus
+from xblock.fields import Scope
+
+from common.djangoapps.student.auth import has_studio_write_access
 from opaque_keys.edx.keys import CourseKey
+from openedx.core.djangoapps.content_libraries import api as library_api
+from openedx.core.djangoapps.xblock.api import load_block
+from openedx.core.lib import ensure_cms, blockstore_api
+from xmodule.capa_block import ProblemBlock
+from xmodule.library_content_block import ANY_CAPA_TYPE_VALUE, LibraryContentBlock
+from xmodule.library_root_xblock import LibraryRoot as LibraryRootV1
+from xmodule.modulestore.django import modulestore
+from xmodule.modulestore.exceptions import ItemNotFoundError
+from xmodule.modulestore.mixed import MixedModuleStore
 
 from . import api
 from .models import ContentLibraryBlockImportTask
 
-
 logger = logging.getLogger(__name__)
+TASK_LOGGER = get_task_logger(__name__)
 
 
 @shared_task(base=LoggedTask)
@@ -23,6 +61,7 @@ def import_blocks_from_course(import_task_id, course_key_str):
     """
     A Celery task to import blocks from a course through modulestore.
     """
+    ensure_cms("import_blocks_from_course may only be executed in a CMS context")
 
     course_key = CourseKey.from_string(course_key_str)
 
@@ -39,3 +78,302 @@ def on_progress(block_key, block_num, block_count, exception=None):
         edx_client.import_blocks_from_course(
             course_key, on_progress
         )
+
+
+def _normalize_key_for_search(library_key):
+    """ Normalizes library key for use with search indexing """
+    return library_key.replace(version_guid=None, branch=None)
+
+
+def _import_block(store, user_id, source_block, dest_parent_key):
+    """
+    Recursively import a blockstore block and its children.`
+    """
+    def generate_block_key(source_key, dest_parent_key):
+        """
+        Deterministically generate an ID for the new block and return the key
+        """
+        block_id = (
+            dest_parent_key.block_id[:10] +
+            '-' +
+            hashlib.sha1(str(source_key).encode('utf-8')).hexdigest()[:10]
+        )
+        return dest_parent_key.context_key.make_usage_key(source_key.block_type, block_id)
+
+    source_key = source_block.scope_ids.usage_id
+    new_block_key = generate_block_key(source_key, dest_parent_key)
+    try:
+        new_block = store.get_item(new_block_key)
+        if new_block.parent.block_id != dest_parent_key.block_id:
+            raise ValueError(
+                "Expected existing block {} to be a child of {} but instead it's a child of {}".format(
+                    new_block_key, dest_parent_key, new_block.parent,
+                )
+            )
+    except ItemNotFoundError:
+        new_block = store.create_child(
+            user_id,
+            dest_parent_key,
+            source_key.block_type,
+            block_id=new_block_key.block_id,
+        )
+
+    # Prepare a list of this block's static assets; any assets that are referenced as /static/{path} (the
+    # recommended way for referencing them) will stop working, and so we rewrite the url when importing.
+    # Copying assets not advised because modulestore doesn't namespace assets to each block like blockstore, which
+    # might cause conflicts when the same filename is used across imported blocks.
+    if isinstance(source_key, LibraryUsageLocatorV2):
+        all_assets = library_api.get_library_block_static_asset_files(source_key)
+    else:
+        all_assets = []
+
+    for field_name, field in source_block.fields.items():
+        if field.scope not in (Scope.settings, Scope.content):
+            continue  # Only copy authored field data
+        if field.is_set_on(source_block) or field.is_set_on(new_block):
+            field_value = getattr(source_block, field_name)
+            if isinstance(field_value, str):
+                # If string field (which may also be JSON/XML data), rewrite /static/... URLs to point to blockstore
+                for asset in all_assets:
+                    field_value = field_value.replace(f'/static/{asset.path}', asset.url)
+                    # Make sure the URL is one that will work from the user's browser when using the docker devstack
+                    field_value = blockstore_api.force_browser_url(field_value)
+            setattr(new_block, field_name, field_value)
+    new_block.save()
+    store.update_item(new_block, user_id)
+
+    if new_block.has_children:
+        # Delete existing children in the new block, which can be reimported again if they still exist in the
+        # source library
+        for existing_child_key in new_block.children:
+            store.delete_item(existing_child_key, user_id)
+        # Now import the children
+        for child in source_block.get_children():
+            _import_block(store, user_id, child, new_block_key)
+
+    return new_block_key
+
+
+def _filter_child(store, usage_key, capa_type):
+    """
+    Return whether this block is both a problem and has a `capa_type` which is included in the filter.
+    """
+    if usage_key.block_type != "problem":
+        return False
+
+    descriptor = store.get_item(usage_key, depth=0)
+    assert isinstance(descriptor, ProblemBlock)
+    return capa_type in descriptor.problem_types
+
+
+def _problem_type_filter(store, library, capa_type):
+    """ Filters library children by capa type."""
+    try:
+        search_engine = SearchEngine.get_search_engine(index="library_index")
+    except:  # pylint: disable=bare-except
+        search_engine = None
+    if search_engine:
+        filter_clause = {
+            "library": str(_normalize_key_for_search(library.location.library_key)),
+            "content_type": ProblemBlock.INDEX_CONTENT_TYPE,
+            "problem_types": capa_type
+        }
+        search_result = search_engine.search(field_dictionary=filter_clause)
+        results = search_result.get('results', [])
+        return [LibraryUsageLocator.from_string(item['data']['id']) for item in results]
+    else:
+        return [key for key in library.children if _filter_child(store, key, capa_type)]
+
+
+def _import_from_blockstore(user_id, store, dest_block, blockstore_block_ids):
+    """
+    Imports a block from a blockstore-based learning context (usually a
+    content library) into modulestore, as a new child of dest_block.
+    Any existing children of dest_block are replaced.
+    """
+    dest_key = dest_block.scope_ids.usage_id
+    if not isinstance(dest_key, BlockUsageLocator):
+        raise TypeError(f"Destination {dest_key} should be a modulestore course.")
+    if user_id is None:
+        raise ValueError("Cannot check user permissions - LibraryTools user_id is None")
+
+    if len(set(blockstore_block_ids)) != len(blockstore_block_ids):
+        # We don't support importing the exact same block twice because it would break the way we generate new IDs
+        # for each block and then overwrite existing copies of blocks when re-importing the same blocks.
+        raise ValueError("One or more library component IDs is a duplicate.")
+
+    dest_course_key = dest_key.context_key
+    user = User.objects.get(id=user_id)
+    if not has_studio_write_access(user, dest_course_key):
+        raise PermissionDenied()
+
+    # Read the source block; this will also confirm that user has permission to read it.
+    # (This could be slow and use lots of memory, except for the fact that LibraryContentBlock which calls this
+    # should be limiting the number of blocks to a reasonable limit. We load them all now instead of one at a
+    # time in order to raise any errors before we start actually copying blocks over.)
+    orig_blocks = [load_block(UsageKey.from_string(key), user) for key in blockstore_block_ids]
+
+    with store.bulk_operations(dest_course_key):
+        child_ids_updated = set()
+
+        for block in orig_blocks:
+            new_block_id = _import_block(store, user_id, block, dest_key)
+            child_ids_updated.add(new_block_id)
+
+        # Remove any existing children that are no longer used
+        for old_child_id in set(dest_block.children) - child_ids_updated:
+            store.delete_item(old_child_id, user_id)
+        # If this was called from a handler, it will save dest_block at the end, so we must update
+        # dest_block.children to avoid it saving the old value of children and deleting the new ones.
+        dest_block.children = store.get_item(dest_key).children
+
+
+class LibrarySyncChildrenTask(UserTask):  # pylint: disable=abstract-method
+    """
+    Base class for tasks which operate upon library_content children.
+    """
+
+    @classmethod
+    def generate_name(cls, arguments_dict) -> str:
+        """
+        Create a name for this particular import task instance.
+
+        Should be both:
+        a. semi human-friendly
+        b. something we can query in order to determine whether the dest block has a task in progress
+
+        Arguments:
+            arguments_dict (dict): The arguments given to the task function
+        """
+        key = arguments_dict['dest_block_id']
+        return f'Updating {key} from library'
+
+
+# Note: The decorator @set_code_owner_attribute cannot be used here because the UserTaskMixin does stack
+# inspection and can't handle additional decorators. So, wet set the code_owner attribute in the tasks' bodies instead.
+
+@shared_task(base=LibrarySyncChildrenTask, bind=True)
+def sync_from_library(
+    self: LibrarySyncChildrenTask,
+    user_id: int,
+    dest_block_id: str,
+    library_version: str | int | None,
+) -> None:
+    """
+    Celery task to update the children of the library_content block at `dest_block_id`.
+    """
+    set_code_owner_attribute_from_module(__name__)
+    store = modulestore()
+    dest_block = store.get_item(BlockUsageLocator.from_string(dest_block_id))
+    _sync_children(
+        task=self,
+        store=store,
+        user_id=user_id,
+        dest_block=dest_block,
+        library_version=library_version,
+    )
+
+
+@shared_task(base=LibrarySyncChildrenTask, bind=True)
+def duplicate_children(
+    self: LibrarySyncChildrenTask,
+    user_id: int,
+    source_block_id: str,
+    dest_block_id: str,
+) -> None:
+    """
+    Celery task to duplicate the children from `source_block_id` to `dest_block_id`.
+    """
+    set_code_owner_attribute_from_module(__name__)
+    store = modulestore()
+    # First, populate the destination block with children imported from the library.
+    # It's important that _sync_children does this at the currently-set version of the dest library
+    # (someone may be duplicating an out-of-date block).
+    dest_block = store.get_item(BlockUsageLocator.from_string(dest_block_id))
+    _sync_children(
+        task=self,
+        store=store,
+        user_id=user_id,
+        dest_block=dest_block,
+        library_version=dest_block.source_library_version,
+    )
+    # Then, copy over any overridden settings the course author may have applied to the blocks.
+    source_block = store.get_item(BlockUsageLocator.from_string(source_block_id))
+    with store.bulk_operations(source_block.scope_ids.usage_id.context_key):
+        _copy_overrides(store=store, user_id=user_id, source_block=source_block, dest_block=dest_block)
+
+
+def _sync_children(
+    task: LibrarySyncChildrenTask,
+    store: MixedModuleStore,
+    user_id: int,
+    dest_block: LibraryContentBlock,
+    library_version: int | str | None,
+) -> None:
+    """
+    Implementation helper for `sync_from_library` and `duplicate_children` Celery tasks.
+
+    Can update children with a specific library `library_version`, or latest (`library_version=None`).
+    """
+    source_blocks = []
+    library_key = dest_block.source_library_key
+    filter_children = (dest_block.capa_type != ANY_CAPA_TYPE_VALUE)
+    library = library_api.get_v1_or_v2_library(library_key, version=library_version)
+    if not library:
+        task.status.fail(f"Requested library {library_key} not found.")
+    elif isinstance(library, LibraryRootV1):
+        if filter_children:
+            # Apply simple filtering based on CAPA problem types:
+            source_blocks.extend(_problem_type_filter(store, library, dest_block.capa_type))
+        else:
+            source_blocks.extend(library.children)
+        with store.bulk_operations(dest_block.scope_ids.usage_id.context_key):
+            try:
+                dest_block.source_library_version = str(library.location.library_key.version_guid)
+                store.update_item(dest_block, user_id)
+                dest_block.children = store.copy_from_template(
+                    source_blocks, dest_block.location, user_id, head_validation=True
+                )
+                # ^-- copy_from_template updates the children in the DB
+                # but we must also set .children here to avoid overwriting the DB again
+            except Exception as exception:  # pylint: disable=broad-except
+                TASK_LOGGER.exception('Error importing children for %s', dest_block.scope_ids.usage_id, exc_info=True)
+                if task.status.state != UserTaskStatus.FAILED:
+                    task.status.fail({'raw_error_msg': str(exception)})
+                raise
+    elif isinstance(library, library_api.ContentLibraryMetadata):
+        # TODO: add filtering by capa_type when V2 library will support different problem types
+        try:
+            source_blocks = library_api.get_library_blocks(library_key)
+            source_block_ids = [str(block.usage_key) for block in source_blocks]
+            _import_from_blockstore(user_id, store, dest_block, source_block_ids)
+            dest_block.source_library_version = str(library.version)
+            store.update_item(dest_block, user_id)
+        except Exception as exception:  # pylint: disable=broad-except
+            TASK_LOGGER.exception('Error importing children for %s', dest_block.scope_ids.usage_id, exc_info=True)
+            if task.status.state != UserTaskStatus.FAILED:
+                task.status.fail({'raw_error_msg': str(exception)})
+            raise
+
+
+def _copy_overrides(
+    store: MixedModuleStore,
+    user_id: int,
+    source_block: LibraryContentBlock,
+    dest_block: LibraryContentBlock
+) -> None:
+    """
+    Copy any overrides the user has made on children of `source` over to the children of `dest_block`, recursively.
+    """
+    for field in source_block.fields.values():
+        if field.scope == Scope.settings and field.is_set_on(source_block):
+            setattr(dest_block, field.name, field.read_from(source_block))
+    if source_block.has_children:
+        for source_child_key, dest_child_key in zip(source_block.children, dest_block.children):
+            _copy_overrides(
+                store=store,
+                user_id=user_id,
+                source_block=source_block.runtime.get_block(source_child_key),
+                dest_block=dest_block.runtime.get_block(dest_child_key),
+            )
+    store.update_item(dest_block, user_id)
diff --git a/openedx/core/djangolib/testing/utils.py b/openedx/core/djangolib/testing/utils.py
index 1da4ee26bfb5..3beb63586b3f 100644
--- a/openedx/core/djangolib/testing/utils.py
+++ b/openedx/core/djangolib/testing/utils.py
@@ -17,11 +17,14 @@
 from django.conf import settings
 from django.contrib import sites
 from django.core.cache import caches
+from django.core.exceptions import ImproperlyConfigured
 from django.db import DEFAULT_DB_ALIAS, connections
 from django.test import RequestFactory, TestCase, override_settings
 from django.test.utils import CaptureQueriesContext
 from edx_django_utils.cache import RequestCache
 
+from openedx.core.lib import ensure_cms, ensure_lms
+
 
 class CacheIsolationMixin:
     """
@@ -245,11 +248,23 @@ def skip_unless_cms(func):
     """
     Only run the decorated test in the CMS test suite
     """
-    return skipUnless(settings.ROOT_URLCONF == 'cms.urls', 'Test only valid in CMS')(func)
+    try:
+        ensure_cms()
+    except ImproperlyConfigured:
+        is_cms = False
+    else:
+        is_cms = True
+    return skipUnless(is_cms, 'Test only valid in CMS')(func)
 
 
 def skip_unless_lms(func):
     """
     Only run the decorated test in the LMS test suite
     """
-    return skipUnless(settings.ROOT_URLCONF == 'lms.urls', 'Test only valid in LMS')(func)
+    try:
+        ensure_lms()
+    except ImproperlyConfigured:
+        is_lms = False
+    else:
+        is_lms = True
+    return skipUnless(is_lms, 'Test only valid in LMS')(func)
diff --git a/openedx/core/lib/__init__.py b/openedx/core/lib/__init__.py
index e69de29bb2d1..61565e758131 100644
--- a/openedx/core/lib/__init__.py
+++ b/openedx/core/lib/__init__.py
@@ -0,0 +1,40 @@
+"""
+This directory (openedx/core/lib) contains packages of utilities used by
+both LMS and CMS. Packages with models should go in openedx/core/djangoapps instead.
+Packages that are LMS-specific or CMS-specific should be in lms/ or cms/ instead.
+
+This particular module contains a small handful of broadly useful utility functions.
+"""
+
+from django.conf import settings
+from django.core.exceptions import ImproperlyConfigured
+
+
+_LMS_URLCONF = 'lms.urls'
+_CMS_URLCONF = 'cms.urls'
+
+
+def ensure_lms(message: str = "This code may only be called by LMS, but it was called by CMS"):
+    """
+    Assert that we're configured as LMS.
+
+    Useful if you want to forbid learner/instructor-oriented code from accidentally
+    running in the CMS process.
+    """
+    if settings.ROOT_URLCONF != _LMS_URLCONF:
+        raise ImproperlyConfigured(
+            f"{message}. Expected ROOT_URLCONF to be '{_LMS_URLCONF}', got '{settings.ROOT_URLCONF}'"
+        )
+
+
+def ensure_cms(message: str = "This code may only be called by CMS, but it was called by LMS"):
+    """
+    Assert that we're configured as CMS.
+
+    Useful if you want to forbid authoring-oriented code from accidentally
+    running in the LMS process.
+    """
+    if settings.ROOT_URLCONF != 'cms.urls':
+        raise ImproperlyConfigured(
+            f"{message}. Expected ROOT_URLCONF to be '{_CMS_URLCONF}', got '{settings.ROOT_URLCONF}'"
+        )
diff --git a/openedx/core/lib/blockstore_api/methods.py b/openedx/core/lib/blockstore_api/methods.py
index 7d7c65decdc1..86b4730efe1b 100644
--- a/openedx/core/lib/blockstore_api/methods.py
+++ b/openedx/core/lib/blockstore_api/methods.py
@@ -195,15 +195,18 @@ def delete_collection(collection_uuid):
 @toggle_blockstore_api
 def get_bundles(uuids=None, text_search=None):
     """
-    Get the details of all bundles
+    Get the details of all bundles.
     """
     query_params = {}
+    data = {}
     if uuids:
-        query_params['uuid'] = ','.join(map(str, uuids))
+        # Potentially we could have a lot of libraries which will lead to 414 error (Request-URI Too Long)
+        # if sending uuids in the query_params. So we have to use the request data instead.
+        data = {'uuid': ','.join(map(str, uuids))}
     if text_search:
         query_params['text_search'] = text_search
     version_url = api_url('bundles') + '?' + urlencode(query_params)
-    response = api_request('get', version_url)
+    response = api_request('get', version_url, json=data)
     # build bundle from response, convert map object to list and return
     return [_bundle_from_response(item) for item in response]
 
diff --git a/openedx/tests/completion_integration/test_services.py b/openedx/tests/completion_integration/test_services.py
index d27d5e87983a..f4088678d99b 100644
--- a/openedx/tests/completion_integration/test_services.py
+++ b/openedx/tests/completion_integration/test_services.py
@@ -217,8 +217,15 @@ def test_vertical_completion_with_library_content(self):
         # Library Content Block needs its children to be completed.
         self.assertFalse(self.completion_service.can_mark_block_complete_on_view(library_content_block))
 
-        library_content_block.refresh_children()
-        lib_vertical = self.store.get_item(lib_vertical.location)
+        # Dirty hack:
+        # sync_from_library isn't *supposed* to work inside LMS, but this test case was written
+        # before we made that rule. So, we need to trick this part of  test case into thinking that it's
+        # running inside CMS instead of LMS. Please don't copy-paste this trick to any other LMS tests :)
+        # Long-term solution: https://github.com/openedx/edx-platform/issues/33545
+        with override_settings(ROOT_URLCONF="cms.urls"):
+            library_content_block.sync_from_library()
+            lib_vertical = self.store.get_item(lib_vertical.location)
+
         self._bind_course_block(lib_vertical)
         # We need to refetch the library_content_block to retrieve the
         # fresh version from the call to get_item for lib_vertical
diff --git a/webpack.common.config.js b/webpack.common.config.js
index 13d368c559bb..3f8e2f9255fa 100644
--- a/webpack.common.config.js
+++ b/webpack.common.config.js
@@ -458,18 +458,6 @@ module.exports = Merge.smart({
                 {
                     test: /logger/,
                     loader: 'imports-loader?this=>window'
-                },
-                {
-                    test: /\.css$/,
-                    use: [
-                        'style-loader',
-                        {
-                            loader: 'css-loader',
-                            options: {
-                                modules: true
-                            }
-                        }
-                    ]
                 }
             ]
         },
diff --git a/xmodule/assets/library_content/public/js/library_content_edit.js b/xmodule/assets/library_content/public/js/library_content_edit.js
index 3c10f40627a7..c961b05472a4 100644
--- a/xmodule/assets/library_content/public/js/library_content_edit.js
+++ b/xmodule/assets/library_content/public/js/library_content_edit.js
@@ -17,7 +17,7 @@ window.LibraryContentAuthorView = function(runtime, element) {
             element: element,
             message: gettext('Updating with latest library content')
         });
-        $.post(runtime.handlerUrl(element, 'refresh_children')).done(function() {
+        $.post(runtime.handlerUrl(element, 'upgrade_and_sync')).done(function() {
             runtime.notify('save', {
                 state: 'end',
                 element: element
@@ -33,4 +33,22 @@ window.LibraryContentAuthorView = function(runtime, element) {
             }
         });
     });
+    // Hide loader and show element when update task finished.
+    var $loader = $wrapper.find('.ui-loading');
+    var $xblockHeader = $wrapper.find('.xblock-header');
+    if (!$loader.hasClass('is-hidden')) {
+        var timer = setInterval(function() {
+            $.get(runtime.handlerUrl(element, 'children_are_syncing'), function( data ) {
+                if (data !== true) {
+                    $loader.addClass('is-hidden');
+                    $xblockHeader.removeClass('is-hidden');
+                    clearInterval(timer);
+                    runtime.notify('save', {
+                        state: 'end',
+                        element: element
+                    });
+                }
+            })
+        }, 1000);
+    }
 };
diff --git a/xmodule/assets/library_content/public/js/library_content_edit_helpers.js b/xmodule/assets/library_content/public/js/library_content_edit_helpers.js
new file mode 100644
index 000000000000..564cc5fb0fbe
--- /dev/null
+++ b/xmodule/assets/library_content/public/js/library_content_edit_helpers.js
@@ -0,0 +1,54 @@
+/* JavaScript for special editing operations that can be done on LibraryContentXBlock */
+// This is a temporary UI improvements that will be removed when V2 content libraries became
+// fully functional
+
+/**
+ * Toggle the "Problem Type" settings section depending on selected library type.
+ * As for now, the V2 libraries don't support different problem types, so they can't be
+ * filtered by it. We're hiding the Problem Type field for them.
+ */
+function checkProblemTypeShouldBeVisible(editor) {
+    var libraries = editor.find('.wrapper-comp-settings.metadata_edit.is-active')
+        .data().metadata.source_library_id.options;
+    var selectedIndex = $("select[name='Library']", editor)[0].selectedIndex;
+    var libraryKey = libraries[selectedIndex].value;
+    var url = URI('/xblock')
+        .segment(editor.find('.xblock.xblock-studio_view.xblock-studio_view-library_content.xblock-initialized')
+        .data('usage-id'))
+        .segment('handler')
+        .segment('is_v2_library');
+
+    $.ajax({
+        type: 'POST',
+        url: url,
+        data: JSON.stringify({'library_key': libraryKey}),
+        success: function(data) {
+            var problemTypeSelect = editor.find("select[name='Problem Type']")
+                .parents("li.field.comp-setting-entry.metadata_entry");
+            data.is_v2 ? problemTypeSelect.hide() : problemTypeSelect.show();
+        }
+    });
+}
+
+/**
+ * Waits untill editor html loaded, than calls checks for Program Type field toggling.
+ */
+function waitForEditorLoading() {
+    var checkContent = setInterval(function() {
+        var $modal = $('.xblock-editor');
+        var content = $modal.html();
+        if (content) {
+            clearInterval(checkContent);
+            checkProblemTypeShouldBeVisible($modal);
+        }
+    }, 10);
+}
+// Initial call
+waitForEditorLoading();
+
+var $librarySelect = $("select[name='Library']");
+$(document).on('change', $librarySelect, waitForEditorLoading)
+
+var $libraryContentEditors = $('.xblock-header.xblock-header-library_content');
+var $editBtns = $libraryContentEditors.find('.action-item.action-edit');
+$(document).on('click', $editBtns, waitForEditorLoading)
diff --git a/xmodule/library_content_block.py b/xmodule/library_content_block.py
index f8f0521ff530..e4c4af267a1f 100644
--- a/xmodule/library_content_block.py
+++ b/xmodule/library_content_block.py
@@ -1,27 +1,28 @@
 """
 LibraryContent: The XBlock used to include blocks from a library in a course.
 """
-
+from __future__ import annotations
 
 import json
 import logging
 import random
 from copy import copy
-from gettext import ngettext
-from rest_framework import status
+from gettext import ngettext, gettext
 
 import bleach
 from django.conf import settings
+from django.core.exceptions import ObjectDoesNotExist, PermissionDenied
 from django.utils.functional import classproperty
-from lazy import lazy
 from lxml import etree
 from lxml.etree import XMLSyntaxError
-from opaque_keys.edx.locator import LibraryLocator
+from opaque_keys import InvalidKeyError
+from opaque_keys.edx.locator import LibraryLocator, LibraryLocatorV2
+from rest_framework import status
 from web_fragments.fragment import Fragment
 from webob import Response
 from xblock.completable import XBlockCompletionMode
 from xblock.core import XBlock
-from xblock.fields import Integer, List, Scope, String, Boolean
+from xblock.fields import Boolean, Integer, List, Scope, String
 
 from xmodule.capa.responsetypes import registry
 from xmodule.mako_block import MakoTemplateBlockBase
@@ -30,14 +31,13 @@
 from xmodule.validation import StudioValidation, StudioValidationMessage
 from xmodule.xml_block import XmlMixin
 from xmodule.x_module import (
-    ResourceTemplates,
-    shim_xmodule_js,
     STUDENT_VIEW,
+    ResourceTemplates,
     XModuleMixin,
     XModuleToXBlockMixin,
+    shim_xmodule_js,
 )
 
-
 # Make '_' a no-op so we can scrape strings. Using lambda instead of
 #  `django.utils.translation.ugettext_noop` because Django cannot be imported in this file
 _ = lambda text: text
@@ -66,8 +66,16 @@ def _get_capa_types():
     ], key=lambda item: item.get('display_name'))
 
 
-@XBlock.wants('library_tools')  # Only needed in studio
-@XBlock.wants('studio_user_permissions')  # Only available in studio
+class LibraryToolsUnavailable(ValueError):
+    """
+    Raised when the library_tools service is requested in a runtime that doesn't provide it.
+    """
+    def __init__(self):
+        super().__init__("Needed 'library_tools' features which were not available in the current runtime")
+
+
+@XBlock.wants('library_tools')  # TODO: Split this service into its LMS and CMS parts.
+@XBlock.wants('studio_user_permissions')  # Only available in CMS.
 @XBlock.wants('user')
 @XBlock.needs('mako')
 class LibraryContentBlock(
@@ -169,9 +177,14 @@ def completion_mode(cls):  # pylint: disable=no-self-argument
     @property
     def source_library_key(self):
         """
-        Convenience method to get the library ID as a LibraryLocator and not just a string
+        Convenience method to get the library ID as a LibraryLocator and not just a string.
+
+        Supports either library v1 or library v2 locators.
         """
-        return LibraryLocator.from_string(self.source_library_id)
+        try:
+            return LibraryLocator.from_string(self.source_library_id)
+        except InvalidKeyError:
+            return LibraryLocatorV2.from_string(self.source_library_id)
 
     @classmethod
     def make_selection(cls, selected, children, max_count, mode):
@@ -324,7 +337,7 @@ def selected_children(self):
         block_keys = self.make_selection(self.selected, self.children, max_count, "random")  # pylint: disable=no-member
 
         # Publish events for analytics purposes:
-        lib_tools = self.runtime.service(self, 'library_tools')
+        lib_tools = self.get_tools()
         format_block_keys = lambda keys: lib_tools.create_block_analytics_summary(self.location.course_key, keys)
         self.publish_selected_children_events(
             block_keys,
@@ -413,8 +426,11 @@ def author_view(self, context):
         fragment = Fragment()
         root_xblock = context.get('root_xblock')
         is_root = root_xblock and root_xblock.location == self.location
-
-        if is_root:
+        try:
+            is_updating = self.get_tools().are_children_syncing(self)
+        except LibraryToolsUnavailable:
+            is_updating = False
+        if is_root and not is_updating:
             # User has clicked the "View" link. Show a preview of all possible children:
             if self.children:  # pylint: disable=no-member
                 max_count = self.max_count
@@ -428,9 +444,11 @@ def author_view(self, context):
                     }))
                 context['can_edit_visibility'] = False
                 context['can_move'] = False
+                context['can_collapse'] = True
                 self.render_children(context, fragment, can_reorder=False, can_add=False)
         # else: When shown on a unit page, don't show any sort of preview -
         # just the status of this block in the validation area.
+        context['is_loading'] = is_updating
 
         # The following JS is used to make the "Update now" button work on the unit page and the container view:
         fragment.add_javascript_url(self.runtime.local_resource_url(self, 'public/js/library_content_edit.js'))
@@ -444,6 +462,7 @@ def studio_view(self, _context):
         fragment = Fragment(
             self.runtime.service(self, 'mako').render_cms_template(self.mako_template, self.get_context())
         )
+        fragment.add_javascript_url(self.runtime.local_resource_url(self, 'public/js/library_content_edit_helpers.js'))
         add_webpack_js_to_fragment(fragment, 'LibraryContentBlockEditor')
         shim_xmodule_js(fragment, self.studio_js_module_name)
         return fragment
@@ -466,12 +485,14 @@ def non_editable_metadata_fields(self):
         ])
         return non_editable_fields
 
-    @lazy
-    def tools(self):
+    def get_tools(self, to_read_library_content: bool = False) -> 'LibraryToolsService':
         """
-        Grab the library tools service or raise an error.
+        Grab the library tools service and confirm that it'll work for us. Else, raise LibraryToolsUnavailable.
         """
-        return self.runtime.service(self, 'library_tools')
+        if tools := self.runtime.service(self, 'library_tools'):
+            if (not to_read_library_content) or tools.can_use_library_content(self):
+                return tools
+        raise LibraryToolsUnavailable()
 
     def get_user_id(self):
         """
@@ -485,40 +506,86 @@ def get_user_id(self):
             user_id = None
         return user_id
 
+    def _validate_sync_permissions(self):
+        """
+        Raises PermissionDenied() if we can't confirm that user has write on this block and read on source library.
+
+        If source library isn't set, then that's OK.
+        """
+        if not (user_perms := self.runtime.service(self, 'studio_user_permissions')):
+            raise PermissionDenied("Access cannot be validated in the current runtime.")
+        if not user_perms.can_write(self.scope_ids.usage_id.context_key):
+            raise PermissionDenied(f"Cannot write to block at {self.scope_ids.usage_id}")
+        if self.source_library_key:
+            if not user_perms.can_read(self.source_library_key):
+                raise PermissionDenied(f"Cannot read library at {self.source_library_key}")
+
     @XBlock.handler
-    def refresh_children(self, request=None, suffix=None):  # lint-amnesty, pylint: disable=unused-argument
+    def upgrade_and_sync(self, request=None, suffix=None):  # pylint: disable=unused-argument
         """
-        Refresh children:
-        This method is to be used when any of the libraries that this block
-        references have been updated. It will re-fetch all matching blocks from
-        the libraries, and copy them as children of this block. The children
-        will be given new block_ids, but the definition ID used should be the
-        exact same definition ID used in the library.
+        HTTP handler allowing Studio users to update to latest version of source library and synchronize children.
 
-        This method will update this block's 'source_library_id' field to store
-        the version number of the libraries used, so we easily determine if
-        this block is up to date or not.
+        This is a thin wrapper around `sync_from_library(upgrade_to_latest=True)`, plus permission checks.
+
+        Returns 400 if libraray tools or user permission services are not available.
+        Returns 403/404 if user lacks read access on source library or write access on this block.
         """
-        user_perms = self.runtime.service(self, 'studio_user_permissions')
-        if not self.tools:
-            return Response("Library Tools unavailable in current runtime.", status=400)
-        self.tools.update_children(self, user_perms)
+        self._validate_sync_permissions()
+        if not self.source_library_id:
+            return Response(_("Source content library has not been specified."), status=400)
+        try:
+            self.sync_from_library(upgrade_to_latest=True)
+        except LibraryToolsUnavailable:
+            return Response(_("Content libraries are not available in the current runtime."), status=400)
+        except ObjectDoesNotExist:
+            return Response(
+                _("Source content library does not exist: {source_library_id}").format(
+                    source_library_id=self.source_library_id
+                ),
+                status=400,
+            )
         return Response()
 
-    # Copy over any overridden settings the course author may have applied to the blocks.
-    def _copy_overrides(self, store, user_id, source, dest):
+    def sync_from_library(self, upgrade_to_latest: bool = False) -> None:
+        """
+        Synchronize children with source library.
+
+        If `upgrade_to_latest==True` or if source library version is unset, update library version to latest.
+        Otherwise, use current source library version.
+
+        Raises ObjectDoesNotExist if library or version is missing.
         """
-        Copy any overrides the user has made on blocks in this library.
+        self.get_tools(to_read_library_content=True).trigger_library_sync(
+            dest_block=self,
+            library_version=(None if upgrade_to_latest else self.source_library_version),
+        )
+
+    @XBlock.json_handler
+    def is_v2_library(self, data, suffix=''):  # pylint: disable=unused-argument
         """
-        for field in source.fields.values():
-            if field.scope == Scope.settings and field.is_set_on(source):
-                setattr(dest, field.name, field.read_from(source))
-        if source.has_children:
-            source_children = [self.runtime.get_block(source_key) for source_key in source.children]
-            dest_children = [self.runtime.get_block(dest_key) for dest_key in dest.children]
-            for source_child, dest_child in zip(source_children, dest_children):
-                self._copy_overrides(store, user_id, source_child, dest_child)
-        store.update_item(dest, user_id)
+        Check the library version by library_id.
+
+        This is a temporary handler needed for hiding the Problem Type xblock editor field for V2 libraries.
+        """
+        lib_key = data.get('library_key')
+        try:
+            LibraryLocatorV2.from_string(lib_key)
+        except InvalidKeyError:
+            is_v2 = False
+        else:
+            is_v2 = True
+        return {'is_v2': is_v2}
+
+    @XBlock.handler
+    def children_are_syncing(self, request, suffix=''):  # pylint: disable=unused-argument
+        """
+        Returns whether this block is currently having its children updated from the source library.
+        """
+        try:
+            is_updating = self.get_tools().are_children_syncing(self)
+        except LibraryToolsUnavailable:
+            is_updating = False
+        return Response(json.dumps(is_updating))
 
     def studio_post_duplicate(self, store, source_block):
         """
@@ -527,27 +594,17 @@ def studio_post_duplicate(self, store, source_block):
 
         Otherwise we'll end up losing data on the next refresh.
         """
-        # The first task will be to refresh our copy of the library to generate the children.
-        # We must do this at the currently set version of the library block. Otherwise we may not have
-        # exactly the same children-- someone may be duplicating an out of date block, after all.
-        user_id = self.get_user_id()
-        user_perms = self.runtime.service(self, 'studio_user_permissions')
-        if not self.tools:
-            raise RuntimeError("Library tools unavailable, duplication will not be sane!")
-        self.tools.update_children(self, user_perms, version=self.source_library_version)
-
-        self._copy_overrides(store, user_id, source_block, self)
-
-        # Children have been handled.
-        return True
+        self._validate_sync_permissions()
+        self.get_tools(to_read_library_content=True).trigger_duplication(source_block=source_block, dest_block=self)
+        return True  # Children have been handled.
 
     def _validate_library_version(self, validation, lib_tools, version, library_key):
         """
         Validates library version
         """
-        latest_version = lib_tools.get_library_version(library_key)
+        latest_version = lib_tools.get_latest_library_version(library_key)
         if latest_version is not None:
-            if version is None or version != str(latest_version):
+            if version is None or version != latest_version:
                 validation.set_summary(
                     StudioValidationMessage(
                         StudioValidationMessage.WARNING,
@@ -586,8 +643,9 @@ def validate(self):
         validation = super().validate()
         if not isinstance(validation, StudioValidation):
             validation = StudioValidation.copy(validation)
-        library_tools = self.runtime.service(self, "library_tools")
-        if not (library_tools and library_tools.can_use_library_content(self)):
+        try:
+            lib_tools = self.get_tools(to_read_library_content=True)
+        except LibraryToolsUnavailable:
             validation.set_summary(
                 StudioValidationMessage(
                     StudioValidationMessage.ERROR,
@@ -608,10 +666,9 @@ def validate(self):
                 )
             )
             return validation
-        lib_tools = self.runtime.service(self, 'library_tools')
         self._validate_library_version(validation, lib_tools, self.source_library_version, self.source_library_key)
 
-        # Note: we assume refresh_children() has been called
+        # Note: we assume children have been synced
         # since the last time fields like source_library_id or capa_types were changed.
         matching_children_count = len(self.children)  # pylint: disable=no-member
         if matching_children_count == 0:
@@ -619,7 +676,8 @@ def validate(self):
                 validation,
                 StudioValidationMessage(
                     StudioValidationMessage.WARNING,
-                    _('There are no matching problem types in the specified libraries.'),
+                    (gettext('There are no problems in the specified library of type {capa_type}.'))
+                    .format(capa_type=self.capa_type),
                     action_class='edit-button',
                     action_label=_("Select another problem type.")
                 )
@@ -653,7 +711,7 @@ def source_library_values(self):
         """
         Return a list of possible values for self.source_library_id
         """
-        lib_tools = self.runtime.service(self, 'library_tools')
+        lib_tools = self.get_tools()
         user_perms = self.runtime.service(self, 'studio_user_permissions')
         all_libraries = [
             (key, bleach.clean(name)) for key, name in lib_tools.list_available_libraries()
@@ -666,17 +724,20 @@ def source_library_values(self):
         values = [{"display_name": name, "value": str(key)} for key, name in all_libraries]
         return values
 
-    def editor_saved(self, user, old_metadata, old_content):  # lint-amnesty, pylint: disable=unused-argument
+    def post_editor_saved(self, user, old_metadata, old_content):  # pylint: disable=unused-argument
         """
-        If source_library_id or capa_type has been edited, refresh_children automatically.
+        If source library or capa_type have been edited, upgrade library & sync automatically.
+
+        TODO: capa_type doesn't really need to trigger an upgrade once we've migrated to V2.
         """
-        old_source_library_id = old_metadata.get('source_library_id', [])
-        if (old_source_library_id != self.source_library_id or
-                old_metadata.get('capa_type', ANY_CAPA_TYPE_VALUE) != self.capa_type):
+        source_lib_changed = (self.source_library_id != old_metadata.get("source_library_id", ""))
+        capa_filter_changed = (self.capa_type != old_metadata.get("capa_type", ANY_CAPA_TYPE_VALUE))
+        if source_lib_changed or capa_filter_changed:
             try:
-                self.refresh_children()
-            except ValueError:
-                pass  # The validation area will display an error message, no need to do anything now.
+                self.sync_from_library(upgrade_to_latest=True)
+            except (ObjectDoesNotExist, LibraryToolsUnavailable):
+                # The validation area will display an error message, no need to do anything now.
+                pass
 
     def has_dynamic_children(self):
         """
diff --git a/xmodule/library_tools.py b/xmodule/library_tools.py
index 748f1b58ac23..6d8106caeaf3 100644
--- a/xmodule/library_tools.py
+++ b/xmodule/library_tools.py
@@ -1,22 +1,18 @@
 """
 XBlock runtime services for LibraryContentBlock
 """
-import hashlib
+from __future__ import annotations
 
 from django.contrib.auth.models import User  # lint-amnesty, pylint: disable=imported-auth-user
-from django.core.exceptions import PermissionDenied
-from opaque_keys.edx.keys import UsageKey
-from opaque_keys.edx.locator import LibraryLocator, LibraryUsageLocator, LibraryUsageLocatorV2, BlockUsageLocator
-from search.search_engine_base import SearchEngine
-from xblock.fields import Scope
+from django.conf import settings
+from django.core.exceptions import ObjectDoesNotExist
+from user_tasks.models import UserTaskStatus
 
+from openedx.core.lib import ensure_cms
 from openedx.core.djangoapps.content_libraries import api as library_api
-from openedx.core.djangoapps.xblock.api import load_block
-from openedx.core.lib import blockstore_api
-from common.djangoapps.student.auth import has_studio_write_access
-from xmodule.capa_block import ProblemBlock
-from xmodule.library_content_block import ANY_CAPA_TYPE_VALUE
-from xmodule.modulestore import ModuleStoreEnum
+from openedx.core.djangoapps.content_libraries import tasks as library_tasks
+from xmodule.library_content_block import LibraryContentBlock
+from xmodule.library_root_xblock import LibraryRoot as LibraryRootV1
 from xmodule.modulestore.exceptions import ItemNotFoundError
 
 
@@ -27,43 +23,34 @@ def normalize_key_for_search(library_key):
 
 class LibraryToolsService:
     """
-    Service that allows LibraryContentBlock to interact with libraries in the
-    modulestore.
+    Service for LibraryContentBlock.
+
+    Allows to interact with libraries in the modulestore and blockstore.
+
+    Should only be used in the CMS.
     """
     def __init__(self, modulestore, user_id):
         self.store = modulestore
         self.user_id = user_id
 
-    def _get_library(self, library_key):
+    def get_latest_library_version(self, lib_key) -> str | None:
         """
-        Given a library key like "library-v1:ProblemX+PR0B", return the
-        'library' XBlock with meta-information about the library.
-
-        A specific version may be specified.
+        Get the version of the given library as string.
 
-        Returns None on error.
+        The return value (library version) could be:
+            str(<ObjectID>) - for V1 library;
+            str(<int>)      - for V2 library.
+            None            - if the library does not exist.
         """
-        if not isinstance(library_key, LibraryLocator):
-            library_key = LibraryLocator.from_string(library_key)
-
-        try:
-            return self.store.get_library(
-                library_key, remove_version=False, remove_branch=False, head_validation=False
-            )
-        except ItemNotFoundError:
+        library = library_api.get_v1_or_v2_library(lib_key, version=None)
+        if not library:
             return None
-
-    def get_library_version(self, lib_key):
-        """
-        Get the version (an ObjectID) of the given library.
-        Returns None if the library does not exist.
-        """
-        library = self._get_library(lib_key)
-        if library:
+        elif isinstance(library, LibraryRootV1):
             # We need to know the library's version so ensure it's set in library.location.library_key.version_guid
             assert library.location.library_key.version_guid is not None
-            return library.location.library_key.version_guid
-        return None
+            return str(library.location.library_key.version_guid)
+        elif isinstance(library, library_api.ContentLibraryMetadata):
+            return str(library.version)
 
     def create_block_analytics_summary(self, course_key, block_keys):
         """
@@ -103,202 +90,104 @@ def summarize_block(usage_key):
             result_json.append(info)
         return result_json
 
-    def _problem_type_filter(self, library, capa_type):
-        """ Filters library children by capa type"""
-        search_engine = SearchEngine.get_search_engine(index="library_index")
-        if search_engine:
-            filter_clause = {
-                "library": str(normalize_key_for_search(library.location.library_key)),
-                "content_type": ProblemBlock.INDEX_CONTENT_TYPE,
-                "problem_types": capa_type
-            }
-            search_result = search_engine.search(field_dictionary=filter_clause)
-            results = search_result.get('results', [])
-            return [LibraryUsageLocator.from_string(item['data']['id']) for item in results]
-        else:
-            return [key for key in library.children if self._filter_child(key, capa_type)]
-
-    def _filter_child(self, usage_key, capa_type):
-        """
-        Filters children by CAPA problem type, if configured
-        """
-        if usage_key.block_type != "problem":
-            return False
-
-        block = self.store.get_item(usage_key, depth=0)
-        assert isinstance(block, ProblemBlock)
-        return capa_type in block.problem_types
-
     def can_use_library_content(self, block):
         """
         Determines whether a modulestore holding a course_id supports libraries.
         """
         return self.store.check_supports(block.location.course_key, 'copy_from_template')
 
-    def update_children(self, dest_block, user_perms=None, version=None):
-        """
-        This method is to be used when the library that a LibraryContentBlock
-        references has been updated. It will re-fetch all matching blocks from
-        the libraries, and copy them as children of dest_block. The children
-        will be given new block_ids, but the definition ID used should be the
-        exact same definition ID used in the library.
-
-        This method will update dest_block's 'source_library_version' field to
-        store the version number of the libraries used, so we easily determine
-        if dest_block is up to date or not.
-        """
-        if user_perms and not user_perms.can_write(dest_block.location.course_key):
-            raise PermissionDenied()
-
+    def trigger_library_sync(self, dest_block: LibraryContentBlock, library_version: str | int | None) -> None:
+        """
+        Queue task to synchronize the children of `dest_block` with it source library (at `library_version` or latest).
+
+        Raises ObjectDoesNotExist if library/version cannot be found.
+
+        The task will:
+        * Load that library at `dest_block.source_library_id` and `library_version`.
+          * If `library_version` is None, load the latest.
+          * Update `dest_block.source_library_version` based on what is loaded.
+        * Ensure that `dest_block` has children corresponding to all matching source library blocks.
+          * Considered fields of `dest_block` include: `source_library_id`, `source_library_version`, `capa_type`.
+            library version, and upate `dest_block.source_library_version` to match.
+        * Derive each child block id as a function of `dest_block`'s id and the library block's definition id.
+        * Follow these important create/update/delete semantics for children:
+          * When a matching library child DOES NOT EXIT in `dest_block.children`: import it in as a new block.
+          * When a matching library child ALREADY EXISTS in `dest_block.children`: re-import its definition, clobbering
+            any content updates in this existing child, but preserving any settings overrides in the existing child.
+          * When a block in `dest_block.children` DOES NOT MATCH any library children: delete it from
+            `dest_block.children`.
+        """
+        ensure_cms("library_content block children may only be synced in a CMS context")
+        if not isinstance(dest_block, LibraryContentBlock):
+            raise ValueError(f"Can only sync children for library_content blocks, not {dest_block.tag} blocks.")
         if not dest_block.source_library_id:
             dest_block.source_library_version = ""
             return
-
-        source_blocks = []
         library_key = dest_block.source_library_key
-        if version:
-            library_key = library_key.replace(branch=ModuleStoreEnum.BranchName.library, version_guid=version)
-        library = self._get_library(library_key)
-        if library is None:
-            raise ValueError(f"Requested library {library_key} not found.")
-        if user_perms and not user_perms.can_read(library_key):
-            raise PermissionDenied()
-        filter_children = (dest_block.capa_type != ANY_CAPA_TYPE_VALUE)
-        if filter_children:
-            # Apply simple filtering based on CAPA problem types:
-            source_blocks.extend(self._problem_type_filter(library, dest_block.capa_type))
-        else:
-            source_blocks.extend(library.children)
-
-        with self.store.bulk_operations(dest_block.location.course_key):
-            dest_block.source_library_version = str(library.location.library_key.version_guid)
-            self.store.update_item(dest_block, self.user_id)
-            head_validation = not version
-            dest_block.children = self.store.copy_from_template(
-                source_blocks, dest_block.location, self.user_id, head_validation=head_validation
+        if not library_api.get_v1_or_v2_library(library_key, version=library_version):
+            if library_version:
+                raise ObjectDoesNotExist(f"Version {library_version} of library {library_key} not found.")
+            raise ObjectDoesNotExist(f"Library {library_key} not found.")
+        library_tasks.sync_from_library.delay(
+            user_id=self.user_id,
+            dest_block_id=str(dest_block.scope_ids.usage_id),
+            library_version=library_version,
+        )
+
+    def trigger_duplication(self, source_block: LibraryContentBlock, dest_block: LibraryContentBlock) -> None:
+        """
+        Queue a task to duplicate the children of `source_block` to `dest_block`.
+        """
+        ensure_cms("library_content block children may only be duplicated in a CMS context")
+        if not isinstance(dest_block, LibraryContentBlock):
+            raise ValueError(f"Can only duplicate children for library_content blocks, not {dest_block.tag} blocks.")
+        if source_block.scope_ids.usage_id.context_key != source_block.scope_ids.usage_id.context_key:
+            raise ValueError(
+                "Cannot duplicate_children across different learning contexts "
+                f"(source={source_block.scope_ids.usage_id}, dest={dest_block.scope_ids.usage_id})"
+            )
+        if source_block.source_library_key != dest_block.source_library_key:
+            raise ValueError(
+                "Cannot duplicate_children across different source libraries or versions thereof "
+                f"({source_block.source_library_key=}, {dest_block.source_library_key=})."
             )
-            # ^-- copy_from_template updates the children in the DB
-            # but we must also set .children here to avoid overwriting the DB again
+        library_tasks.duplicate_children.delay(
+            user_id=self.user_id,
+            source_block_id=str(source_block.scope_ids.usage_id),
+            dest_block_id=str(dest_block.scope_ids.usage_id),
+        )
 
-    def list_available_libraries(self):
+    def are_children_syncing(self, library_content_block: LibraryContentBlock) -> bool:
         """
-        List all known libraries.
-        Returns tuples of (LibraryLocator, display_name)
+        Is a task currently running to sync the children of `library_content_block`?
+
+        Only checks the latest task (so that this block's state can't get permanently messed up by
+        some older task that's stuck in PENDING).
         """
-        return [
-            (lib.location.library_key.replace(version_guid=None, branch=None), lib.display_name)
-            for lib in self.store.get_library_summaries()
+        args = {'dest_block_id': library_content_block.scope_ids.usage_id}
+        name = library_tasks.LibrarySyncChildrenTask.generate_name(args)
+        status = UserTaskStatus.objects.filter(name=name).order_by('-created').first()
+        return status and status.state in [
+            UserTaskStatus.IN_PROGRESS, UserTaskStatus.PENDING, UserTaskStatus.RETRYING
         ]
 
-    def import_from_blockstore(self, dest_block, blockstore_block_ids):
+    def list_available_libraries(self):
         """
-        Imports a block from a blockstore-based learning context (usually a
-        content library) into modulestore, as a new child of dest_block.
-        Any existing children of dest_block are replaced.
+        List all known libraries.
 
-        This is only used by LibraryContentBlock. It should verify first that
-        the number of block IDs is reasonable.
+        Collects Only V2 Libaries if the FEATURES[ENABLE_LIBRARY_AUTHORING_MICROFRONTEND] setting is True.
+        Otherwise, return all v1 and v2 libraries.
+        Returns tuples of (library key, display_name).
         """
-        dest_key = dest_block.scope_ids.usage_id
-        if not isinstance(dest_key, BlockUsageLocator):
-            raise TypeError(f"Destination {dest_key} should be a modulestore course.")
-        if self.user_id is None:
-            raise ValueError("Cannot check user permissions - LibraryTools user_id is None")
-
-        if len(set(blockstore_block_ids)) != len(blockstore_block_ids):
-            # We don't support importing the exact same block twice because it would break the way we generate new IDs
-            # for each block and then overwrite existing copies of blocks when re-importing the same blocks.
-            raise ValueError("One or more library component IDs is a duplicate.")
-
-        dest_course_key = dest_key.context_key
         user = User.objects.get(id=self.user_id)
-        if not has_studio_write_access(user, dest_course_key):
-            raise PermissionDenied()
-
-        # Read the source block; this will also confirm that user has permission to read it.
-        # (This could be slow and use lots of memory, except for the fact that LibraryContentBlock which calls this
-        # should be limiting the number of blocks to a reasonable limit. We load them all now instead of one at a
-        # time in order to raise any errors before we start actually copying blocks over.)
-        orig_blocks = [load_block(UsageKey.from_string(key), user) for key in blockstore_block_ids]
-
-        with self.store.bulk_operations(dest_course_key):
-            child_ids_updated = set()
-
-            for block in orig_blocks:
-                new_block_id = self._import_block(block, dest_key)
-                child_ids_updated.add(new_block_id)
-
-            # Remove any existing children that are no longer used
-            for old_child_id in set(dest_block.children) - child_ids_updated:
-                self.store.delete_item(old_child_id, self.user_id)
-            # If this was called from a handler, it will save dest_block at the end, so we must update
-            # dest_block.children to avoid it saving the old value of children and deleting the new ones.
-            dest_block.children = self.store.get_item(dest_key).children
-
-    def _import_block(self, source_block, dest_parent_key):
-        """
-        Recursively import a blockstore block and its children. See import_from_blockstore above.
-        """
-        def generate_block_key(source_key, dest_parent_key):
-            """
-            Deterministically generate an ID for the new block and return the key
-            """
-            block_id = (
-                dest_parent_key.block_id[:10] +
-                '-' +
-                hashlib.sha1(str(source_key).encode('utf-8')).hexdigest()[:10]
-            )
-            return dest_parent_key.context_key.make_usage_key(source_key.block_type, block_id)
-
-        source_key = source_block.scope_ids.usage_id
-        new_block_key = generate_block_key(source_key, dest_parent_key)
-        try:
-            new_block = self.store.get_item(new_block_key)
-            if new_block.parent != dest_parent_key:
-                raise ValueError(
-                    "Expected existing block {} to be a child of {} but instead it's a child of {}".format(
-                        new_block_key, dest_parent_key, new_block.parent,
-                    )
-                )
-        except ItemNotFoundError:
-            new_block = self.store.create_child(
-                user_id=self.user_id,
-                parent_usage_key=dest_parent_key,
-                block_type=source_key.block_type,
-                block_id=new_block_key.block_id,
-            )
-
-        # Prepare a list of this block's static assets; any assets that are referenced as /static/{path} (the
-        # recommended way for referencing them) will stop working, and so we rewrite the url when importing.
-        # Copying assets not advised because modulestore doesn't namespace assets to each block like blockstore, which
-        # might cause conflicts when the same filename is used across imported blocks.
-        if isinstance(source_key, LibraryUsageLocatorV2):
-            all_assets = library_api.get_library_block_static_asset_files(source_key)
-        else:
-            all_assets = []
-
-        for field_name, field in source_block.fields.items():
-            if field.scope not in (Scope.settings, Scope.content):
-                continue  # Only copy authored field data
-            if field.is_set_on(source_block) or field.is_set_on(new_block):
-                field_value = getattr(source_block, field_name)
-                if isinstance(field_value, str):
-                    # If string field (which may also be JSON/XML data), rewrite /static/... URLs to point to blockstore
-                    for asset in all_assets:
-                        field_value = field_value.replace(f'/static/{asset.path}', asset.url)
-                        # Make sure the URL is one that will work from the user's browser when using the docker devstack
-                        field_value = blockstore_api.force_browser_url(field_value)
-                setattr(new_block, field_name, field_value)
-        new_block.save()
-        self.store.update_item(new_block, self.user_id)
-
-        if new_block.has_children:
-            # Delete existing children in the new block, which can be reimported again if they still exist in the
-            # source library
-            for existing_child_key in new_block.children:
-                self.store.delete_item(existing_child_key, self.user_id)
-            # Now import the children
-            for child in source_block.get_children():
-                self._import_block(child, new_block_key)
+        v1_libs = [
+            (lib.location.library_key.replace(version_guid=None, branch=None), lib.display_name)
+            for lib in self.store.get_library_summaries()
+        ]
+        v2_query = library_api.get_libraries_for_user(user)
+        v2_libs_with_meta = library_api.get_metadata_from_index(v2_query)
+        v2_libs = [(lib.key, lib.title) for lib in v2_libs_with_meta]
 
-        return new_block_key
+        if settings.FEATURES.get('ENABLE_LIBRARY_AUTHORING_MICROFRONTEND'):
+            return v2_libs
+        return v1_libs + v2_libs
diff --git a/xmodule/modulestore/split_mongo/caching_descriptor_system.py b/xmodule/modulestore/split_mongo/caching_descriptor_system.py
index b3234df5a28e..b0965d63fecb 100644
--- a/xmodule/modulestore/split_mongo/caching_descriptor_system.py
+++ b/xmodule/modulestore/split_mongo/caching_descriptor_system.py
@@ -4,6 +4,7 @@
 import sys
 import weakref
 
+from crum import get_current_user
 from fs.osfs import OSFS
 from lazy import lazy
 from opaque_keys.edx.locator import BlockUsageLocator, DefinitionLocator, LocalId
@@ -74,7 +75,11 @@ def __init__(self, modulestore, course_entry, default_class, module_data, lazy,
         self.module_data = module_data
         self.default_class = default_class
         self.local_modules = {}
-        self._services['library_tools'] = LibraryToolsService(modulestore, user_id=None)
+
+        user = get_current_user()
+        user_id = user.id if user else None
+        self._services['library_tools'] = LibraryToolsService(modulestore, user_id=user_id)
+
         # Cache of block field datas, keyed by the XBlock instance (since the ScopeId changes!)
         self.block_field_datas = weakref.WeakKeyDictionary()
 
diff --git a/xmodule/modulestore/xml_importer.py b/xmodule/modulestore/xml_importer.py
index 45023b1a1a07..3c1345b44e61 100644
--- a/xmodule/modulestore/xml_importer.py
+++ b/xmodule/modulestore/xml_importer.py
@@ -29,6 +29,7 @@
 from abc import abstractmethod
 
 import xblock
+from django.core.exceptions import ObjectDoesNotExist
 from django.utils.translation import gettext as _
 from lxml import etree
 from opaque_keys.edx.keys import UsageKey
@@ -42,7 +43,6 @@
 from xmodule.assetstore import AssetMetadata
 from xmodule.contentstore.content import StaticContent
 from xmodule.errortracker import make_error_tracker
-from xmodule.library_tools import LibraryToolsService
 from xmodule.modulestore import ModuleStoreEnum
 from xmodule.modulestore.django import ASSET_IGNORE_REGEX
 from xmodule.modulestore.exceptions import DuplicateCourseError
@@ -783,7 +783,7 @@ def import_library_from_xml(*args, **kwargs):
     return list(manager.run_imports())
 
 
-def _update_and_import_block(
+def _update_and_import_block(  # pylint: disable=too-many-statements
         block, store, user_id,
         source_course_id, dest_course_id,
         do_import_static=True, runtime=None):
@@ -880,7 +880,7 @@ def _convert_ref_fields_to_new_namespace(reference):
         # according to this existing library and library content block.
         if block.source_library_id and store.get_library(block.source_library_key):
             # If the library content block is already in the course, then don't
-            # refresh the children when we re-import it. This lets us address
+            # sync the children when we re-import it. This lets us address
             # TNL-7507 (Randomized Content Block Settings Lost in Course Import)
             # while still avoiding AA-310, where the IDs of the children for an
             # existing library_content block might be altered, losing student
@@ -900,10 +900,14 @@ def _convert_ref_fields_to_new_namespace(reference):
             try:
                 # Update library content block's children on draft branch
                 with store.branch_setting(branch_setting=ModuleStoreEnum.Branch.draft_preferred):
-                    LibraryToolsService(store, user_id).update_children(
-                        block,
-                        version=block.source_library_version,
-                    )
+                    try:
+                        block.sync_from_library()
+                    except ObjectDoesNotExist:
+                        # If the source library does not exist, that's OK, the library content will still kinda work.
+                        # Unfortunately, any setting defaults that are set in the library will be missing.
+                        # TODO save library default settings to course's OLX and then load them here if available:
+                        # https://github.com/openedx/edx-platform/issues/33742
+                        pass
             except ValueError as err:
                 # The specified library version does not exist.
                 log.error(err)
diff --git a/xmodule/studio_editable.py b/xmodule/studio_editable.py
index 4bb7a130b1be..332025619eb4 100644
--- a/xmodule/studio_editable.py
+++ b/xmodule/studio_editable.py
@@ -49,6 +49,36 @@ def get_preview_view_name(block):
         """
         return AUTHOR_VIEW if has_author_view(block) else STUDENT_VIEW
 
+    # Some parts of the code use getattr to dynamically check for the following three methods on subclasses.
+    # We'd like to refactor so that we can actually declare them here as overridable methods.
+    # For now, we leave them here as documentation.
+    # See https://github.com/openedx/edx-platform/issues/33715.
+    #
+    # def editor_saved(self, old_metadata, old_content) -> None:  # pylint: disable=unused-argument
+    #     """
+    #     Called right *before* the block is written to the DB. Can be used, e.g., to modify fields before saving.
+    #
+    #     By default, is a no-op. Can be overriden in subclasses.
+    #     """
+    #
+    # def post_editor_saved(self, old_metadata, old_content) -> None:  # pylint: disable=unused-argument
+    #     """
+    #     Called right *after* the block is written to the DB. Can be used, e.g., to spin up followup tasks.
+    #
+    #     By default, is a no-op. Can be overriden in subclasses.
+    #     """
+    #
+    # def studio_post_duplicate(self, dest_block) -> bool:  # pylint: disable=unused-argument
+    #     """
+    #     Called when a the block is duplicated. Can be used, e.g., for special handling of child duplication.
+    #
+    #     Returns 'True' if children have been handled and thus shouldn't be handled by the standard
+    #     duplication logic.
+    #
+    #     By default, is a no-op. Can be overriden in subclasses.
+    #     """
+    #     return False
+
 
 def has_author_view(block):
     """
diff --git a/xmodule/tests/test_library_content.py b/xmodule/tests/test_library_content.py
index 61c8e890760f..fd4b97fd546e 100644
--- a/xmodule/tests/test_library_content.py
+++ b/xmodule/tests/test_library_content.py
@@ -4,16 +4,18 @@
 Higher-level tests are in `cms/djangoapps/contentstore/tests/test_libraries.py`.
 """
 from unittest.mock import MagicMock, Mock, patch
-import ddt
 
+import ddt
 from bson.objectid import ObjectId
 from fs.memoryfs import MemoryFS
 from lxml import etree
+from opaque_keys.edx.locator import LibraryLocator, LibraryLocatorV2
+from rest_framework import status
 from search.search_engine_base import SearchEngine
 from web_fragments.fragment import Fragment
 from xblock.runtime import Runtime as VanillaRuntime
-from rest_framework import status
 
+from openedx.core.djangolib.testing.utils import skip_unless_cms
 from xmodule.library_content_block import ANY_CAPA_TYPE_VALUE, LibraryContentBlock
 from xmodule.library_tools import LibraryToolsService
 from xmodule.modulestore import ModuleStoreEnum
@@ -23,12 +25,14 @@
 from xmodule.validation import StudioValidationMessage
 from xmodule.x_module import AUTHOR_VIEW
 from xmodule.capa_block import ProblemBlock
+from common.djangoapps.student.tests.factories import UserFactory
 
 from .test_course_block import DummySystem as TestImportSystem
 
 dummy_render = lambda block, _: Fragment(block.data)  # pylint: disable=invalid-name
 
 
+@skip_unless_cms
 class LibraryContentTest(MixedSplitTestCase):
     """
     Base class for tests of LibraryContentBlock (library_content_block.py)
@@ -36,7 +40,7 @@ class LibraryContentTest(MixedSplitTestCase):
 
     def setUp(self):
         super().setUp()
-
+        self.user_id = UserFactory().id
         self.tools = LibraryToolsService(self.store, self.user_id)
         self.library = LibraryFactory.create(modulestore=self.store)
         self.lib_blocks = [
@@ -53,13 +57,25 @@ def setUp(self):
             max_count=1,
             source_library_id=str(self.library.location.library_key)
         )
+        self.lc_block.runtime._services.update({'library_tools': self.tools})  # pylint: disable=protected-access
+
+    def _sync_lc_block_from_library(self, upgrade_to_latest=False):
+        """
+        Save the lc_block, then sync its children with the library, and then re-load it.
+
+        We must re-load it because the syncing happens in a Celery task, so that original self.lc_block instance will
+        not have changes manifested on it, but the re-loaded instance will.
+        """
+        self.store.update_item(self.lc_block, self.user_id)
+        self.lc_block.sync_from_library(upgrade_to_latest=upgrade_to_latest)
+        self.lc_block = self.store.get_item(self.lc_block.location)
 
     def _bind_course_block(self, block):
         """
         Bind a block (part of self.course) so we can access student-specific data.
         """
         prepare_block_runtime(block.runtime, course_id=block.location.course_key)
-        block.runtime._services.update({'library_tools': self.tools})  # lint-amnesty, pylint: disable=protected-access
+        block.runtime._services.update({'library_tools': self.tools})  # pylint: disable=protected-access
 
         def get_block(descriptor):
             """Mocks module_system get_block function"""
@@ -71,16 +87,59 @@ def get_block(descriptor):
         block.runtime.get_block_for_descriptor = get_block
 
 
+@ddt.ddt
+class LibraryContentGeneralTest(LibraryContentTest):
+    """
+    Test the base functionality of the LibraryContentBlock.
+    """
+
+    @ddt.data(
+        ('library-v1:ProblemX+PR0B', LibraryLocator),
+        ('lib:ORG:test-1', LibraryLocatorV2)
+    )
+    @ddt.unpack
+    def test_source_library_key(self, library_key, expected_locator_type):
+        """
+        Test the source_library_key property of the xblock.
+
+        The method should correctly work either with V1 or V2 libraries.
+        """
+        library = self.make_block(
+            "library_content",
+            self.vertical,
+            max_count=1,
+            source_library_id=library_key
+        )
+        assert isinstance(library.source_library_key, expected_locator_type)
+
+    def test_initial_sync_from_library(self):
+        """
+        Test that a lc block starts without children, but is correctly populated upon first sync.
+        """
+        source_library_key = self.library.location.library_key
+
+        # Normally the children get added when the "source_libraries" setting
+        # is updated, but the way we do it through a factory doesn't do that.
+        assert self.lc_block.source_library_key == source_library_key
+        assert self.lc_block.source_library_version is None
+        assert len(self.lc_block.children) == 0
+
+        # Update the LibraryContent block's children:
+        self._sync_lc_block_from_library()
+
+        # Check that all blocks from the library are now children of the block:
+        assert self.lc_block.source_library_key == source_library_key  # Unchanged
+        assert self.lc_block.source_library_version == self.tools.get_latest_library_version(source_library_key)
+        assert len(self.lc_block.children) == len(self.lib_blocks)
+
+
 class TestLibraryContentExportImport(LibraryContentTest):
     """
     Export and import tests for LibraryContentBlock
     """
     def setUp(self):
         super().setUp()
-
-        # Children will only set after calling this.
-        self.lc_block.refresh_children()
-        self.lc_block = self.store.get_item(self.lc_block.location)
+        self._sync_lc_block_from_library()
 
         self.expected_olx = (
             '<library_content display_name="{block.display_name}" max_count="{block.max_count}"'
@@ -177,6 +236,10 @@ class LibraryContentBlockTestMixin:
 
     problem_type_lookup = {}
 
+    def setUp(self):
+        super().setUp()
+        self._sync_lc_block_from_library()
+
     def _get_capa_problem_type_xml(self, *args):
         """ Helper function to create empty CAPA problem definition """
         problem = "<problem>"
@@ -185,7 +248,7 @@ def _get_capa_problem_type_xml(self, *args):
         problem += "</problem>"
         return problem
 
-    def _create_capa_problems(self):
+    def _add_problems_to_library(self):
         """
         Helper function to create a set of capa problems to test against.
 
@@ -196,26 +259,10 @@ def _create_capa_problems(self):
             block = self.make_block("problem", self.library, data=self._get_capa_problem_type_xml(*problem_type))
             self.problem_type_lookup[block.location] = problem_type
 
-    def test_lib_content_block(self):
-        """
-        Test that blocks from a library are copied and added as children
-        """
-        # Check that the LibraryContent block has no children initially
-        # Normally the children get added when the "source_libraries" setting
-        # is updated, but the way we do it through a factory doesn't do that.
-        assert len(self.lc_block.children) == 0
-        # Update the LibraryContent block:
-        self.lc_block.refresh_children()
-        self.lc_block = self.store.get_item(self.lc_block.location)
-        # Check that all blocks from the library are now children of the block:
-        assert len(self.lc_block.children) == len(self.lib_blocks)
-
     def test_children_seen_by_a_user(self):
         """
         Test that each student sees only one block as a child of the LibraryContent block.
         """
-        self.lc_block.refresh_children()
-        self.lc_block = self.store.get_item(self.lc_block.location)
         self._bind_course_block(self.lc_block)
         # Make sure the runtime knows that the block's children vary per-user:
         assert self.lc_block.has_dynamic_children()
@@ -234,93 +281,113 @@ def test_validation_of_course_libraries(self):
         """
         # When source_library_id is blank, the validation summary should say this block needs to be configured:
         self.lc_block.source_library_id = ""
+        self.lc_block.source_library_version = None
         result = self.lc_block.validate()
         assert not result
-        # Validation fails due to at least one warning/message
         assert result.summary
         assert StudioValidationMessage.NOT_CONFIGURED == result.summary.type
 
         # When source_library_id references a non-existent library, we should get an error:
         self.lc_block.source_library_id = "library-v1:BAD+WOLF"
+        self.lc_block.source_library_version = None
         result = self.lc_block.validate()
         assert not result
-        # Validation fails due to at least one warning/message
         assert result.summary
         assert StudioValidationMessage.ERROR == result.summary.type
         assert 'invalid' in result.summary.text
 
-        # When source_library_id is set but the block needs to be updated, the summary should say so:
+        # When source_library_id is set but the block hasn't been synced, the summary should say so:
         self.lc_block.source_library_id = str(self.library.location.library_key)
+        self.lc_block.source_library_version = None
         result = self.lc_block.validate()
         assert not result
-        # Validation fails due to at least one warning/message
         assert result.summary
         assert StudioValidationMessage.WARNING == result.summary.type
         assert 'out of date' in result.summary.text
 
         # Now if we update the block, all validation should pass:
-        self.lc_block.refresh_children()
+        self._sync_lc_block_from_library()
         assert self.lc_block.validate()
 
+        # But updating the library will cause it to fail again as out-of-date:
+        self._add_problems_to_library()
+        result = self.lc_block.validate()
+        assert not result
+        assert result.summary
+        assert StudioValidationMessage.WARNING == result.summary.type
+        assert 'out of date' in result.summary.text
+
+        # And a regular sync will not fix that:
+        self._sync_lc_block_from_library()
+        result = self.lc_block.validate()
+        assert not result
+        assert result.summary
+        assert StudioValidationMessage.WARNING == result.summary.type
+        assert 'out of date' in result.summary.text
+
+        # But a upgrade_to_latest sync will:
+        self._sync_lc_block_from_library(upgrade_to_latest=True)
+        assert self.lc_block.validate()
+
+    def _assert_has_only_N_matching_problems(self, result, n):
+        assert result.summary
+        assert StudioValidationMessage.WARNING == result.summary.type
+        assert f'only {n} matching problem' in result.summary.text
+
     def test_validation_of_matching_blocks(self):
         """
         Test that the validation method of LibraryContent blocks can warn
         the user about problems with other settings (max_count and capa_type).
         """
+        # Ensure we're starting wtih clean validation
+        assert self.lc_block.validate()
+
         # Set max_count to higher value than exists in library
         self.lc_block.max_count = 50
-        # In the normal studio editing process, editor_saved() calls refresh_children at this point
-        self.lc_block.refresh_children()
         result = self.lc_block.validate()
         assert not result
-        # Validation fails due to at least one warning/message
-        assert result.summary
-        assert StudioValidationMessage.WARNING == result.summary.type
-        assert 'only 4 matching problems' in result.summary.text
+        self._assert_has_only_N_matching_problems(result, 4)
         assert len(self.lc_block.selected_children()) == 4
 
         # Add some capa problems so we can check problem type validation messages
+        self._add_problems_to_library()
+        self._sync_lc_block_from_library(upgrade_to_latest=True)
         self.lc_block.max_count = 1
-        self._create_capa_problems()
-        self.lc_block.refresh_children()
         assert self.lc_block.validate()
         assert len(self.lc_block.selected_children()) == 1
 
         # Existing problem type should pass validation
-        self.lc_block.max_count = 1
         self.lc_block.capa_type = 'multiplechoiceresponse'
-        self.lc_block.refresh_children()
+        self._sync_lc_block_from_library()
+        self.lc_block.max_count = 1
         assert self.lc_block.validate()
         assert len(self.lc_block.selected_children()) == 1
 
         # ... unless requested more blocks than exists in library
-        self.lc_block.max_count = 10
         self.lc_block.capa_type = 'multiplechoiceresponse'
-        self.lc_block.refresh_children()
+        self._sync_lc_block_from_library()
+        self.lc_block.max_count = 10
         result = self.lc_block.validate()
         assert not result
-        # Validation fails due to at least one warning/message
-        assert result.summary
-        assert StudioValidationMessage.WARNING == result.summary.type
-        assert 'only 1 matching problem' in result.summary.text
+        self._assert_has_only_N_matching_problems(result, 1)
         assert len(self.lc_block.selected_children()) == 1
 
         # Missing problem type should always fail validation
-        self.lc_block.max_count = 1
         self.lc_block.capa_type = 'customresponse'
-        self.lc_block.refresh_children()
+        self._sync_lc_block_from_library()
+        self.lc_block.max_count = 1
         result = self.lc_block.validate()
         assert not result
         # Validation fails due to at least one warning/message
         assert result.summary
         assert StudioValidationMessage.WARNING == result.summary.type
-        assert 'no matching problem types' in result.summary.text
+        assert 'There are no problems in the specified library of type customresponse' in result.summary.text
         assert len(self.lc_block.selected_children()) == 0
 
         # -1 selects all blocks from the library.
-        self.lc_block.max_count = -1
         self.lc_block.capa_type = ANY_CAPA_TYPE_VALUE
-        self.lc_block.refresh_children()
+        self._sync_lc_block_from_library()
+        self.lc_block.max_count = -1
         assert self.lc_block.validate()
         assert len(self.lc_block.selected_children()) == len(self.lc_block.children)
 
@@ -328,27 +395,28 @@ def test_capa_type_filtering(self):
         """
         Test that the capa type filter is actually filtering children
         """
-        self._create_capa_problems()
-        assert len(self.lc_block.children) == 0
-        # precondition check
+        self._add_problems_to_library()
+        self._sync_lc_block_from_library(upgrade_to_latest=True)
+        assert self.lc_block.children
+        assert len(self.lc_block.children) == len(self.library.children)
+
         self.lc_block.capa_type = "multiplechoiceresponse"
-        self.lc_block.refresh_children()
+        self._sync_lc_block_from_library()
         assert len(self.lc_block.children) == 1
 
         self.lc_block.capa_type = "optionresponse"
-        self.lc_block.refresh_children()
+        self._sync_lc_block_from_library()
         assert len(self.lc_block.children) == 3
 
         self.lc_block.capa_type = "coderesponse"
-        self.lc_block.refresh_children()
+        self._sync_lc_block_from_library()
         assert len(self.lc_block.children) == 2
 
         self.lc_block.capa_type = "customresponse"
-        self.lc_block.refresh_children()
-        assert len(self.lc_block.children) == 0
+        self._sync_lc_block_from_library()
 
         self.lc_block.capa_type = ANY_CAPA_TYPE_VALUE
-        self.lc_block.refresh_children()
+        self._sync_lc_block_from_library()
         assert len(self.lc_block.children) == (len(self.lib_blocks) + 4)
 
     def test_non_editable_settings(self):
@@ -367,24 +435,22 @@ def test_overlimit_blocks_chosen_randomly(self):
         blocks_seen = set()
         total_tries, max_tries = 0, 100
 
-        self.lc_block.refresh_children()
-        self.lc_block = self.store.get_item(self.lc_block.location)
         self._bind_course_block(self.lc_block)
 
         # Eventually, we should see every child block selected
         while len(blocks_seen) != len(self.lib_blocks):
-            self._change_count_and_refresh_children(len(self.lib_blocks))
+            self._change_count_and_reselect_children(len(self.lib_blocks))
             # Now set the number of selections to 1
-            selected = self._change_count_and_refresh_children(1)
+            selected = self._change_count_and_reselect_children(1)
             blocks_seen.update(selected)
             total_tries += 1
             if total_tries >= max_tries:
                 assert False, "Max tries exceeded before seeing all blocks."
                 break
 
-    def _change_count_and_refresh_children(self, count):
+    def _change_count_and_reselect_children(self, count):
         """
-        Helper method that changes the max_count of self.lc_block, refreshes
+        Helper method that changes the max_count of self.lc_block, reselects
         children, and asserts that the number of selected children equals the count provided.
         """
         self.lc_block.max_count = count
@@ -413,9 +479,8 @@ def test_reset_selected_children_capa_blocks(self, allow_resetting_children, max
         self.lc_block.allow_resetting_children = allow_resetting_children
         self.lc_block.max_count = max_count
         # Add some capa blocks
-        self._create_capa_problems()
-        self.lc_block.refresh_children()
-        self.lc_block = self.store.get_item(self.lc_block.location)
+        self._add_problems_to_library()
+        self._sync_lc_block_from_library(upgrade_to_latest=True)
         # Mock the student view to return an empty dict to be returned as response
         self.lc_block.student_view = MagicMock()
         self.lc_block.student_view.return_value.content = {}
@@ -434,19 +499,10 @@ def test_reset_selected_children_capa_blocks(self, allow_resetting_children, max
             assert response.status_code == status.HTTP_400_BAD_REQUEST
 
 
-@patch('xmodule.library_tools.SearchEngine.get_search_engine', Mock(return_value=None, autospec=True))
-class TestLibraryContentBlockNoSearchIndex(LibraryContentBlockTestMixin, LibraryContentTest):
-    """
-    Tests for library container when no search index is available.
-    Tests fallback low-level CAPA problem introspection
-    """
-    pass  # pylint:disable=unnecessary-pass
-
-
 search_index_mock = Mock(spec=SearchEngine)  # pylint: disable=invalid-name
 
 
-@patch('xmodule.library_tools.SearchEngine.get_search_engine', Mock(return_value=search_index_mock, autospec=True))
+@patch.object(SearchEngine, 'get_search_engine', Mock(return_value=None, autospec=True))
 class TestLibraryContentBlockWithSearchIndex(LibraryContentBlockTestMixin, LibraryContentTest):
     """
     Tests for library container with mocked search engine response.
@@ -481,10 +537,12 @@ class TestLibraryContentRender(LibraryContentTest):
     Rendering unit tests for LibraryContentBlock
     """
 
+    def setUp(self):
+        super().setUp()
+        self._sync_lc_block_from_library()
+
     def test_preview_view(self):
         """ Test preview view rendering """
-        self.lc_block.refresh_children()
-        self.lc_block = self.store.get_item(self.lc_block.location)
         assert len(self.lc_block.children) == len(self.lib_blocks)
         self._bind_course_block(self.lc_block)
         rendered = self.lc_block.render(AUTHOR_VIEW, {'root_xblock': self.lc_block})
@@ -492,8 +550,6 @@ def test_preview_view(self):
 
     def test_author_view(self):
         """ Test author view rendering """
-        self.lc_block.refresh_children()
-        self.lc_block = self.store.get_item(self.lc_block.location)
         assert len(self.lc_block.children) == len(self.lib_blocks)
         self._bind_course_block(self.lc_block)
         rendered = self.lc_block.render(AUTHOR_VIEW, {})
@@ -511,8 +567,7 @@ class TestLibraryContentAnalytics(LibraryContentTest):
     def setUp(self):
         super().setUp()
         self.publisher = Mock()
-        self.lc_block.refresh_children()
-        self.lc_block = self.store.get_item(self.lc_block.location)
+        self._sync_lc_block_from_library()
         self._bind_course_block(self.lc_block)
         self.lc_block.runtime.publish = self.publisher
 
@@ -582,10 +637,9 @@ def test_assigned_descendants(self):
             inner_vertical = self.make_block("vertical", main_vertical)
             html_block = self.make_block("html", inner_vertical)
             problem_block = self.make_block("problem", inner_vertical)
-            self.lc_block.refresh_children()
 
         # Reload lc_block and set it up for a student:
-        self.lc_block = self.store.get_item(self.lc_block.location)
+        self._sync_lc_block_from_library(upgrade_to_latest=True)
         self._bind_course_block(self.lc_block)
         self.lc_block.runtime.publish = self.publisher
 
@@ -645,6 +699,7 @@ def test_removed_invalid(self):
         Test the "removed" event emitted when we un-assign blocks previously assigned to a student.
         We go from two blocks assigned, to one because the others have been deleted from the library.
         """
+
         # Start by assigning two blocks to the student:
         self.lc_block.get_child_blocks()  # This line is needed in the test environment or the change has no effect
         self.lc_block.max_count = 2
@@ -654,13 +709,18 @@ def test_removed_invalid(self):
         # Now make sure that one of the assigned blocks will have to be un-assigned.
         # To cause an "invalid" event, we delete all blocks from the content library
         # except for one of the two already assigned to the student:
+
         keep_block_key = initial_blocks_assigned[0].location
         keep_block_lib_usage_key, keep_block_lib_version = self.store.get_block_original_usage(keep_block_key)
         assert keep_block_lib_usage_key is not None
         deleted_block_key = initial_blocks_assigned[1].location
         self.library.children = [keep_block_lib_usage_key]
         self.store.update_item(self.library, self.user_id)
-        self.lc_block.refresh_children()
+        self.store.update_item(self.lc_block, self.user_id)
+        old_selected = self.lc_block.selected
+        self._sync_lc_block_from_library(upgrade_to_latest=True)
+        self.lc_block.selected = old_selected
+        self.lc_block.runtime.publish = self.publisher
 
         # Check that the event says that one block was removed, leaving one block left:
         children = self.lc_block.get_child_blocks()
diff --git a/xmodule/tests/test_library_tools.py b/xmodule/tests/test_library_tools.py
index e2daa723cc7b..265d0f31f174 100644
--- a/xmodule/tests/test_library_tools.py
+++ b/xmodule/tests/test_library_tools.py
@@ -1,39 +1,64 @@
 """
 Tests for library tools service (only used by CMS)
+
+Currently, the only known user of the LibraryToolsService is the
+LibraryContentBlock, so these tests are all written with only that
+block type in mind.
 """
-from unittest.mock import patch
 
+from unittest import mock
+
+import ddt
+from django.conf import settings
+from django.test import override_settings
 from opaque_keys.edx.keys import UsageKey
+from opaque_keys.edx.locator import LibraryLocator, LibraryLocatorV2
+
+from common.djangoapps.student.roles import CourseInstructorRole
+from common.djangoapps.student.tests.factories import UserFactory
 from openedx.core.djangolib.testing.utils import skip_unless_cms
 from openedx.core.djangoapps.content_libraries import api as library_api
 from openedx.core.djangoapps.content_libraries.tests.base import ContentLibrariesRestApiTest
 from openedx.core.djangoapps.xblock.api import load_block
-from common.djangoapps.student.roles import CourseInstructorRole
 from xmodule.library_tools import LibraryToolsService
 from xmodule.modulestore.tests.factories import CourseFactory, LibraryFactory
 from xmodule.modulestore.tests.utils import MixedSplitTestCase
 
 
 @skip_unless_cms
-class LibraryToolsServiceTest(MixedSplitTestCase):
-    """
-    Tests for library service.
+@ddt.ddt
+class ContentLibraryToolsTest(MixedSplitTestCase, ContentLibrariesRestApiTest):
     """
+    Tests for LibraryToolsService.
 
+    Tests interaction with blockstore-based (V2) and mongo-based (V1) content libraries.
+    """
     def setUp(self):
         super().setUp()
+        UserFactory(is_staff=True, id=self.user_id)
         self.tools = LibraryToolsService(self.store, self.user_id)
 
     def test_list_available_libraries(self):
         """
         Test listing of libraries.
+
+        Collects Only V2 Libaries if the FEATURES[ENABLE_LIBRARY_AUTHORING_MICROFRONTEND] setting is True.
+        Otherwise, return all v1 and v2 libraries.
         """
+        # create V1 library
         _ = LibraryFactory.create(modulestore=self.store)
+        # create V2 library
+        self._create_library(slug="testlib1_preview", title="Test Library 1", description="Testing XBlocks")
         all_libraries = self.tools.list_available_libraries()
         assert all_libraries
-        assert len(all_libraries) == 1
+        assert len(all_libraries) == 2
+
+        with override_settings(FEATURES={**settings.FEATURES, "ENABLE_LIBRARY_AUTHORING_MICROFRONTEND": True}):
+            all_libraries = self.tools.list_available_libraries()
+            assert all_libraries
+            assert len(all_libraries) == 1
 
-    @patch('xmodule.modulestore.split_mongo.split.SplitMongoModuleStore.get_library_summaries')
+    @mock.patch('xmodule.modulestore.split_mongo.split.SplitMongoModuleStore.get_library_summaries')
     def test_list_available_libraries_fetch(self, mock_get_library_summaries):
         """
         Test that library list is compiled using light weight library summary objects.
@@ -41,17 +66,75 @@ def test_list_available_libraries_fetch(self, mock_get_library_summaries):
         _ = self.tools.list_available_libraries()
         assert mock_get_library_summaries.called
 
+    def test_get_latest_v1_library_version(self):
+        """
+        Test get_v1_library_version for V1 libraries.
 
-@skip_unless_cms
-class ContentLibraryToolsTest(MixedSplitTestCase, ContentLibrariesRestApiTest):
-    """
-    Tests for LibraryToolsService which interact with blockstore-based content libraries
-    """
-    def setUp(self):
-        super().setUp()
-        self.tools = LibraryToolsService(self.store, self.user.id)
+        Covers getting results for either string library key or LibraryLocator.
+        """
+        lib_key = LibraryFactory.create(modulestore=self.store).location.library_key
+        # Re-load the library from the modulestore, explicitly including version information:
+        lib = self.store.get_library(lib_key, remove_version=False, remove_branch=False)
+        # check the result using the LibraryLocator
+        assert isinstance(lib_key, LibraryLocator)
+        result = self.tools.get_latest_library_version(lib_key)
+        assert result
+        assert result == str(lib.location.library_key.version_guid)
+        # the same check for string representation of the LibraryLocator
+        str_key = str(lib_key)
+        result = self.tools.get_latest_library_version(str_key)
+        assert result
+        assert result == str(lib.location.library_key.version_guid)
+
+    @ddt.data(
+        'library-v1:Fake+Key',  # V1 library key
+        'lib:Fake:V-2',         # V2 library key
+        LibraryLocator.from_string('library-v1:Fake+Key'),
+        LibraryLocatorV2.from_string('lib:Fake:V-2'),
+    )
+    def test_get_latest_library_version_no_library(self, lib_key):
+        """
+        Test get_latest_library_version result when the library does not exist.
 
-    def test_import_from_blockstore(self):
+        Provided lib_key's are valid V1 or V2 keys.
+        """
+        assert self.tools.get_latest_library_version(lib_key) is None
+
+    def test_update_children_for_v2_lib(self):
+        """
+        Test update_children with V2 library as a source.
+        """
+        library = self._create_library(
+            slug="cool-v2-lib", title="The best Library", description="Spectacular description"
+        )
+        self._add_block_to_library(library["id"], "unit", "unit1_id")
+
+        course = CourseFactory.create(modulestore=self.store, user_id=self.user.id)
+        CourseInstructorRole(course.id).add_users(self.user)
+
+        content_block = self.make_block(
+            "library_content",
+            course,
+            max_count=1,
+            source_library_id=library['id']
+        )
+        assert len(content_block.children) == 0
+
+        # Populate children from library
+        self.tools.trigger_library_sync(content_block, library_version=None)
+
+        # The updates happen in a Celery task, so this particular content_block instance is no updated.
+        # We must re-instantiate it from modulstore in order to see the updated children list.
+        content_block = self.store.get_item(content_block.location)
+
+        assert len(content_block.children) == 1
+
+    def test_update_children_for_v2_lib_recursive(self):
+        """
+        Test update_children for a V2 library containing a unit.
+
+        Ensures that _import_from_blockstore works on nested blocks.
+        """
         # Create a blockstore content library
         library = self._create_library(slug="testlib1_import", title="A Test Library", description="Testing XBlocks")
         # Create a unit block with an HTML block in it.
@@ -66,10 +149,17 @@ def test_import_from_blockstore(self):
         course = CourseFactory.create(modulestore=self.store, user_id=self.user.id)
         CourseInstructorRole(course.id).add_users(self.user)
         # Add Source from library block to the course
-        lc_block = self.make_block("library_content", course, user_id=self.user.id)
+        lc_block = self.make_block(
+            "library_content",
+            course,
+            user_id=self.user_id,
+            max_count=1,
+            source_library_id=str(library["id"]),
+        )
 
         # Import the unit block from the library to the course
-        self.tools.import_from_blockstore(lc_block, [unit_block_id])
+        self.tools.trigger_library_sync(lc_block, library_version=None)
+        lc_block = self.store.get_item(lc_block.location)
 
         # Verify imported block with its children
         assert len(lc_block.children) == 1
@@ -89,7 +179,8 @@ def test_import_from_blockstore(self):
 
         # Check that reimporting updates the target block
         self._set_library_block_olx(html_block_id, '<html><a href="/static/test.txt">Foo bar</a></html>')
-        self.tools.import_from_blockstore(lc_block, [unit_block_id])
+        self.tools.trigger_library_sync(lc_block, library_version=None)
+        lc_block = self.store.get_item(lc_block.location)
 
         assert len(lc_block.children) == 1
         imported_unit_block = self.store.get_item(lc_block.children[0])
@@ -97,3 +188,24 @@ def test_import_from_blockstore(self):
         imported_html_block = self.store.get_item(imported_unit_block.children[0])
         assert 'Hello world' not in imported_html_block.data
         assert 'Foo bar' in imported_html_block.data
+
+    def test_update_children_for_v1_lib(self):
+        """
+        Test update_children with V1 library as a source.
+
+        As for now, covers usage of update_children for the library content module only.
+        """
+        library = LibraryFactory.create(modulestore=self.store)
+        self.make_block("html", library, data="Hello world from the block")
+        course = CourseFactory.create(modulestore=self.store)
+        content_block = self.make_block(
+            "library_content",
+            course,
+            max_count=1,
+            source_library_id=str(library.location.library_key)
+        )
+
+        assert len(content_block.children) == 0
+        self.tools.trigger_library_sync(content_block, library_version=None)
+        content_block = self.store.get_item(content_block.location)
+        assert len(content_block.children) == 1