diff --git a/client/src/components/Dataset/DatasetHistory.vue b/client/src/components/Dataset/DatasetHistory.vue
deleted file mode 100644
index 20605fac0298..000000000000
--- a/client/src/components/Dataset/DatasetHistory.vue
+++ /dev/null
@@ -1,24 +0,0 @@
-<script setup lang="ts">
-import { computed } from "vue";
-
-import { HDASummary } from "@/api/datasets";
-import { useHistoryStore } from "@/stores/historyStore";
-
-interface Props {
-    item: HDASummary;
-}
-
-const props = defineProps<Props>();
-
-const historyStore = useHistoryStore();
-
-const historyName = computed(() => {
-    return historyStore.getHistoryNameById(props.item.history_id);
-});
-</script>
-
-<template>
-    <div>
-        {{ historyName }}
-    </div>
-</template>
diff --git a/client/src/components/Dataset/DatasetList.vue b/client/src/components/Dataset/DatasetList.vue
index bc3560ba5793..014004214ff0 100644
--- a/client/src/components/Dataset/DatasetList.vue
+++ b/client/src/components/Dataset/DatasetList.vue
@@ -8,8 +8,8 @@ import { updateTags } from "@/api/tags";
 import { useHistoryStore } from "@/stores/historyStore";
 
 import DelayedInput from "@/components/Common/DelayedInput.vue";
-import DatasetHistory from "@/components/Dataset/DatasetHistory.vue";
 import DatasetName from "@/components/Dataset/DatasetName.vue";
+import SwitchToHistoryLink from "@/components/History/SwitchToHistoryLink.vue";
 import LoadingSpan from "@/components/LoadingSpan.vue";
 import StatelessTags from "@/components/TagsMultiselect/StatelessTags.vue";
 import UtcDate from "@/components/UtcDate.vue";
@@ -185,7 +185,9 @@ onMounted(() => {
             </template>
 
             <template v-slot:cell(history_id)="row">
-                <DatasetHistory :item="row.item" />
+                <SwitchToHistoryLink
+                    :history-id="row.item.history_id"
+                    :filters="{ deleted: row.item.deleted, visible: row.item.visible, hid: row.item.hid }" />
             </template>
 
             <template v-slot:cell(tags)="row">
diff --git a/client/src/components/Dataset/DatasetName.test.ts b/client/src/components/Dataset/DatasetName.test.ts
index 2de4470470f3..415bd08faafa 100644
--- a/client/src/components/Dataset/DatasetName.test.ts
+++ b/client/src/components/Dataset/DatasetName.test.ts
@@ -19,15 +19,7 @@ describe("Dataset Name", () => {
         const state = wrapper.findAll(".name");
         expect(state.length).toBe(1);
         expect(state.at(0).text()).toBe("name");
-
-        const $linkShow = wrapper.find(".dropdown-item:first-child");
-
-        $linkShow.trigger("click");
-
-        expect(Array.isArray(wrapper.emitted().showDataset)).toBe(true);
-
-        const $linkCopy = wrapper.find(".dropdown-item:last-child");
-
+        const $linkCopy = wrapper.find(".dropdown-item:first-child");
         $linkCopy.trigger("click");
 
         expect(Array.isArray(wrapper.emitted().copyDataset)).toBe(true);
diff --git a/client/src/components/Dataset/DatasetName.vue b/client/src/components/Dataset/DatasetName.vue
index 22fe48c8b883..99a1e335a65d 100644
--- a/client/src/components/Dataset/DatasetName.vue
+++ b/client/src/components/Dataset/DatasetName.vue
@@ -33,10 +33,6 @@ const isPaused = computed(() => {
 function copyDataset() {
     emit("copyDataset", props.item);
 }
-
-function showDataset() {
-    emit("showDataset", props.item);
-}
 </script>
 
 <template>
@@ -65,12 +61,6 @@ function showDataset() {
         </BLink>
 
         <div class="dropdown-menu" aria-labelledby="dataset-dropdown">
-            <a class="dropdown-item" href="#" @click.prevent="showDataset">
-                <FontAwesomeIcon :icon="faEye" class="mr-1" />
-
-                <span>Show in History containing dataset</span>
-            </a>
-
             <a class="dropdown-item" href="#" @click.prevent="copyDataset">
                 <FontAwesomeIcon :icon="faCopy" class="mr-1" />
 
diff --git a/client/src/components/History/Content/ContentItem.vue b/client/src/components/History/Content/ContentItem.vue
index 11ecbf1df642..e0d6acdb8178 100644
--- a/client/src/components/History/Content/ContentItem.vue
+++ b/client/src/components/History/Content/ContentItem.vue
@@ -4,7 +4,7 @@ import { faCheckSquare, faSquare } from "@fortawesome/free-regular-svg-icons";
 import { faArrowCircleDown, faArrowCircleUp, faCheckCircle, faSpinner } from "@fortawesome/free-solid-svg-icons";
 import { FontAwesomeIcon } from "@fortawesome/vue-fontawesome";
 import { BBadge, BButton, BCollapse } from "bootstrap-vue";
-import { computed } from "vue";
+import { computed, ref } from "vue";
 import { useRoute, useRouter } from "vue-router/composables";
 
 import type { ItemUrls } from "@/components/History/Content/Dataset/index";
@@ -35,6 +35,7 @@ interface Props {
     addHighlightBtn?: boolean;
     highlight?: string;
     isDataset?: boolean;
+    isRangeSelectAnchor?: boolean;
     isHistoryItem?: boolean;
     selected?: boolean;
     selectable?: boolean;
@@ -48,6 +49,7 @@ const props = withDefaults(defineProps<Props>(), {
     addHighlightBtn: false,
     highlight: undefined,
     isDataset: true,
+    isRangeSelectAnchor: false,
     isHistoryItem: false,
     selected: false,
     selectable: false,
@@ -58,12 +60,12 @@ const props = withDefaults(defineProps<Props>(), {
 const emit = defineEmits<{
     (e: "update:selected", selected: boolean): void;
     (e: "update:expand-dataset", expand: boolean): void;
-    (e: "shift-select", direction: string): void;
+    (e: "shift-arrow-select", direction: string): void;
     (e: "init-key-selection"): void;
     (e: "arrow-navigate", direction: string): void;
     (e: "hide-selection"): void;
     (e: "select-all"): void;
-    (e: "selected-to", reset: boolean): void;
+    (e: "selected-to"): void;
     (e: "delete", item: any, recursive: boolean): void;
     (e: "undelete"): void;
     (e: "unhide"): void;
@@ -77,6 +79,8 @@ const emit = defineEmits<{
 const entryPointStore = useEntryPointStore();
 const eventStore = useEventStore();
 
+const contentItem = ref<HTMLElement | null>(null);
+
 const jobState = computed(() => {
     return new JobStateSummary(props.item);
 });
@@ -171,6 +175,10 @@ const isBeingUsed = computed(() => {
     return Object.values(itemUrls.value).includes(route.path) ? "being-used" : "";
 });
 
+const rangeSelectClass = computed(() => {
+    return props.isRangeSelectAnchor ? "range-select-anchor" : "";
+});
+
 /** Based on the user's keyboard platform, checks if it is the
  * typical key for selection (ctrl for windows/linux, cmd for mac)
  */
@@ -197,7 +205,7 @@ function onKeyDown(event: KeyboardEvent) {
         } else {
             event.preventDefault();
             if ((event.key === "ArrowUp" || event.key === "ArrowDown") && event.shiftKey) {
-                emit("shift-select", event.key);
+                emit("shift-arrow-select", event.key);
             } else if (event.key === "ArrowUp" || event.key === "ArrowDown") {
                 emit("init-key-selection");
             } else if (event.key === "Delete" && !props.selected && !props.item.deleted) {
@@ -215,15 +223,12 @@ function onKeyDown(event: KeyboardEvent) {
 function onClick(e?: Event) {
     const event = e as KeyboardEvent;
     if (event && props.writable) {
-        if (event.shiftKey && isSelectKey(event)) {
-            emit("selected-to", false);
-            return;
-        } else if (isSelectKey(event)) {
+        if (isSelectKey(event)) {
             emit("init-key-selection");
             emit("update:selected", !props.selected);
             return;
         } else if (event.shiftKey) {
-            emit("selected-to", true);
+            emit("selected-to");
             return;
         } else {
             emit("init-key-selection");
@@ -298,6 +303,17 @@ function onTagClick(tag: string) {
     }
 }
 
+function onButtonSelect(e: Event) {
+    const event = e as KeyboardEvent;
+    if (event.shiftKey) {
+        onClick(e);
+    } else {
+        emit("init-key-selection");
+    }
+    contentItem.value?.focus();
+    emit("update:selected", !props.selected);
+}
+
 function toggleHighlights() {
     emit("toggleHighlights", props.item);
 }
@@ -312,7 +328,8 @@ function unexpandedClick(event: Event) {
 <template>
     <div
         :id="contentId"
-        :class="['content-item m-1 p-0 rounded btn-transparent-background', contentCls, isBeingUsed]"
+        ref="contentItem"
+        :class="['content-item m-1 p-0 rounded btn-transparent-background', contentCls, isBeingUsed, rangeSelectClass]"
         :data-hid="id"
         :data-state="dataState"
         tabindex="0"
@@ -325,7 +342,7 @@ function unexpandedClick(event: Event) {
         <div class="p-1 cursor-pointer" @click.stop="onClick">
             <div class="d-flex justify-content-between">
                 <span class="p-1" data-description="content item header info">
-                    <BButton v-if="selectable" class="selector p-0" @click.stop="emit('update:selected', !selected)">
+                    <BButton v-if="selectable" class="selector p-0" @click.stop="onButtonSelect">
                         <FontAwesomeIcon v-if="selected" fixed-width size="lg" :icon="faCheckSquare" />
                         <FontAwesomeIcon v-else fixed-width size="lg" :icon="faSquare" />
                     </BButton>
@@ -439,6 +456,10 @@ function unexpandedClick(event: Event) {
         box-shadow: 0 0 0 0.2rem transparentize($brand-primary, 0.75);
     }
 
+    &.range-select-anchor {
+        box-shadow: 0 0 0 0.2rem transparentize($brand-primary, 0.75);
+    }
+
     &.being-used {
         border-left: 0.25rem solid $brand-primary;
         margin-left: 0rem !important;
diff --git a/client/src/components/History/Content/SelectedItems.js b/client/src/components/History/Content/SelectedItems.js
index 7a0d3a24196f..a93fa5904784 100644
--- a/client/src/components/History/Content/SelectedItems.js
+++ b/client/src/components/History/Content/SelectedItems.js
@@ -11,6 +11,7 @@ export default {
         getItemKey: { type: Function, required: true },
         filterText: { type: String, required: true },
         totalItemsInQuery: { type: Number, required: false },
+        allItems: { type: Array, required: true },
     },
     data() {
         return {
@@ -19,6 +20,8 @@ export default {
             allSelected: false,
             initSelectedItem: null,
             initDirection: null,
+            firstInRange: null,
+            lastInRange: null,
         };
     },
     computed: {
@@ -34,18 +37,27 @@ export default {
         initSelectedKey() {
             return this.initSelectedItem ? this.getItemKey(this.initSelectedItem) : null;
         },
+        lastInRangeIndex() {
+            return this.lastInRange ? this.allItems.indexOf(this.lastInRange) : null;
+        },
+        firstInRangeIndex() {
+            return this.firstInRange ? this.allItems.indexOf(this.firstInRange) : null;
+        },
+        rangeSelectActive() {
+            return this.lastInRange && this.initDirection;
+        },
     },
     methods: {
         setShowSelection(val) {
             this.showSelection = val;
         },
-        selectAllInCurrentQuery(loadedItems = [], force = true) {
+        selectAllInCurrentQuery(force = true) {
             // if we are not forcing selectAll, and all items are already selected; deselect them
             if (!force && this.allSelected) {
                 this.setShowSelection(false);
                 return;
             }
-            this.selectItems(loadedItems);
+            this.selectItems(this.allItems);
             this.allSelected = true;
         },
         isSelected(item) {
@@ -55,19 +67,49 @@ export default {
             const key = this.getItemKey(item);
             return this.items.has(key);
         },
-        setSelected(item, selected) {
+        /** Adds/Removes an item from the selected items
+         *
+         * @param {Object} item - the item to be selected/deselected
+         * @param {Boolean} selected - whether to select or deselect the item
+         * @param {Boolean} checkInRange - whether to check if the item lies outside the range
+         */
+        setSelected(item, selected, checkInRange = true) {
             const key = this.getItemKey(item);
             const newSelected = new Map(this.items);
             selected ? newSelected.set(key, item) : newSelected.delete(key);
             this.items = newSelected;
             this.breakQuerySelection();
+
+            // item selected from panel, range select is active, check if item lies outside the range
+            if (checkInRange && this.rangeSelectActive) {
+                const currentItemIndex = this.allItems.indexOf(item);
+
+                /** If either of the following are `true`, change the range anchor */
+                // if range select was downwards and the current item is below the lastInRange or above the firstInRange
+                if (
+                    this.initDirection === "ArrowDown" &&
+                    (currentItemIndex > this.lastInRangeIndex || currentItemIndex < this.firstInRangeIndex)
+                ) {
+                    this.firstInRange = item;
+                    this.lastInRange = item;
+                }
+                // if range select was upwards and the current item is above the lastInRange or below the firstInRange
+                else if (
+                    this.initDirection === "ArrowUp" &&
+                    (currentItemIndex < this.lastInRangeIndex || currentItemIndex > this.firstInRangeIndex)
+                ) {
+                    this.firstInRange = item;
+                    this.lastInRange = item;
+                }
+            }
         },
-        shiftSelect(item, nextItem, eventKey) {
+        /** Selecting items using `Shift+ArrowUp/ArrowDown` keys */
+        shiftArrowKeySelect(item, nextItem, eventKey) {
             const currentItemKey = this.getItemKey(item);
             if (!this.initSelectedKey) {
                 this.initSelectedItem = item;
                 this.initDirection = eventKey;
-                this.setSelected(item, true);
+                this.setSelected(item, true, false);
             }
             // got back to the initial selected item
             else if (this.initSelectedKey === currentItemKey) {
@@ -75,50 +117,101 @@ export default {
             }
             // same direction
             else if (this.initDirection === eventKey) {
-                this.setSelected(item, true);
+                this.setSelected(item, true, false);
             }
             // different direction
             else {
-                this.setSelected(item, false);
+                this.setSelected(item, false, false);
             }
             if (nextItem) {
-                this.setSelected(nextItem, true);
+                this.setSelected(nextItem, true, false);
             }
         },
-        selectTo(item, prevItem, allItems, reset = true) {
+        /** Range selecting items using `Shift+Click` */
+        rangeSelect(item, prevItem) {
             if (prevItem && item) {
-                // we are staring a new shift+click selectTo from `prevItem`
-                if (!this.initSelectedKey) {
-                    this.initSelectedItem = prevItem;
-                }
+                // either a range select is not active or we have modified a range select (changing the anchor)
+                const noRangeSelectOrModified = !this.initSelectedKey;
+                if (noRangeSelectOrModified) {
+                    // there is a range select active
+                    if (this.rangeSelectActive) {
+                        const currentItemIndex = this.allItems.indexOf(item);
 
-                // `reset = false` in the case user is holding shift+ctrl key
-                if (reset) {
-                    // clear this.items of any other selections
-                    this.items = new Map();
+                        // the current item is outside the range in the same direction;
+                        // the new range will follow the last item in prev range
+                        if (
+                            (this.initDirection === "ArrowDown" && currentItemIndex > this.lastInRangeIndex) ||
+                            (this.initDirection === "ArrowUp" && currentItemIndex < this.lastInRangeIndex)
+                        ) {
+                            this.initSelectedItem = this.lastInRange;
+                        }
+                        // the current item is outside the range in the opposite direction;
+                        // the new range will follow the first item in prev range
+                        else if (
+                            (this.initDirection === "ArrowDown" && currentItemIndex < this.firstInRangeIndex) ||
+                            (this.initDirection === "ArrowUp" && currentItemIndex > this.firstInRangeIndex)
+                        ) {
+                            this.initSelectedItem = this.firstInRange;
+                        } else {
+                            this.initSelectedItem = prevItem;
+                            this.firstInRange = prevItem;
+                        }
+                    }
+                    // there is no range select active
+                    else {
+                        // we are staring a new shift+click rangeSelect from `prevItem`
+                        this.initSelectedItem = prevItem;
+                        this.firstInRange = prevItem;
+                    }
                 }
-                this.setSelected(this.initSelectedItem, true);
 
-                const initItemIndex = allItems.indexOf(this.initSelectedItem);
-                const currentItemIndex = allItems.indexOf(item);
+                const initItemIndex = this.allItems.indexOf(this.initSelectedItem);
+                const currentItemIndex = this.allItems.indexOf(item);
 
+                const lastDirection = this.initDirection;
                 let selections = [];
                 // from allItems, get the items between the init item and the current item
                 if (initItemIndex < currentItemIndex) {
                     this.initDirection = "ArrowDown";
-                    selections = allItems.slice(initItemIndex + 1, currentItemIndex + 1);
+                    selections = this.allItems.slice(initItemIndex + 1, currentItemIndex + 1);
                 } else if (initItemIndex > currentItemIndex) {
                     this.initDirection = "ArrowUp";
-                    selections = allItems.slice(currentItemIndex, initItemIndex);
+                    selections = this.allItems.slice(currentItemIndex, initItemIndex);
+                }
+
+                let deselections;
+                // there is an existing range select; deselect items in certain conditions
+                if (this.rangeSelectActive) {
+                    // if there is an active, uninterrupted range-select and the direction changed;
+                    // deselect the items between the lastInRange and initSelectedItem
+                    if (!noRangeSelectOrModified && lastDirection && lastDirection !== this.initDirection) {
+                        if (this.lastInRangeIndex >= initItemIndex) {
+                            deselections = this.allItems.slice(initItemIndex + 1, this.lastInRangeIndex + 1);
+                        } else {
+                            deselections = this.allItems.slice(this.lastInRangeIndex, initItemIndex);
+                        }
+                    }
+
+                    // if the range has become smaller, deselect items between the lastInRange and the current item
+                    else if (this.lastInRangeIndex < currentItemIndex && this.initDirection === "ArrowUp") {
+                        deselections = this.allItems.slice(this.lastInRangeIndex, currentItemIndex);
+                    } else if (this.lastInRangeIndex > currentItemIndex && this.initDirection === "ArrowDown") {
+                        deselections = this.allItems.slice(currentItemIndex + 1, this.lastInRangeIndex + 1);
+                    }
                 }
+
                 this.selectItems(selections);
+                if (deselections) {
+                    deselections.forEach((deselected) => this.setSelected(deselected, false, false));
+                }
             } else {
                 this.setSelected(item, true);
             }
+            this.lastInRange = item;
         },
+        /** Resets the initial item in a range select (or shiftArrowKeySelect) */
         initKeySelection() {
             this.initSelectedItem = null;
-            this.initDirection = null;
         },
         selectItems(items = []) {
             const newItems = [...this.items.values(), ...items];
@@ -139,6 +232,9 @@ export default {
             this.items = new Map();
             this.allSelected = false;
             this.initKeySelection();
+            this.lastInRange = null;
+            this.firstInRange = null;
+            this.initDirection = null;
         },
         cancelSelection() {
             this.showSelection = false;
@@ -176,12 +272,13 @@ export default {
             setShowSelection: this.setShowSelection,
             selectAllInCurrentQuery: this.selectAllInCurrentQuery,
             selectItems: this.selectItems,
-            selectTo: this.selectTo,
+            rangeSelect: this.rangeSelect,
             isSelected: this.isSelected,
             setSelected: this.setSelected,
             resetSelection: this.reset,
-            shiftSelect: this.shiftSelect,
+            shiftArrowKeySelect: this.shiftArrowKeySelect,
             initKeySelection: this.initKeySelection,
+            initSelectedItem: this.initSelectedItem,
         });
     },
 };
diff --git a/client/src/components/History/Content/SelectedItems.test.js b/client/src/components/History/Content/SelectedItems.test.js
index d493b1a9cfc7..dbcf8fb55843 100644
--- a/client/src/components/History/Content/SelectedItems.test.js
+++ b/client/src/components/History/Content/SelectedItems.test.js
@@ -6,17 +6,20 @@ import SelectedItems from "./SelectedItems";
 
 const localVue = getLocalVue();
 
-const DEFAULT_PROPS = {
-    scopeKey: "scope",
-    getItemKey: (item) => `item-key-${item.id}`,
-    filterText: "",
-    totalItemsInQuery: 100,
-};
-
 describe("History SelectedItems", () => {
     let wrapper;
     let slotProps;
 
+    const numberOfLoadedItems = 10;
+    const allItems = generateTestItems(numberOfLoadedItems);
+    const DEFAULT_PROPS = {
+        scopeKey: "scope",
+        getItemKey: (item) => `item-key-${item.id}`,
+        filterText: "",
+        totalItemsInQuery: 100,
+        allItems,
+    };
+
     beforeEach(async () => {
         wrapper = shallowMount(SelectedItems, {
             localVue,
@@ -79,10 +82,8 @@ describe("History SelectedItems", () => {
     describe("Query Selection Mode", () => {
         it("is considered a query selection when we select `all items` and the query contains more items than we have currently loaded", async () => {
             const expectedTotalItemsInQuery = 100;
-            const numberOfLoadedItems = 10;
-            const loadedItems = generateTestItems(numberOfLoadedItems);
 
-            await selectAllItemsInCurrentQuery(loadedItems);
+            await selectAllItemsInCurrentQuery();
 
             expect(slotProps.isQuerySelection).toBe(true);
             expect(slotProps.selectionSize).toBe(expectedTotalItemsInQuery);
@@ -90,11 +91,9 @@ describe("History SelectedItems", () => {
 
         it("shouldn't be a query selection when we already have all items loaded", async () => {
             const expectedTotalItemsInQuery = 10;
-            const numberOfLoadedItems = 10;
-            const loadedItems = generateTestItems(numberOfLoadedItems);
             await wrapper.setProps({ totalItemsInQuery: expectedTotalItemsInQuery });
 
-            await selectAllItemsInCurrentQuery(loadedItems);
+            await selectAllItemsInCurrentQuery();
 
             expect(slotProps.isQuerySelection).toBe(false);
             expect(slotProps.selectionSize).toBe(expectedTotalItemsInQuery);
@@ -102,14 +101,12 @@ describe("History SelectedItems", () => {
 
         it("should `break` query selection mode when we unselect an item", async () => {
             const expectedTotalItemsInQuery = 100;
-            const numberOfLoadedItems = 10;
-            const loadedItems = generateTestItems(numberOfLoadedItems);
-            await selectAllItemsInCurrentQuery(loadedItems);
+            await selectAllItemsInCurrentQuery();
             expect(slotProps.isQuerySelection).toBe(true);
             expect(slotProps.selectionSize).toBe(expectedTotalItemsInQuery);
             expect(wrapper.emitted()["query-selection-break"]).toBeUndefined();
 
-            await unselectItem(loadedItems[0]);
+            await unselectItem(allItems[0]);
 
             expect(slotProps.isQuerySelection).toBe(false);
             expect(slotProps.selectionSize).toBe(numberOfLoadedItems - 1);
@@ -117,9 +114,7 @@ describe("History SelectedItems", () => {
         });
 
         it("should `break` query selection mode when the total number of items changes", async () => {
-            const numberOfLoadedItems = 10;
-            const loadedItems = generateTestItems(numberOfLoadedItems);
-            await selectAllItemsInCurrentQuery(loadedItems);
+            await selectAllItemsInCurrentQuery();
             expect(slotProps.isQuerySelection).toBe(true);
             expect(wrapper.emitted()["query-selection-break"]).toBeUndefined();
 
@@ -146,8 +141,8 @@ describe("History SelectedItems", () => {
 
         it("should match the number of items in query when selecting all items", async () => {
             const expectedTotalItemsInQuery = 100;
-            const loadedItems = []; // Even if there are no explicit items selected
-            await selectAllItemsInCurrentQuery(loadedItems);
+            await wrapper.setProps({ allItems: generateTestItems(0) }); // Even if there are no explicit items selected
+            await selectAllItemsInCurrentQuery();
             expect(slotProps.isQuerySelection).toBe(true);
             expect(slotProps.selectionSize).toBe(expectedTotalItemsInQuery);
         });
diff --git a/client/src/components/History/CurrentHistory/HistoryPanel.vue b/client/src/components/History/CurrentHistory/HistoryPanel.vue
index 227b6f25ee7c..5e287c961ec2 100644
--- a/client/src/components/History/CurrentHistory/HistoryPanel.vue
+++ b/client/src/components/History/CurrentHistory/HistoryPanel.vue
@@ -488,15 +488,17 @@ function setItemDragstart(
                 setShowSelection,
                 selectAllInCurrentQuery,
                 isSelected,
-                selectTo,
+                rangeSelect,
                 setSelected,
-                shiftSelect,
+                shiftArrowKeySelect,
                 initKeySelection,
                 resetSelection,
+                initSelectedItem,
             }"
             :scope-key="queryKey"
             :get-item-key="getItemKey"
             :filter-text="filterText"
+            :all-items="historyItems"
             :total-items-in-query="totalMatchesCount"
             @query-selection-break="querySelectionBreak = true">
             <!-- eslint-disable-next-line vuejs-accessibility/no-static-element-interactions -->
@@ -563,7 +565,7 @@ function setItemDragstart(
                             <HistorySelectionStatus
                                 v-if="showSelection"
                                 :selection-size="selectionSize"
-                                @select-all="selectAllInCurrentQuery(historyItems)"
+                                @select-all="selectAllInCurrentQuery()"
                                 @reset-selection="resetSelection" />
                         </template>
                     </HistoryOperations>
@@ -615,6 +617,9 @@ function setItemDragstart(
                                     :writable="canEditHistory"
                                     :expand-dataset="isExpanded(item)"
                                     :is-dataset="isDataset(item)"
+                                    :is-range-select-anchor="
+                                        initSelectedItem && itemUniqueKey(item) === itemUniqueKey(initSelectedItem)
+                                    "
                                     :highlight="getHighlight(item)"
                                     :selected="isSelected(item)"
                                     :selectable="showSelection"
@@ -631,11 +636,11 @@ function setItemDragstart(
                                     "
                                     @hide-selection="setShowSelection(false)"
                                     @init-key-selection="initKeySelection"
-                                    @shift-select="
-                                        (eventKey) => shiftSelect(item, arrowNavigate(item, eventKey), eventKey)
+                                    @shift-arrow-select="
+                                        (eventKey) => shiftArrowKeySelect(item, arrowNavigate(item, eventKey), eventKey)
                                     "
-                                    @select-all="selectAllInCurrentQuery(historyItems, false)"
-                                    @selected-to="(reset) => selectTo(item, lastItemFocused, historyItems, reset)"
+                                    @select-all="selectAllInCurrentQuery(false)"
+                                    @selected-to="rangeSelect(item, lastItemFocused)"
                                     @tag-click="updateFilterValue('tag', $event)"
                                     @tag-change="onTagChange"
                                     @toggleHighlights="updateFilterValue('related', item.hid)"
diff --git a/client/src/components/History/SwitchToHistoryLink.vue b/client/src/components/History/SwitchToHistoryLink.vue
index 39fb8e945dc1..96149ac48bcc 100644
--- a/client/src/components/History/SwitchToHistoryLink.vue
+++ b/client/src/components/History/SwitchToHistoryLink.vue
@@ -18,6 +18,7 @@ const historyStore = useHistoryStore();
 
 interface Props {
     historyId: string;
+    filters?: Record<string, string | boolean>;
 }
 
 const props = defineProps<Props>();
@@ -26,11 +27,23 @@ const history = computed(() => historyStore.getHistoryById(props.historyId));
 
 const canSwitch = computed(() => !!history.value && !history.value.archived && !history.value.purged);
 
-const actionText = computed(() => (canSwitch.value ? "Switch to" : "View in new tab"));
+const actionText = computed(() => {
+    if (canSwitch.value) {
+        if (props.filters) {
+            return "Show in history";
+        }
+        return "Switch to";
+    }
+    return "View in new tab";
+});
 
 function onClick(history: HistorySummary) {
     if (canSwitch.value) {
-        historyStore.setCurrentHistory(history.id);
+        if (props.filters) {
+            historyStore.applyFilters(history.id, props.filters);
+        } else {
+            historyStore.setCurrentHistory(history.id);
+        }
         return;
     }
     viewHistoryInNewTab(history);
diff --git a/client/src/entry/analysis/menu.js b/client/src/entry/analysis/menu.js
index 495b0ae231a2..29ed49424a7b 100644
--- a/client/src/entry/analysis/menu.js
+++ b/client/src/entry/analysis/menu.js
@@ -41,18 +41,9 @@ export function fetchMenu(options = {}) {
     }
 
     //
-    // 'Data Items' or Libraries tab.
+    // 'Data' tab.
     //
-    if (Galaxy.config.single_user) {
-        // Single user can still use libraries, especially as we may grow that
-        // functionality as a representation for external data.  The rest is
-        // hidden though.
-        menu.push({
-            title: _l("Data Libraries"),
-            url: "/libraries",
-            id: "libraries",
-        });
-    } else if (Galaxy.user.id) {
+    if (Galaxy.user.id) {
         menu.push({
             id: "resources",
             title: _l("Data"),
@@ -102,10 +93,6 @@ export function fetchMenu(options = {}) {
                     url: "/libraries",
                     target: "_top",
                 },
-                {
-                    title: _l("Datasets"),
-                    url: "/datasets/list_published",
-                },
                 {
                     title: _l("Histories"),
                     url: "/histories/list_published",
diff --git a/lib/galaxy/model/__init__.py b/lib/galaxy/model/__init__.py
index c856002071da..235eb89ee3e8 100644
--- a/lib/galaxy/model/__init__.py
+++ b/lib/galaxy/model/__init__.py
@@ -6270,16 +6270,17 @@ def attribute_columns(column_collection, attributes, nesting_level=None):
 
         while ":" in depth_collection_type:
             nesting_level += 1
-            inner_dc = alias(DatasetCollection)
             inner_dce = alias(DatasetCollectionElement)
+            inner_dc = alias(DatasetCollection)
             order_by_columns.append(inner_dce.c.element_index)
-            q = q.join(
-                inner_dc, and_(inner_dc.c.id == dce.c.child_collection_id, dce.c.dataset_collection_id == dc.c.id)
-            ).outerjoin(inner_dce, inner_dce.c.dataset_collection_id == inner_dc.c.id)
-            q = q.add_columns(
-                *attribute_columns(inner_dce.c, element_attributes, nesting_level),
-                *attribute_columns(inner_dc.c, collection_attributes, nesting_level),
-            )
+            q = q.outerjoin(inner_dce, inner_dce.c.dataset_collection_id == dce.c.child_collection_id)
+            if collection_attributes:
+                q = q.join(inner_dc, inner_dc.c.id == dce.c.child_collection_id)
+            q = q.add_columns(*attribute_columns(inner_dce.c, element_attributes, nesting_level))
+            if collection_attributes:
+                q = q.add_columns(
+                    *attribute_columns(inner_dc.c, collection_attributes, nesting_level),
+                )
             dce = inner_dce
             dc = inner_dc
             depth_collection_type = depth_collection_type.split(":", 1)[1]
diff --git a/lib/galaxy/webapps/galaxy/controllers/history.py b/lib/galaxy/webapps/galaxy/controllers/history.py
index e4746fb6cba0..fd3f1a036f20 100644
--- a/lib/galaxy/webapps/galaxy/controllers/history.py
+++ b/lib/galaxy/webapps/galaxy/controllers/history.py
@@ -97,7 +97,13 @@ def display_by_username_and_slug(self, trans, username, slug, **kwargs):
         session = trans.sa_session
 
         user = session.scalars(select(model.User).filter_by(username=username).limit(1)).first()
-        history = session.scalars(select(model.History).filter_by(user=user, slug=slug, deleted=False).limit(1)).first()
+        history = session.scalars(
+            select(model.History)
+            .filter_by(user=user, slug=slug, deleted=False)
+            # return public histories first if slug is not unique
+            .order_by(model.History.importable.desc())
+            .limit(1)
+        ).first()
 
         if history is None:
             raise web.httpexceptions.HTTPNotFound()