From 42e49954f37693310f24676162b7373cdc744c38 Mon Sep 17 00:00:00 2001
From: John Chilton <jmchilton@gmail.com>
Date: Sun, 29 Dec 2024 22:12:45 -0500
Subject: [PATCH] Implement paired_or_unpaired collections...

---
 client/src/api/datasetCollections.ts          |  13 +-
 .../Collections/CollectionCreatorModal.vue    |  88 +--
 .../Collections/ListCollectionCreator.vue     |  38 +-
 .../src/components/Collections/ListWizard.vue | 201 +++++-
 .../Collections/ListWizard/WhichBuilder.vue   | 141 ++--
 .../Collections/ListWizard/types.ts           |   8 +-
 .../Collections/PairCollectionCreator.vue     |  36 +-
 .../PairedOrUnpairedListCollectionCreator.vue | 600 ++++++++++++++++++
 .../Collections/common/AutoPairing.vue        | 157 +++++
 .../common/CellDiscardComponent.vue           |  35 +
 .../common/CellStatusComponent.vue            |  69 ++
 .../Collections/common/CollectionCreator.vue  |  29 +-
 .../common/CollectionNameInput.vue            |   5 +-
 .../common/PairedDatasetCellComponent.vue     | 151 +++++
 .../common/PairingFilterInputGroup.vue        |  65 ++
 .../common/useCollectionCreation.ts           |  33 +
 .../common/useCollectionCreator.ts            |  64 +-
 .../Collections/common/usePairingSummary.ts   |  33 +
 .../components/Collections/pairing.test.ts    |  23 +-
 client/src/components/Collections/pairing.ts  |  16 +-
 .../Collection/CollectionDescription.vue      |  25 +-
 .../HistoryOperations/SelectionOperations.vue |  42 +-
 .../src/components/History/model/queries.ts   |   4 +-
 .../src/components/RuleCollectionBuilder.vue  |  44 +-
 .../modules/collectionTypeDescription.ts      |  37 +-
 .../Workflow/Editor/modules/terminals.test.ts |  66 ++
 .../Editor/test-data/parameter_steps.json     | 123 ++++
 client/src/entry/analysis/router.js           |   3 +
 .../src/stores/collectionBuilderItemsStore.ts |  24 +
 .../model/dataset_collections/adapters.py     | 257 ++++++++
 .../model/dataset_collections/registry.py     |   2 +
 .../model/dataset_collections/structure.py    |  11 +-
 .../dataset_collections/subcollections.py     |  17 +-
 .../dataset_collections/type_description.py   |  38 +-
 .../dataset_collections/types/__init__.py     |   8 +
 .../types/collection_semantics.yml            |  60 ++
 .../model/dataset_collections/types/paired.py |  11 +-
 .../types/paired_or_unpaired.py               |  43 ++
 lib/galaxy/schema/schema.py                   |   2 +
 lib/galaxy/tool_util/parameters/models.py     |  74 +++
 lib/galaxy/tools/__init__.py                  |  57 ++
 lib/galaxy/tools/actions/__init__.py          |  24 +-
 lib/galaxy/tools/parameters/basic.py          |  59 +-
 .../tools/parameters/dataset_matcher.py       |   1 +
 lib/galaxy/tools/parameters/history_query.py  |   3 +-
 .../tools/split_paired_and_unpaired.xml       | 132 ++++
 lib/galaxy/tools/wrappers.py                  |  21 +-
 .../api/test_dataset_collections.py           |  19 +
 lib/galaxy_test/api/test_tool_execute.py      | 119 ++++
 lib/galaxy_test/base/populators.py            |  47 ++
 .../collection_list_paired_or_unpaired.xml    |  88 +++
 .../tools/collection_paired_or_unpaired.xml   |  68 ++
 test/functional/tools/sample_tool_conf.xml    |   4 +-
 .../data/dataset_collections/test_matching.py |  44 ++
 .../dataset_collections/test_structure.py     |  31 +
 .../test_type_descriptions.py                 |  33 +-
 56 files changed, 3229 insertions(+), 217 deletions(-)
 create mode 100644 client/src/components/Collections/PairedOrUnpairedListCollectionCreator.vue
 create mode 100644 client/src/components/Collections/common/AutoPairing.vue
 create mode 100644 client/src/components/Collections/common/CellDiscardComponent.vue
 create mode 100644 client/src/components/Collections/common/CellStatusComponent.vue
 create mode 100644 client/src/components/Collections/common/PairedDatasetCellComponent.vue
 create mode 100644 client/src/components/Collections/common/PairingFilterInputGroup.vue
 create mode 100644 client/src/components/Collections/common/useCollectionCreation.ts
 create mode 100644 client/src/components/Collections/common/usePairingSummary.ts
 create mode 100644 lib/galaxy/model/dataset_collections/adapters.py
 create mode 100644 lib/galaxy/model/dataset_collections/types/paired_or_unpaired.py
 create mode 100644 lib/galaxy/tools/split_paired_and_unpaired.xml
 create mode 100644 test/functional/tools/collection_list_paired_or_unpaired.xml
 create mode 100644 test/functional/tools/collection_paired_or_unpaired.xml

diff --git a/client/src/api/datasetCollections.ts b/client/src/api/datasetCollections.ts
index f5955dfb1daa..08c53058deff 100644
--- a/client/src/api/datasetCollections.ts
+++ b/client/src/api/datasetCollections.ts
@@ -85,10 +85,10 @@ export async function fetchElementsFromCollection(params: {
     });
 }
 
-type CollectionElementIdentifiers = components["schemas"]["CollectionElementIdentifier"][];
-type CreateNewCollectionPayload = components["schemas"]["CreateNewCollectionPayload"];
+export type CollectionElementIdentifiers = components["schemas"]["CollectionElementIdentifier"][];
+export type CreateNewCollectionPayload = components["schemas"]["CreateNewCollectionPayload"];
 
-type NewCollectionOptions = {
+export type NewCollectionOptions = {
     name: string;
     element_identifiers: CollectionElementIdentifiers;
     collection_type: string;
@@ -104,13 +104,18 @@ export function createCollectionPayload(options: NewCollectionOptions): CreateNe
         element_identifiers: options.element_identifiers,
         collection_type: options.collection_type,
         instance_type: "history",
+        fields: "auto",
         copy_elements: options.copy_elements || true,
         hide_source_items: options.hide_source_items || true,
     };
 }
 
-export async function createHistoryDatasetCollectionInstance(options: NewCollectionOptions) {
+export async function createHistoryDatasetCollectionInstanceSimple(options: NewCollectionOptions) {
     const payload = createCollectionPayload(options);
+    return createHistoryDatasetCollectionInstanceFull(payload);
+}
+
+export async function createHistoryDatasetCollectionInstanceFull(payload: CreateNewCollectionPayload) {
     const { data, error } = await GalaxyApi().POST("/api/dataset_collections", {
         body: payload,
     });
diff --git a/client/src/components/Collections/CollectionCreatorModal.vue b/client/src/components/Collections/CollectionCreatorModal.vue
index e376a50410ea..a196a777d560 100644
--- a/client/src/components/Collections/CollectionCreatorModal.vue
+++ b/client/src/components/Collections/CollectionCreatorModal.vue
@@ -4,18 +4,18 @@ import { FontAwesomeIcon } from "@fortawesome/vue-fontawesome";
 import { BAlert, BLink, BModal } from "bootstrap-vue";
 import { computed, ref, watch } from "vue";
 
-import type { HDASummary, HistoryItemSummary, HistorySummary } from "@/api";
-import { createDatasetCollection } from "@/components/History/model/queries";
+import type { HistoryItemSummary } from "@/api";
+import { createHistoryDatasetCollectionInstanceFull, type CreateNewCollectionPayload } from "@/api/datasetCollections";
 import { useCollectionBuilderItemsStore } from "@/stores/collectionBuilderItemsStore";
 import { useHistoryStore } from "@/stores/historyStore";
 import localize from "@/utils/localization";
 import { orList } from "@/utils/strings";
 
-import type { CollectionType, DatasetPair } from "../History/adapters/buildCollectionModal";
+import type { CollectionType } from "../History/adapters/buildCollectionModal";
 
 import ListCollectionCreator from "./ListCollectionCreator.vue";
 import PairCollectionCreator from "./PairCollectionCreator.vue";
-import PairedListCollectionCreator from "./PairedListCollectionCreator.vue";
+import PairedOrUnpairedListCollectionCreator from "./PairedOrUnpairedListCollectionCreator.vue";
 import Heading from "@/components/Common/Heading.vue";
 import GenericItem from "@/components/History/Content/GenericItem.vue";
 import LoadingSpan from "@/components/LoadingSpan.vue";
@@ -30,6 +30,7 @@ interface Props {
     fromRulesInput?: boolean;
     hideModalOnCreate?: boolean;
     filterText?: string;
+    useBetaComponents?: boolean;
 }
 const props = defineProps<Props>();
 
@@ -141,63 +142,11 @@ const modalTitle = computed(() => {
 });
 
 // Methods
-function createListCollection(elements: HDASummary[], name: string, hideSourceItems: boolean) {
-    const returnedElems = elements.map((element) => ({
-        id: element.id,
-        name: element.name,
-        //TODO: this allows for list:list even if the implementation does not - reconcile
-        src: "src" in element ? element.src : element.history_content_type == "dataset" ? "hda" : "hdca",
-    }));
-    return createHDCA(returnedElems, "list", name, hideSourceItems);
-}
-
-function createListPairedCollection(elements: DatasetPair[], name: string, hideSourceItems: boolean) {
-    const returnedElems = elements.map((pair) => ({
-        collection_type: "paired",
-        src: "new_collection",
-        name: pair.name,
-        element_identifiers: [
-            {
-                name: "forward",
-                id: pair.forward.id,
-                src: "src" in pair.forward ? pair.forward.src : "hda",
-            },
-            {
-                name: "reverse",
-                id: pair.reverse.id,
-                src: "src" in pair.reverse ? pair.reverse.src : "hda",
-            },
-        ],
-    }));
-    return createHDCA(returnedElems, "list:paired", name, hideSourceItems);
-}
 
-function createPairedCollection(elements: DatasetPair, name: string, hideSourceItems: boolean) {
-    const { forward, reverse } = elements;
-    const returnedElems = [
-        { name: "forward", src: "src" in forward ? forward.src : "hda", id: forward.id },
-        { name: "reverse", src: "src" in reverse ? reverse.src : "hda", id: reverse.id },
-    ];
-    return createHDCA(returnedElems, "paired", name, hideSourceItems);
-}
-
-async function createHDCA(
-    element_identifiers: any[],
-    collection_type: CollectionType,
-    name: string,
-    hide_source_items: boolean,
-    options = {}
-) {
+async function createHDCA(payload: CreateNewCollectionPayload) {
     try {
         creatingCollection.value = true;
-        const collection = await createDatasetCollection(history.value as HistorySummary, {
-            collection_type,
-            name,
-            hide_source_items,
-            element_identifiers,
-            options,
-        });
-
+        const collection = await createHistoryDatasetCollectionInstanceFull(payload);
         emit("created-collection", collection);
         createdCollection.value = collection;
 
@@ -293,16 +242,30 @@ function resetModal() {
             :default-hide-source-items="props.defaultHideSourceItems"
             :from-selection="fromSelection"
             :extensions="props.extensions"
-            @on-create="createListCollection"
+            mode="modal"
+            @on-create="createHDCA"
             @on-cancel="hideModal" />
-        <PairedListCollectionCreator
+        <PairedOrUnpairedListCollectionCreator
             v-else-if="props.collectionType === 'list:paired'"
             :history-id="props.historyId"
             :initial-elements="creatorItems || []"
             :default-hide-source-items="props.defaultHideSourceItems"
             :from-selection="fromSelection"
             :extensions="props.extensions"
-            @on-create="createListPairedCollection"
+            collection-type="list:paired"
+            mode="modal"
+            @on-create="createHDCA"
+            @on-cancel="hideModal" />
+        <PairedOrUnpairedListCollectionCreator
+            v-else-if="props.collectionType === 'list:paired_or_unpaired'"
+            :history-id="props.historyId"
+            :initial-elements="creatorItems || []"
+            :default-hide-source-items="props.defaultHideSourceItems"
+            :from-selection="fromSelection"
+            :extensions="props.extensions"
+            collection-type="list:paired_or_unpaired"
+            mode="modal"
+            @on-create="createHDCA"
             @on-cancel="hideModal" />
         <PairCollectionCreator
             v-else-if="props.collectionType === 'paired'"
@@ -311,7 +274,8 @@ function resetModal() {
             :default-hide-source-items="props.defaultHideSourceItems"
             :from-selection="fromSelection"
             :extensions="props.extensions"
-            @clicked-create="createPairedCollection"
+            mode="modal"
+            @on-create="createHDCA"
             @on-cancel="hideModal" />
     </BModal>
 </template>
diff --git a/client/src/components/Collections/ListCollectionCreator.vue b/client/src/components/Collections/ListCollectionCreator.vue
index df63e0f82e44..b9aacbc65230 100644
--- a/client/src/components/Collections/ListCollectionCreator.vue
+++ b/client/src/components/Collections/ListCollectionCreator.vue
@@ -9,12 +9,13 @@ import { computed, ref, watch } from "vue";
 import draggable from "vuedraggable";
 
 import type { HDASummary, HistoryItemSummary } from "@/api";
+import { type CollectionElementIdentifiers, type CreateNewCollectionPayload } from "@/api/datasetCollections";
 import { useConfirmDialog } from "@/composables/confirmDialog";
 import { Toast } from "@/composables/toast";
 import localize from "@/utils/localization";
 
 import { stripExtension } from "./common/stripExtension";
-import { useCollectionCreator } from "./common/useCollectionCreator";
+import { type Mode, useCollectionCreator } from "./common/useCollectionCreator";
 
 import FormSelectMany from "../Form/Elements/FormSelectMany/FormSelectMany.vue";
 import CollectionCreator from "@/components/Collections/common/CollectionCreator.vue";
@@ -28,14 +29,16 @@ interface Props {
     defaultHideSourceItems?: boolean;
     fromSelection?: boolean;
     extensions?: string[];
-    showButtons?: boolean;
+    mode: Mode;
 }
 
 const props = defineProps<Props>();
 
 const emit = defineEmits<{
-    (e: "on-create", workingElements: HDASummary[], collectionName: string, hideSourceItems: boolean): void;
+    (e: "on-create", options: CreateNewCollectionPayload): void;
     (e: "on-cancel"): void;
+    (e: "name", value: string): void;
+    (e: "input-valid", value: boolean): void;
 }>();
 
 const state = ref("build");
@@ -81,7 +84,16 @@ const allElementsAreInvalid = computed(() => {
 /** If not `fromSelection`, the list of elements that will become the collection */
 const inListElements = ref<HDASummary[]>([]);
 
-const { removeExtensions, hideSourceItems, onUpdateHideSourceItems, isElementInvalid } = useCollectionCreator(props);
+const {
+    removeExtensions,
+    hideSourceItems,
+    onUpdateHideSourceItems,
+    isElementInvalid,
+    collectionName,
+    onUpdateCollectionName,
+    onCollectionCreate,
+    showButtonsForModal,
+} = useCollectionCreator(props, emit);
 
 // ----------------------------------------------------------------------- process raw list
 /** set up main data */
@@ -245,7 +257,7 @@ function clickSelectAll() {
 }
 const { confirm } = useConfirmDialog();
 
-async function clickedCreate(collectionName: string) {
+async function attemptCreate() {
     checkForDuplicates();
 
     const returnedElements = props.fromSelection ? workingElements.value : inListElements.value;
@@ -261,10 +273,18 @@ async function clickedCreate(collectionName: string) {
     }
 
     if (state.value !== "error" && (atLeastOneElement.value || confirmed)) {
-        emit("on-create", returnedElements, collectionName, hideSourceItems.value);
+        const identifiers = returnedElements.map((element) => ({
+            id: element.id,
+            name: element.name,
+            //TODO: this allows for list:list even if the implementation does not - reconcile
+            src: "src" in element ? element.src : element.history_content_type == "dataset" ? "hda" : "hdca",
+        })) as CollectionElementIdentifiers;
+        onCollectionCreate("list", identifiers);
     }
 }
 
+defineExpose({ attemptCreate });
+
 function checkForDuplicates() {
     var valid = true;
     var existingNames: { [key: string]: boolean } = {};
@@ -399,12 +419,14 @@ function renameElement(element: any, name: string) {
                 collection-type="list"
                 :no-items="props.initialElements.length == 0 && !props.fromSelection"
                 :show-upload="!fromSelection"
-                :show-buttons="showButtons"
+                :show-buttons="showButtonsForModal"
+                :collection-name="collectionName"
+                @on-update-collection-name="onUpdateCollectionName"
                 @add-uploaded-files="addUploadedFiles"
                 @on-update-datatype-toggle="changeDatatypeFilter"
                 @onUpdateHideSourceItems="onUpdateHideSourceItems"
                 @remove-extensions-toggle="removeExtensionsToggle"
-                @clicked-create="clickedCreate">
+                @clicked-create="attemptCreate">
                 <template v-slot:help-content>
                     <p>
                         {{
diff --git a/client/src/components/Collections/ListWizard.vue b/client/src/components/Collections/ListWizard.vue
index 21513f1a33ee..3acd44e5138f 100644
--- a/client/src/components/Collections/ListWizard.vue
+++ b/client/src/components/Collections/ListWizard.vue
@@ -2,30 +2,56 @@
 import { storeToRefs } from "pinia";
 import { computed, onMounted, ref, watch } from "vue";
 
+import {
+    type CollectionElementIdentifiers,
+    createHistoryDatasetCollectionInstanceFull,
+    type CreateNewCollectionPayload,
+} from "@/api/datasetCollections";
 import { useWizard } from "@/components/Common/Wizard/useWizard";
 import { useCollectionBuilderItemSelection } from "@/stores/collectionBuilderItemsStore";
 
+import { useCollectionCreation } from "./common/useCollectionCreation";
+import { type SupportedPairedOrPairedBuilderCollectionTypes } from "./common/useCollectionCreator";
 import { type WhichListBuilder } from "./ListWizard/types";
 import { autoPairWithCommonFilters } from "./pairing";
 
+import AutoPairing from "./common/AutoPairing.vue";
 import ListCollectionCreator from "./ListCollectionCreator.vue";
 import WhichBuilder from "./ListWizard/WhichBuilder.vue";
-import PairedListCollectionCreator from "./PairedListCollectionCreator.vue";
+import PairedOrUnpairedListCollectionCreator from "./PairedOrUnpairedListCollectionCreator.vue";
 import GenericWizard from "@/components/Common/Wizard/GenericWizard.vue";
+import RuleCollectionBuilder from "components/RuleCollectionBuilder.vue";
+
+interface Props {
+    initialAdvanced: boolean;
+}
+
+const props = defineProps<Props>();
 
 const isBusy = ref<boolean>(false);
 const whichBuilder = ref<WhichListBuilder>("list");
 const store = useCollectionBuilderItemSelection();
+const { currentHistoryId, createPayload } = useCollectionCreation();
+const currentForwardFilter = ref("");
+const currentReverseFilter = ref("");
 
+type InferrableBuilder = "list" | "list:paired";
+type CollectionCreatorComponent =
+    | InstanceType<typeof ListCollectionCreator>
+    | InstanceType<typeof PairedOrUnpairedListCollectionCreator>;
+const collectionCreator = ref<CollectionCreatorComponent>();
 const { selectedItems } = storeToRefs(store);
 
 const countPaired = ref(-1);
 const countUnpaired = ref(-1);
-const inferredBuilder = ref<WhichListBuilder>("list");
+const inferredBuilder = ref<InferrableBuilder>("list");
+const builderInputsValid = ref(false);
 
 async function initialize() {
     isBusy.value = true;
     const summary = autoPairWithCommonFilters(selectedItems.value, true);
+    currentForwardFilter.value = summary.forwardFilter || "";
+    currentReverseFilter.value = summary.reverseFilter || "";
     countPaired.value = summary.pairs?.length || 0;
     countUnpaired.value = summary.unpaired.length;
     if (countPaired.value * 2 > selectedItems.value.length * 0.2) {
@@ -35,15 +61,23 @@ async function initialize() {
         whichBuilder.value = "list";
         inferredBuilder.value = "list";
     }
-    goToInferredBuilder();
+
+    if (!props.initialAdvanced) {
+        goToInferredBuilder();
+    }
     isBusy.value = false;
 }
 
+const requiresPairing = computed(() => {
+    return whichBuilder.value === "list:paired" || whichBuilder.value == "list:paired_or_unpaired";
+});
+
 function goToInferredBuilder() {
     const builder = inferredBuilder.value;
     if (builder == "list") {
         wizard.goTo("list-builder");
     } else if (builder == "list:paired") {
+        console.log("going to inferred builder...");
         wizard.goTo("list-paired-builder");
     }
 }
@@ -52,6 +86,18 @@ watch(selectedItems, () => {
     initialize();
 });
 
+const instructions = computed(() => {
+    if (whichBuilder.value == "list") {
+        return "Assemble, label, and sort your list.";
+    } else if (whichBuilder.value == "list:paired") {
+        return "Assemble, label, and sort your list of pairs.";
+    } else if (whichBuilder.value == "list:paired_or_unpaired") {
+        return "Assemble, label, and sort your list of paired and unpaired datasets.";
+    } else {
+        return "Assemble, label, and sort your list.";
+    }
+});
+
 onMounted(initialize);
 
 const wizard = useWizard({
@@ -63,66 +109,177 @@ const wizard = useWizard({
         isValid: () => true,
         isSkippable: () => false,
     },
-    "list-builder": {
-        label: "Builder",
+    "auto-pairing": {
+        label: "Auto Pairing",
         instructions: computed(() => {
-            return "Assemble, label, and sort your list.";
+            return "Configure auto-pairing";
         }),
         isValid: () => true,
+        isSkippable: () => !requiresPairing.value,
+    },
+    "list-builder": {
+        label: "Builder",
+        instructions: instructions,
+        isValid: () => builderInputsValid.value,
         isSkippable: () => whichBuilder.value !== "list",
     },
     "list-paired-builder": {
+        label: "Builder",
+        instructions: instructions,
+        isValid: () => builderInputsValid.value,
+        isSkippable: () => ["list", "rules"].indexOf(whichBuilder.value) !== -1,
+    },
+    rules: {
         label: "Builder",
         instructions: computed(() => {
-            return "Assemble, label, and sort your list of pairs.";
+            return "Assemble, label, and sort your list(s).";
         }),
-        isValid: () => true,
-        isSkippable: () => whichBuilder.value !== "list:paired",
+        isValid: () => ruleState.value,
+        isSkippable: () => whichBuilder.value !== "rules",
     },
 });
 
+const collectionTypeForPairedOrUnpairedBuilder = computed(
+    () => whichBuilder.value as SupportedPairedOrPairedBuilderCollectionTypes
+);
+
 const buildButtonLabel = computed(() => {
     return "Build";
 });
 
-function submit() {
-    console.log("submitted....");
+const pairedListType = computed(() => {
+    return whichBuilder.value == "list:paired_or_unpaired" ? "list:paired_or_unpaired" : "list:paired";
+});
+
+async function attemptCreate(creator: CollectionCreatorComponent) {
+    // fight typing to workaround https://github.com/vuejs/core/issues/10077
+    interface HasAttemptCreate {
+        attemptCreate: () => Promise<void>;
+    }
+
+    (creator as unknown as HasAttemptCreate).attemptCreate();
+}
+
+async function submit() {
+    if (collectionCreator.value) {
+        attemptCreate(collectionCreator.value);
+    }
+}
+
+async function onCreate(payload: CreateNewCollectionPayload) {
+    try {
+        const data = await createHistoryDatasetCollectionInstanceFull(payload);
+        console.log(data);
+        console.log("collection created!");
+    } catch (e) {
+        console.log(e);
+    }
+}
+
+type RuleCreationRequestT = {
+    name: string;
+    collectionType: string;
+    elementIdentifiers: CollectionElementIdentifiers;
+    hide_source_items: boolean;
+}[];
+
+async function ruleOnAttemptCreate(createRequest: RuleCreationRequestT) {
+    console.log("in outer... ruleOnAttemptCreate");
+    for (const request of createRequest) {
+        const payload = createPayload(
+            request.name,
+            request.collectionType,
+            request.elementIdentifiers,
+            request.hide_source_items
+        );
+        await onCreate(payload);
+    }
 }
 
 function setWhichBuilder(newWhichBuilder: WhichListBuilder) {
     whichBuilder.value = newWhichBuilder;
 }
 
-function create() {
-    console.log("in create...");
+function onFilters(forwardFilter: string, reverseFilter: string) {
+    currentForwardFilter.value = forwardFilter;
+    currentReverseFilter.value = reverseFilter;
+}
+
+function goToAutoPairing() {
+    wizard.goTo("auto-pairing");
+}
+
+function onRuleCreate() {
+    return 3;
+}
+
+function onRuleCancel() {
+    return 3;
+}
+
+const ruleState = ref(false);
+
+function onRuleState(newRuleState: boolean) {
+    console.log("in on Rule state...");
+    ruleState.value = newRuleState;
 }
 </script>
 
 <template>
-    <div>
+    <div v-if="currentHistoryId">
         <GenericWizard :use="wizard" :is-busy="isBusy" :submit-button-label="buildButtonLabel" @submit="submit">
             <div v-if="wizard.isCurrent('which-builder')">
-                <WhichBuilder :value="whichBuilder" @onChange="setWhichBuilder" />
+                <WhichBuilder :initial-advanced="initialAdvanced" :value="whichBuilder" @onChange="setWhichBuilder" />
             </div>
             <div v-else-if="wizard.isCurrent('list-builder')" class="collection-creator-bounded-help">
                 <ListCollectionCreator
-                    :history-id="'TODO'"
+                    ref="collectionCreator"
+                    :history-id="currentHistoryId"
                     :initial-elements="selectedItems || []"
                     :default-hide-source-items="true"
                     :from-selection="true"
                     :show-upload="false"
-                    :show-buttons="false"
-                    @clicked-create="create" />
+                    mode="wizard"
+                    @input-valid="(e) => (builderInputsValid = e)"
+                    @on-create="onCreate" />
+            </div>
+            <div v-else-if="wizard.isCurrent('auto-pairing')">
+                <AutoPairing
+                    :elements="selectedItems || []"
+                    :forward-filter="currentForwardFilter"
+                    :reverse-filter="currentReverseFilter"
+                    :collection-type="pairedListType"
+                    :remove-extensions="true"
+                    mode="wizard"
+                    @on-update="onFilters" />
             </div>
-            <div v-else-if="wizard.isCurrent('list-paired-builder')" class="collection-creator-bounded-help">
-                <PairedListCollectionCreator
-                    :history-id="'TODO'"
+            <div v-else-if="wizard.isCurrent('list-paired-builder')">
+                <PairedOrUnpairedListCollectionCreator
+                    ref="collectionCreator"
+                    :history-id="currentHistoryId"
                     :initial-elements="selectedItems || []"
+                    :collection-type="collectionTypeForPairedOrUnpairedBuilder"
+                    mode="wizard"
                     :default-hide-source-items="true"
                     :from-selection="true"
                     :show-upload="false"
                     :show-buttons="false"
-                    @clicked-create="create" />
+                    @input-valid="(e) => (builderInputsValid = e)"
+                    @go-to-auto-pairing="goToAutoPairing"
+                    @on-create="onCreate" />
+            </div>
+            <div v-else-if="wizard.isCurrent('rules')">
+                <RuleCollectionBuilder
+                    ref="collectionCreator"
+                    grid-implementation="ag"
+                    import-type="collections"
+                    elements-type="datasets"
+                    :initial-elements="selectedItems || []"
+                    mode="wizard"
+                    :oncreate="onRuleCreate"
+                    :oncancel="onRuleCancel"
+                    @onAttemptCreate="ruleOnAttemptCreate"
+                    @validInput="onRuleState" />
             </div>
         </GenericWizard>
     </div>
diff --git a/client/src/components/Collections/ListWizard/WhichBuilder.vue b/client/src/components/Collections/ListWizard/WhichBuilder.vue
index 5c899ca92e36..733140ae577a 100644
--- a/client/src/components/Collections/ListWizard/WhichBuilder.vue
+++ b/client/src/components/Collections/ListWizard/WhichBuilder.vue
@@ -1,5 +1,6 @@
 <script setup lang="ts">
-import { BCard, BCardGroup, BCardTitle } from "bootstrap-vue";
+import { BButton, BCard, BCardGroup, BCardTitle } from "bootstrap-vue";
+import { ref } from "vue";
 
 import { borderVariant } from "@/components/Common/Wizard/utils";
 
@@ -7,53 +8,109 @@ import { type WhichListBuilder } from "./types";
 
 interface Props {
     value: WhichListBuilder;
+    initialAdvanced: boolean;
 }
 
 const emit = defineEmits(["onChange"]);
 
-defineProps<Props>();
+const props = defineProps<Props>();
+
+const advanced = ref(props.initialAdvanced);
+
+function toggleAdvanced() {
+    advanced.value = !advanced.value;
+}
 </script>
 
 <template>
-    <BCardGroup deck>
-        <BCard
-            data-which-builder="list"
-            class="wizard-selection-card"
-            :border-variant="borderVariant(value === 'list')"
-            @click="emit('onChange', 'list')">
-            <BCardTitle>
-                <b>Flat List</b>
-            </BCardTitle>
-            <div>
-                This options creates a simple flat list of files. If your data isn't nested and does not contained
-                paired datasets, this is the the option to choose.
-            </div>
-        </BCard>
-        <BCard
-            data-which-builder="list:paired"
-            class="wizard-selection-card"
-            :border-variant="borderVariant(value === 'list:paired')"
-            @click="emit('onChange', 'list:paired')">
-            <BCardTitle>
-                <b>List of Paired Datasets</b>
-            </BCardTitle>
-            <div>
-                This options creates a uniform list of paired datasets, use this option if all of your data should be
-                paired off.
-            </div>
-        </BCard>
-        <BCard
-            data-which-builder="rules"
-            class="wizard-selection-card"
-            :border-variant="borderVariant(value === 'rules')"
-            @click="emit('onChange', 'rules')">
-            <BCardTitle>
-                <b>Rule Builder</b>
-            </BCardTitle>
-            <div>
-                The rule builder allows building arbitrarily nested collections of data with reproducible metadata
-                parsing and other advanced features.
+    <div>
+        <BCardGroup deck>
+            <BCard
+                data-which-builder="list"
+                class="wizard-selection-card"
+                :border-variant="borderVariant(value === 'list')"
+                @click="emit('onChange', 'list')">
+                <BCardTitle>
+                    <b>Flat List</b>
+                </BCardTitle>
+                <div>
+                    This options creates a simple flat list of files. If your data isn't nested and does not contained
+                    paired datasets, this is the the option to choose.
+                </div>
+            </BCard>
+            <BCard
+                data-which-builder="list:paired"
+                class="wizard-selection-card"
+                :border-variant="borderVariant(value === 'list:paired')"
+                @click="emit('onChange', 'list:paired')">
+                <BCardTitle>
+                    <b>List of Paired Datasets</b>
+                </BCardTitle>
+                <div>
+                    This options creates a uniform list of paired datasets, use this option if all of your data should
+                    be paired off.
+                </div>
+            </BCard>
+            <BCard
+                data-which-builder="rules"
+                class="wizard-selection-card"
+                :border-variant="borderVariant(value === 'rules')"
+                @click="emit('onChange', 'rules')">
+                <BCardTitle>
+                    <b>Rule Builder</b>
+                </BCardTitle>
+                <div>
+                    The rule builder allows building arbitrarily nested collections of data with reproducible metadata
+                    parsing and other advanced features.
+                </div>
+            </BCard>
+        </BCardGroup>
+        <span>
+            <div v-if="!advanced" class="m-3">
+                <BButton variant="primary" @click="toggleAdvanced">Advanced Options</BButton>
             </div>
-        </BCard>
-    </BCardGroup>
+            <BCardGroup v-else deck class="mt-3">
+                <BCard
+                    data-which-builder="list:paired_or_unpaired"
+                    class="wizard-selection-card"
+                    :border-variant="borderVariant(value === 'list:paired_or_unpaired')"
+                    @click="emit('onChange', 'list:paired_or_unpaired')">
+                    <BCardTitle>
+                        <b>Mixed List of Paired and Unpaired Datasets</b>
+                    </BCardTitle>
+                    <div>
+                        For studies that have a mix of paired and unpaired data, this may be the right choice. Existing
+                        tools and workflows may have to be updated to allow this modality though.
+                    </div>
+                </BCard>
+                <BCard
+                    data-which-builder="list:list"
+                    class="wizard-selection-card"
+                    :border-variant="borderVariant(value === 'list:list')"
+                    @click="emit('onChange', 'list:list')">
+                    <BCardTitle>
+                        <b>Nested List of Datasets</b>
+                    </BCardTitle>
+                    <div>
+                        A nested list of datasets. This type of collection is a list where each element is in turn a
+                        list of datasets. The outer list identifier might group samples together by condition, sample
+                        type, etc..
+                    </div>
+                </BCard>
+                <BCard
+                    data-which-builder="list:list:paired"
+                    class="wizard-selection-card"
+                    :border-variant="borderVariant(value === 'list:list:paired')"
+                    @click="emit('onChange', 'list:list:paired')">
+                    <BCardTitle>
+                        <b>Nested List of Dataset Pairs</b>
+                    </BCardTitle>
+                    <div>
+                        A nested list of datasets. This type of collection is a list where each element is in turn a
+                        list of pairs of datasets.
+                    </div>
+                </BCard>
+            </BCardGroup>
+        </span>
+    </div>
 </template>
diff --git a/client/src/components/Collections/ListWizard/types.ts b/client/src/components/Collections/ListWizard/types.ts
index 0d3840d85bfd..429f92f6c40a 100644
--- a/client/src/components/Collections/ListWizard/types.ts
+++ b/client/src/components/Collections/ListWizard/types.ts
@@ -1 +1,7 @@
-export type WhichListBuilder = "list" | "list:paired" | "rules";
+export type WhichListBuilder =
+    | "list"
+    | "list:paired"
+    | "rules"
+    | "list:paired_or_unpaired"
+    | "list:list"
+    | "list:list:paired";
diff --git a/client/src/components/Collections/PairCollectionCreator.vue b/client/src/components/Collections/PairCollectionCreator.vue
index c1d3a318392d..8933d0340552 100644
--- a/client/src/components/Collections/PairCollectionCreator.vue
+++ b/client/src/components/Collections/PairCollectionCreator.vue
@@ -5,11 +5,11 @@ import { BAlert, BButton } from "bootstrap-vue";
 import { computed, ref, watch } from "vue";
 
 import type { HDASummary, HistoryItemSummary } from "@/api";
+import { type CollectionElementIdentifiers, type CreateNewCollectionPayload } from "@/api/datasetCollections";
 import { Toast } from "@/composables/toast";
 import localize from "@/utils/localization";
 
-import type { DatasetPair } from "../History/adapters/buildCollectionModal";
-import { useCollectionCreator } from "./common/useCollectionCreator";
+import { type Mode, useCollectionCreator } from "./common/useCollectionCreator";
 import { guessNameForPair } from "./pairing";
 
 import DatasetCollectionElementView from "./ListDatasetCollectionElementView.vue";
@@ -28,12 +28,13 @@ interface Props {
     defaultHideSourceItems?: boolean;
     fromSelection?: boolean;
     extensions?: string[];
+    mode: Mode;
 }
 
 const props = defineProps<Props>();
 
 const emit = defineEmits<{
-    (event: "on-create", selectedPair: DatasetPair, collectionName: string, hideSourceItems: boolean): void;
+    (event: "on-create", options: CreateNewCollectionPayload): void;
     (event: "on-cancel"): void;
 }>();
 
@@ -65,7 +66,15 @@ const pairElements = computed<SelectedDatasetPair>(() => {
     }
 });
 
-const { removeExtensions, hideSourceItems, onUpdateHideSourceItems, isElementInvalid } = useCollectionCreator(props);
+const {
+    removeExtensions,
+    hideSourceItems,
+    onUpdateHideSourceItems,
+    isElementInvalid,
+    onCollectionCreate,
+    showButtonsForModal,
+    onUpdateCollectionName,
+} = useCollectionCreator(props);
 
 watch(
     () => props.initialElements,
@@ -207,14 +216,15 @@ function addUploadedFiles(files: HDASummary[]) {
     });
 }
 
-function clickedCreate(collectionName: string) {
+function attemptCreate() {
     if (state.value !== "error" && exactlyTwoValidElements.value) {
-        const returnedPair = {
-            forward: pairElements.value.forward as HDASummary,
-            reverse: pairElements.value.reverse as HDASummary,
-            name: collectionName,
-        };
-        emit("on-create", returnedPair, collectionName, hideSourceItems.value);
+        const forward = pairElements.value.forward as HDASummary;
+        const reverse = pairElements.value.reverse as HDASummary;
+        const returnedElems = [
+            { name: "forward", src: "src" in forward ? forward.src : "hda", id: forward.id },
+            { name: "reverse", src: "src" in reverse ? reverse.src : "hda", id: reverse.id },
+        ] as CollectionElementIdentifiers;
+        onCollectionCreate("paired", returnedElems);
     }
 }
 
@@ -274,9 +284,11 @@ function _guessNameForPair(fwd: HDASummary, rev: HDASummary, removeExtensions: b
                 collection-type="paired"
                 :no-items="props.initialElements.length == 0 && !props.fromSelection"
                 :show-upload="!fromSelection"
+                :show-buttons="showButtonsForModal"
+                @on-update-collection-name="onUpdateCollectionName"
                 @add-uploaded-files="addUploadedFiles"
                 @onUpdateHideSourceItems="onUpdateHideSourceItems"
-                @clicked-create="clickedCreate"
+                @clicked-create="attemptCreate"
                 @remove-extensions-toggle="removeExtensionsToggle">
                 <template v-slot:help-content>
                     <!-- TODO: Update help content for case where `fromSelection` is false -->
diff --git a/client/src/components/Collections/PairedOrUnpairedListCollectionCreator.vue b/client/src/components/Collections/PairedOrUnpairedListCollectionCreator.vue
new file mode 100644
index 000000000000..25cd6b728e25
--- /dev/null
+++ b/client/src/components/Collections/PairedOrUnpairedListCollectionCreator.vue
@@ -0,0 +1,600 @@
+<script setup lang="ts">
+import { type ColDef, type GetRowIdParams, type NewValueParams } from "ag-grid-community";
+import { BCol, BLink, BRow } from "bootstrap-vue";
+import { getActivePinia } from "pinia";
+import { computed, nextTick, ref } from "vue";
+
+import type { components, HDASummary, HistoryItemSummary } from "@/api";
+import { type CreateNewCollectionPayload } from "@/api/datasetCollections";
+import { splitIntoPairedAndUnpaired } from "@/components/Collections/pairing";
+import { useConfirmDialog } from "@/composables/confirmDialog";
+import { Toast } from "@/composables/toast";
+import { useAgGrid } from "@/composables/useAgGrid";
+import localize from "@/utils/localization";
+
+import type { GenericPair } from "../History/adapters/buildCollectionModal";
+import {
+    type SupportedPairedOrPairedBuilderCollectionTypes,
+    useCollectionCreator,
+} from "./common/useCollectionCreator";
+import { usePairingSummary } from "./common/usePairingSummary";
+import { type AutoPairingResult, autoPairWithCommonFilters } from "./pairing";
+
+import AutoPairing from "./common/AutoPairing.vue";
+import CellDiscardComponent from "./common/CellDiscardComponent.vue";
+import CellStatusComponent from "./common/CellStatusComponent.vue";
+import PairedDatasetCellComponent from "./common/PairedDatasetCellComponent.vue";
+import CollectionCreator from "@/components/Collections/common/CollectionCreator.vue";
+
+type CollectionElementIdentifier = components["schemas"]["CollectionElementIdentifier"];
+type CollectionSourceType = components["schemas"]["ColletionSourceType"];
+const NOT_VALID_ELEMENT_MSG: string = localize("is not a valid element for this collection");
+
+const { confirm } = useConfirmDialog();
+
+const pinia = getActivePinia();
+
+interface Props {
+    historyId: string;
+    initialElements: HistoryItemSummary[];
+    defaultHideSourceItems?: boolean;
+    fromSelection?: boolean;
+    extensions?: string[];
+    height?: string;
+    width?: string;
+    forwardFilter?: string;
+    reverseFilter?: string;
+    collectionType: SupportedPairedOrPairedBuilderCollectionTypes;
+    mode: "wizard" | "modal"; // in modal mode we need to show buttons and manage pairing components, wizard takes care these details
+}
+
+const { gridApi, AgGridVue, onGridReady, theme } = useAgGrid(resize);
+
+const showAutoPairing = ref<boolean>(false);
+
+function resize() {
+    if (gridApi.value) {
+        gridApi.value.sizeColumnsToFit();
+    }
+}
+
+const emit = defineEmits<{
+    (e: "on-create", options: CreateNewCollectionPayload): void;
+    (e: "on-cancel"): void;
+    (e: "go-to-auto-pairing"): void;
+    (e: "name", value: string): void;
+    (e: "input-valid", value: boolean): void;
+}>();
+
+const props = defineProps<Props>();
+
+const currentForwardFilter = ref(props.forwardFilter);
+const currentReverseFilter = ref(props.reverseFilter);
+const activeElements = ref(props.initialElements);
+const { currentSummary, summaryText, autoPair } = usePairingSummary<HistoryItemSummary>();
+
+const {
+    removeExtensions,
+    hideSourceItems,
+    isElementInvalid,
+    onUpdateHideSourceItems,
+    collectionName,
+    onUpdateCollectionName,
+    onCollectionCreate,
+    showButtonsForModal,
+} = useCollectionCreator(props, emit);
+
+const style = computed(() => {
+    return { width: props.width || "100%", height: props.height || "500px" };
+});
+
+const flatLists = computed(() => props.collectionType.indexOf("paired") == -1);
+
+const isNestedList = computed(() => {
+    return props.collectionType.startsWith("list:list");
+});
+
+const collectionTypeForAutoPairing = computed<"list:paired" | "list:paired_or_unpaired">(() => {
+    return props.collectionType == "list:paired_or_unpaired" ? "list:paired_or_unpaired" : "list:paired";
+});
+
+// Default Column Properties
+const defaultColDef = ref<ColDef>({
+    editable: false,
+    sortable: false,
+    filter: false,
+    resizable: true,
+});
+
+interface RowT {
+    id: string;
+    datasets: GenericPair<HistoryItemSummary> | { unpaired: HistoryItemSummary };
+    identifier: string;
+    outerIdentifier?: string;
+    status: "ok" | "duplicate";
+}
+
+const rowData = ref<RowT[]>([]);
+
+const columnDefs = computed(() => {
+    let datasets: ColDef;
+    if (!flatLists.value) {
+        datasets = {
+            headerName: "Dataset(s)",
+            field: "datasets",
+            editable: false,
+            cellRenderer: "PairedDatasetCellComponent",
+            rowDrag: true,
+        };
+    } else {
+        datasets = {
+            headerName: "Dataset",
+            field: "datasets",
+            editable: false,
+            rowDrag: true,
+            valueFormatter: (p) => {
+                console.log("in valueFormatter...");
+                console.log(p.value.unpaired);
+                return p.value.unpaired.name;
+            },
+        };
+    }
+    const identifierColumns: ColDef[] = [];
+    if (!isNestedList.value) {
+        identifierColumns.push({
+            headerName: "List Identifier",
+            field: "identifier",
+            editable: true,
+            onCellValueChanged: onIdentifierChange,
+        });
+    } else {
+        identifierColumns.push({
+            headerName: "Outer List Identifier",
+            field: "outerIdentifier",
+            editable: true,
+            onCellValueChanged: onIdentifierChange,
+        });
+        identifierColumns.push({
+            headerName: "Inner List Identifier",
+            field: "identifier",
+            editable: true,
+            onCellValueChanged: onIdentifierChange,
+        });
+    }
+    const discard: ColDef = {
+        headerName: "Discard",
+        field: "discard",
+        editable: false,
+        cellRenderer: "CellDiscardComponent",
+        width: 65,
+    };
+    const status: ColDef = {
+        headerName: "Status",
+        field: "status",
+        editable: false,
+        cellRenderer: "CellStatusComponent",
+        width: 65,
+    };
+    return [datasets, ...identifierColumns, discard, status];
+});
+
+function onIdentifierChange(e: NewValueParams) {
+    console.log("checking for duplicates from cell value changed...");
+    nextTick(() => {
+        checkForDuplicates(true);
+    });
+}
+
+function checkForDuplicates(refresh: boolean) {
+    const isDuplicate: Record<string, boolean> = {};
+    let anyDuplicated = false;
+    for (const item of rowData.value) {
+        if (item.identifier in isDuplicate) {
+            isDuplicate[item.identifier] = true;
+            anyDuplicated = true;
+        } else {
+            isDuplicate[item.identifier] = false;
+        }
+    }
+    for (const item of rowData.value) {
+        item.status = isDuplicate[item.identifier] ? "duplicate" : "ok";
+    }
+    if (refresh) {
+        console.log(isDuplicate);
+        _refresh();
+        gridApi.value?.redrawRows();
+    }
+    return anyDuplicated;
+}
+
+function unpairedRow(item: HistoryItemSummary): RowT {
+    return { identifier: item.name || "", datasets: { unpaired: item }, id: item.id, status: "ok" };
+}
+
+function pairedRow(item: GenericPair<HistoryItemSummary>): RowT {
+    return { identifier: item.name, datasets: item, id: item.forward.id, status: "ok" };
+}
+
+function syncPairingToRowData(summary: AutoPairingResult<HistoryItemSummary>, rowDataValue: RowT[]) {
+    if (!flatLists.value) {
+        if (summary) {
+            for (const pair of summary.pairs) {
+                rowDataValue.push(pairedRow(pair));
+            }
+            for (const unpaired of summary.unpaired) {
+                rowDataValue.push(unpairedRow(unpaired));
+            }
+        } else {
+            for (const unpaired of activeElements.value) {
+                rowDataValue.push(unpairedRow(unpaired));
+            }
+        }
+    } else {
+        for (const unpaired of activeElements.value) {
+            rowDataValue.push(unpairedRow(unpaired));
+        }
+    }
+}
+
+function syncRowDataToRowPairing() {
+    rowData.value.splice(0);
+    const summary = currentSummary.value;
+    if (summary) {
+        syncPairingToRowData(summary, rowData.value);
+    }
+}
+
+function initialize() {
+    if (currentForwardFilter.value === undefined) {
+        const summary = autoPairWithCommonFilters(activeElements.value, true);
+        const { forwardFilter, reverseFilter } = summary;
+        if (forwardFilter !== undefined && reverseFilter !== undefined) {
+            currentSummary.value = summary;
+            currentForwardFilter.value = forwardFilter;
+            currentReverseFilter.value = reverseFilter;
+        } else {
+            currentSummary.value = undefined;
+        }
+    } else {
+        autoPair(
+            activeElements.value,
+            currentForwardFilter.value,
+            currentReverseFilter.value || "",
+            removeExtensions.value
+        );
+    }
+    syncRowDataToRowPairing();
+    checkForDuplicates(false);
+}
+
+initialize();
+
+function getRowId(params: GetRowIdParams) {
+    return String(params.data.id);
+}
+
+function addUploadedFiles(files: HDASummary[]) {
+    // Any uploaded files are added to workingElements in _elementsSetUp
+    // The user will have to manually select the files to add them to the pair
+
+    // Check for validity of uploads
+    const addedFiles = [];
+    files.forEach((file) => {
+        const problem = isElementInvalid(file);
+        if (problem) {
+            const invalidMsg = `${file.hid}: ${file.name} ${problem} and ${NOT_VALID_ELEMENT_MSG}`;
+            Toast.error(invalidMsg, localize("Uploaded item invalid for pair"));
+        } else {
+            activeElements.value.push(file);
+            addedFiles.push(file);
+        }
+    });
+    const summary = splitIntoPairedAndUnpaired(
+        files,
+        currentForwardFilter.value || "",
+        currentReverseFilter.value || "",
+        removeExtensions.value
+    );
+    syncPairingToRowData(summary, rowData.value);
+    _refresh();
+}
+
+function updatePairNames() {
+    // TODO: I guess.
+}
+
+function removeExtensionsToggle() {
+    removeExtensions.value = !removeExtensions.value;
+    updatePairNames();
+}
+
+function flatListIdentifiers(): CollectionElementIdentifier[] {
+    const outerIdentifiers: Record<string, RowT[]> = {};
+    for (const row of rowData.value) {
+        const outerIdentifier = row.outerIdentifier || "";
+        if (!(outerIdentifier in outerIdentifiers)) {
+            outerIdentifiers[outerIdentifier] = [];
+        }
+        outerIdentifiers[outerIdentifier]?.push(row);
+    }
+    const listIdentifiers: CollectionElementIdentifier[] = [];
+    for (const outerIdentifier of Object.keys(outerIdentifiers)) {
+        const outerIdentifierElements = [];
+        for (const innerRowData of outerIdentifiers[outerIdentifier] ?? []) {
+            const unpaired = unpairedDataset(innerRowData);
+            const innerElement = {
+                name: innerRowData.identifier,
+                id: unpaired.id as string,
+                src: ("src" in unpaired ? unpaired.src : "hda") as CollectionSourceType,
+            };
+            outerIdentifierElements.push(innerElement);
+        }
+
+        listIdentifiers.push({
+            collection_type: "list",
+            src: "new_collection" as CollectionSourceType,
+            name: outerIdentifier,
+            element_identifiers: outerIdentifierElements,
+        });
+    }
+
+    return listIdentifiers;
+}
+
+function paired_or_paired_list_identifiers(): CollectionElementIdentifier[] {
+    return (rowData.value || []).map((v) => {
+        const isPaired = "forward" in v.datasets;
+        function toElementIdentifierObject(
+            collectionType: "paired" | "paired_or_unpaired",
+            identifiers: CollectionElementIdentifier[]
+        ) {
+            return {
+                collection_type: collectionType,
+                src: "new_collection" as CollectionSourceType,
+                name: v.identifier as string,
+                element_identifiers: identifiers,
+            };
+        }
+        if (isPaired) {
+            const pair = v.datasets as GenericPair<HistoryItemSummary>;
+            const identifiers: CollectionElementIdentifier[] = [
+                {
+                    name: "forward",
+                    id: pair.forward.id as string,
+                    src: ("src" in pair.forward ? pair.forward.src : "hda") as CollectionSourceType,
+                },
+                {
+                    name: "reverse",
+                    id: pair.reverse.id as string,
+                    src: ("src" in pair.reverse ? pair.reverse.src : "hda") as CollectionSourceType,
+                },
+            ];
+            return toElementIdentifierObject(
+                props.collectionType == "list:paired" ? "paired" : "paired_or_unpaired",
+                identifiers
+            );
+        } else {
+            const unpaired = unpairedDataset(v);
+            const identifiers = [
+                {
+                    name: "unpaired",
+                    id: unpaired.id as string,
+                    src: ("src" in unpaired ? unpaired.src : "hda") as CollectionSourceType,
+                },
+            ];
+            return toElementIdentifierObject(
+                props.collectionType == "list:paired" ? "paired" : "paired_or_unpaired",
+                identifiers
+            );
+        }
+    });
+}
+
+function unpairedDataset(row: RowT): HistoryItemSummary {
+    if ("unpaired" in row.datasets) {
+        return row.datasets.unpaired;
+    } else {
+        throw Error("Unknown data encountered, logic bug in Galaxy's client.");
+    }
+}
+
+async function attemptCreate() {
+    if (checkForDuplicates(true)) {
+        return;
+    }
+
+    let listIdentifiers: CollectionElementIdentifier[];
+    if (props.collectionType == "list:list") {
+        listIdentifiers = flatListIdentifiers();
+    } else {
+        listIdentifiers = paired_or_paired_list_identifiers();
+    }
+    let confirmed = false;
+    if (listIdentifiers.length == 0) {
+        confirmed = await confirm("Are you sure you want to create a list with no entries?", {
+            title: "Create an empty list",
+            okTitle: "Create",
+            okVariant: "primary",
+        });
+        if (!confirmed) {
+            return;
+        }
+    }
+
+    onCollectionCreate(props.collectionType, listIdentifiers);
+}
+
+defineExpose({ attemptCreate });
+
+function applyFilters(forwardFilter: string, reverseFilter: string) {
+    currentForwardFilter.value = forwardFilter;
+    currentReverseFilter.value = reverseFilter;
+    showAutoPairing.value = false;
+    initialize();
+}
+
+function onPair(forwardId: string, reverseId: string) {
+    let forwardIndex = -1;
+    let reverseIndex = -1;
+    let forward: HistoryItemSummary | null = null;
+    let reverse: HistoryItemSummary | null = null;
+
+    rowData.value.forEach((row, index) => {
+        if (row.id == forwardId && "unpaired" in row.datasets) {
+            forwardIndex = index;
+            forward = row.datasets.unpaired as HistoryItemSummary;
+        }
+        if (row.id == reverseId && "unpaired" in row.datasets) {
+            reverseIndex = index;
+            reverse = row.datasets.unpaired as HistoryItemSummary;
+        }
+    });
+    if (forwardIndex !== -1 && reverseIndex !== -1 && forward && reverse) {
+        const pair = { forward, reverse, name: "TODO" };
+        if (reverseIndex > forwardIndex) {
+            rowData.value.splice(reverseIndex, 1);
+            rowData.value.splice(forwardIndex, 1);
+            rowData.value.splice(forwardIndex, 0, pairedRow(pair));
+        } else {
+            rowData.value.splice(forwardIndex, 1);
+            rowData.value.splice(reverseIndex, 1);
+            rowData.value.splice(forwardIndex + 1, 0, pairedRow(pair));
+        }
+        _refresh();
+    }
+}
+
+function _refresh() {
+    gridApi.value!.setRowData(rowData.value);
+}
+
+function onUnpair(pair: GenericPair<HistoryItemSummary>) {
+    const targetIndex = onRemove(pair, false) || 0;
+    rowData.value.splice(targetIndex, 0, unpairedRow(pair.forward), unpairedRow(pair.reverse));
+    _refresh();
+}
+
+function onRemove(item: GenericPair<HistoryItemSummary> | { unpaired: HistoryItemSummary }, refresh = true) {
+    let rowId = null as string | null;
+    if ("forward" in item) {
+        rowId = item.forward.id;
+    } else {
+        rowId = item.unpaired.id;
+    }
+    let targetIndex = null;
+    rowData.value.forEach((row, index) => {
+        if (row.id == rowId) {
+            targetIndex = index;
+        }
+    });
+    if (targetIndex !== null) {
+        rowData.value.splice(targetIndex, 1);
+    }
+    if (refresh) {
+        _refresh();
+    }
+    return targetIndex;
+}
+
+function onSwap(pair: GenericPair<HistoryItemSummary>) {
+    const newForward = pair.reverse;
+    pair.reverse = pair.forward;
+    pair.forward = newForward;
+}
+
+function goToAutoPairing() {
+    if (props.mode === "wizard") {
+        emit("go-to-auto-pairing");
+    } else {
+        showAutoPairing.value = true;
+    }
+}
+
+const context = {
+    pinia,
+    onPair,
+    onUnpair,
+    onRemove,
+    onSwap,
+};
+</script>
+
+<script lang="ts">
+// defineExpose should work for exposing PairedDatasetCellComponent to AG Grid
+// but doesn't seem to and it has been reported as an issue with Vue 2.7.
+export default {
+    components: {
+        CollectionCreator,
+        // eslint-disable-next-line vue/no-unused-components
+        PairedDatasetCellComponent,
+        // eslint-disable-next-line vue/no-unused-components
+        CellStatusComponent,
+        // eslint-disable-next-line vue/no-unused-components
+        CellDiscardComponent,
+    },
+};
+</script>
+
+<template>
+    <div>
+        <div v-if="showAutoPairing">
+            <AutoPairing
+                :elements="initialElements"
+                :collection-type="collectionTypeForAutoPairing"
+                :remove-extensions="removeExtensions"
+                :forward-filter="currentForwardFilter"
+                :reverse-filter="currentReverseFilter"
+                :mode="mode"
+                @on-apply="applyFilters"
+                @on-cancel="showAutoPairing = false" />
+        </div>
+        <CollectionCreator
+            v-else
+            :oncancel="() => emit('on-cancel')"
+            :history-id="props.historyId"
+            :hide-source-items="hideSourceItems"
+            render-extensions-toggle
+            :extensions-toggle="removeExtensions"
+            :extensions="extensions"
+            collection-type="collectionType"
+            :no-items="props.initialElements.length == 0 && !props.fromSelection"
+            :show-upload="!fromSelection"
+            :show-buttons="showButtonsForModal"
+            :collection-name="collectionName"
+            @on-update-collection-name="onUpdateCollectionName"
+            @add-uploaded-files="addUploadedFiles"
+            @onUpdateHideSourceItems="onUpdateHideSourceItems"
+            @clicked-create="attemptCreate"
+            @remove-extensions-toggle="removeExtensionsToggle">
+            <template v-slot:help-content>
+                <p>Help Here....</p>
+            </template>
+            <template v-slot:middle-content>
+                <div>
+                    <BRow>
+                        <BCol v-if="!flatLists">
+                            <p>
+                                {{ summaryText }}
+                                If this isn't correct,
+                                <BLink style="font-weight: bold" @click="goToAutoPairing"
+                                    >configure auto-filtering</BLink
+                                >.
+                            </p>
+                        </BCol>
+                    </BRow>
+                    <div :style="style" :class="theme">
+                        <AgGridVue
+                            :row-drag-managed="true"
+                            :get-row-id="getRowId"
+                            :default-col-def="defaultColDef"
+                            :column-defs="columnDefs"
+                            :style="style"
+                            :row-data="rowData"
+                            :context="context"
+                            @gridReady="onGridReady" />
+                    </div>
+                </div>
+            </template>
+        </CollectionCreator>
+    </div>
+</template>
diff --git a/client/src/components/Collections/common/AutoPairing.vue b/client/src/components/Collections/common/AutoPairing.vue
new file mode 100644
index 000000000000..401d1fae909b
--- /dev/null
+++ b/client/src/components/Collections/common/AutoPairing.vue
@@ -0,0 +1,157 @@
+<script setup lang="ts">
+import { BButton } from "bootstrap-vue";
+import { computed, ref } from "vue";
+
+import type { HistoryItemSummary } from "@/api";
+import localize from "@/utils/localization";
+
+import { usePairingSummary } from "./usePairingSummary";
+
+import PairingFilterInputGroup from "./PairingFilterInputGroup.vue";
+
+interface Props {
+    elements: HistoryItemSummary[];
+    collectionType: "list:paired" | "list:paired_or_unpaired";
+    forwardFilter?: string;
+    reverseFilter?: string;
+    removeExtensions: boolean;
+    mode: "wizard" | "modal";
+}
+
+const emit = defineEmits<{
+    (e: "on-apply", forwardFilter: string, reverseFilter: string): void;
+    (e: "on-update", forwardFilter: string, reverseFilter: string): void;
+    (e: "on-cancel"): void;
+}>();
+
+const props = defineProps<Props>();
+
+const currentForwardFilter = ref(props.forwardFilter || "");
+const currentReverseFilter = ref(props.reverseFilter || "");
+const { currentSummary, summaryText, autoPair } = usePairingSummary<HistoryItemSummary>();
+
+function summarize() {
+    autoPair(props.elements, currentForwardFilter.value, currentReverseFilter.value, props.removeExtensions);
+}
+
+summarize();
+
+function onUpdate(forwardFilter: string, reverseFilter: string) {
+    currentForwardFilter.value = forwardFilter;
+    currentReverseFilter.value = reverseFilter;
+    summarize();
+    emit("on-update", currentForwardFilter.value, currentReverseFilter.value);
+}
+
+const applyButtonTitle = computed(() => localize("Apply Auto Pairing"));
+const whereIsTheBuilder = computed(() => {
+    if (props.mode == "modal") {
+        return `back in the main table of this builder after you click '${applyButtonTitle.value}' below'.`;
+    } else {
+        return "in the table on the next step of this wizard";
+    }
+});
+
+function onApply() {
+    emit("on-apply", currentForwardFilter.value, currentReverseFilter.value);
+}
+</script>
+
+<template>
+    <div class="collection-creator">
+        <div class="middle flex-row flex-row-container">
+            <PairingFilterInputGroup
+                :forward-filter="currentForwardFilter"
+                :reverse-filter="currentReverseFilter"
+                @on-update="onUpdate" />
+            <div class="summary-text mt-2">
+                {{ summaryText }}
+            </div>
+            <div class="summary-list-header mt-2">Auto-matched Pairs</div>
+            <div class="summary-list-description">
+                These pairs of datasets have been auto-matched up using the filters above. The will be included as
+                dataset pairs in the final list without additional action.
+            </div>
+            <ol class="summary-list">
+                <li v-for="(pair, index) of currentSummary?.pairs" :key="`paired_${index}`">
+                    <span v-if="index > 0">,</span>
+                    <span class="pair-name">{{ pair.name }}</span> (<span class="direction">FORWARD</span
+                    ><span class="dataset-name">{{ pair.forward.name }}</span> | <span class="direction">REVERSE</span
+                    ><span class="dataset-name">{{ pair.reverse.name }}</span
+                    >)
+                </li>
+            </ol>
+            <div class="summary-list-header mt-2">Un-matched Datasets</div>
+            <div class="summary-list-description">
+                These datasets were not paired automatically. This builder will allow you to match any of pairs of these
+                manually {{ whereIsTheBuilder }}.
+                <span v-if="collectionType == 'list:paired'">
+                    All unmatched datasets will not be included in the final list of paired datasets.
+                </span>
+                <span v-else>
+                    Any of these datasets will be included in the final list if they are not discarded.
+                </span>
+            </div>
+            <ol class="summary-list">
+                <li v-for="(unpairedDataset, index) of currentSummary?.unpaired" :key="`unpaired_${index}`">
+                    <span v-if="index > 0">,</span>
+                    <span class="unpaired-dataset-name dataset-name">{{ unpairedDataset.name }}</span>
+                </li>
+            </ol>
+        </div>
+        <div v-if="mode == 'modal'" class="footer flex-row">
+            <div class="actions vertically-spaced d-flex justify-content-between">
+                <BButton tabindex="-1" @click="emit('on-cancel')">
+                    {{ localize("Cancel") }}
+                </BButton>
+
+                <BButton variant="primary" @click="onApply">
+                    {{ localize("Apply Auto Pairing") }}
+                </BButton>
+            </div>
+        </div>
+    </div>
+</template>
+
+<style lang="scss" scoped>
+.summary-text {
+    font-size: 1rem;
+}
+
+.summary-list {
+    margin-left: 20px;
+
+    li {
+        list-style-type: none;
+        display: inline;
+
+        .direction {
+            font-variant: small-caps;
+            font-weight: normal;
+            color: gray;
+            font-size: 0.8rem;
+            padding-right: 5px;
+            display: none;
+        }
+    }
+}
+
+.summary-list-header {
+    font-size: 1rem;
+    font-weight: bold;
+}
+
+.summary-list-description {
+    font-size: 0.9rem;
+    font-style: italic;
+}
+
+.pair-name {
+    font-weight: bold;
+    font-size: 0.9rem;
+}
+.unpaired-dataset-name {
+    font-weight: bold;
+    font-size: 0.9rem;
+}
+</style>
diff --git a/client/src/components/Collections/common/CellDiscardComponent.vue b/client/src/components/Collections/common/CellDiscardComponent.vue
new file mode 100644
index 000000000000..657febd744ec
--- /dev/null
+++ b/client/src/components/Collections/common/CellDiscardComponent.vue
@@ -0,0 +1,35 @@
+<script lang="ts">
+/* cannot use a setup block and get params injection in Vue 2.7 I think */
+
+import { library } from "@fortawesome/fontawesome-svg-core";
+import { faTimes } from "@fortawesome/free-solid-svg-icons";
+import { FontAwesomeIcon } from "@fortawesome/vue-fontawesome";
+import { type ICellRendererParams } from "ag-grid-community";
+import { defineComponent } from "vue";
+
+library.add(faTimes);
+
+export default defineComponent({
+    components: {
+        FontAwesomeIcon,
+    },
+    data() {
+        return {
+            params: {} as ICellRendererParams,
+        };
+    },
+    computed: {},
+    methods: {
+        onRemove() {
+            this.params.context.onRemove(this.params.data.datasets);
+        },
+    },
+});
+</script>
+<template>
+    <div>
+        <FontAwesomeIcon size="2x" icon="fa-times" @click="onRemove" />
+    </div>
+</template>
+
+<style lang="scss"></style>
diff --git a/client/src/components/Collections/common/CellStatusComponent.vue b/client/src/components/Collections/common/CellStatusComponent.vue
new file mode 100644
index 000000000000..9723d54c162c
--- /dev/null
+++ b/client/src/components/Collections/common/CellStatusComponent.vue
@@ -0,0 +1,69 @@
+<script lang="ts">
+/* cannot use a setup block and get params injection in Vue 2.7 I think */
+
+import { library } from "@fortawesome/fontawesome-svg-core";
+import { faCheck, faExclamationTriangle } from "@fortawesome/free-solid-svg-icons";
+import { FontAwesomeIcon } from "@fortawesome/vue-fontawesome";
+import { type ICellRendererParams } from "ag-grid-community";
+import { BPopover } from "bootstrap-vue";
+import { defineComponent } from "vue";
+
+library.add(faCheck, faExclamationTriangle);
+
+export default defineComponent({
+    components: {
+        BPopover,
+        FontAwesomeIcon,
+    },
+    data() {
+        return {
+            params: {} as ICellRendererParams,
+        };
+    },
+    computed: {
+        id() {
+            return `status-for-identifier-${this.params.data.id}`;
+        },
+        isDuplicate() {
+            return this.params.value == "duplicate";
+        },
+        statusClass() {
+            if (this.isDuplicate) {
+                return "status-warn";
+            } else {
+                return "status-ok";
+            }
+        },
+        icon() {
+            if (this.isDuplicate) {
+                return "fa-exclamation-triangle";
+            } else {
+                return "fa-check";
+            }
+        },
+    },
+    methods: {},
+});
+</script>
+<template>
+    <div :class="statusClass">
+        <FontAwesomeIcon :id="id" size="2x" :icon="icon" />
+        <BPopover
+            :target="id"
+            title="Stats"
+            triggers="hover focus"
+            content="This is some information about the current status."></BPopover>
+    </div>
+</template>
+
+<style lang="scss" scoped>
+@import "theme/blue.scss";
+
+.status-ok {
+    color: $brand-success;
+}
+
+.status-warn {
+    color: $brand-warning;
+}
+</style>
diff --git a/client/src/components/Collections/common/CollectionCreator.vue b/client/src/components/Collections/common/CollectionCreator.vue
index c7230e0a25f5..6ce260823b6a 100644
--- a/client/src/components/Collections/common/CollectionCreator.vue
+++ b/client/src/components/Collections/common/CollectionCreator.vue
@@ -30,6 +30,7 @@ interface Props {
     oncancel: () => void;
     historyId: string;
     hideSourceItems: boolean;
+    name?: string;
     suggestedName?: string;
     renderExtensionsToggle?: boolean;
     extensions?: string[];
@@ -38,6 +39,7 @@ interface Props {
     collectionType?: string;
     showUpload: boolean;
     showButtons?: boolean;
+    collectionName: string;
 }
 
 const props = withDefaults(defineProps<Props>(), {
@@ -49,6 +51,7 @@ const props = withDefaults(defineProps<Props>(), {
 });
 
 const emit = defineEmits<{
+    (e: "on-update-collection-name", name: string): void;
     (e: "remove-extensions-toggle"): void;
     (e: "clicked-create", value: string): void;
     (e: "onUpdateHideSourceItems", value: boolean): void;
@@ -57,13 +60,13 @@ const emit = defineEmits<{
 }>();
 
 const currentTab = ref(Tabs.create);
-const collectionName = ref(props.suggestedName);
 const localHideSourceItems = ref(props.hideSourceItems);
+const name = ref(props.collectionName);
 
 const { listExtensions, extensionsSet, loadExtensions } = useUploadDatatypes();
 
 const validInput = computed(() => {
-    return collectionName.value.length > 0;
+    return props.collectionName.length > 0;
 });
 
 // If there are props.extensions, filter the list of extensions to only include those
@@ -131,12 +134,24 @@ function removeExtensionsToggle() {
 
 loadExtensions();
 
+function updateName(newName: string) {
+    name.value = newName;
+    emit("on-update-collection-name", newName);
+}
+
 watch(
     () => localHideSourceItems.value,
     () => {
         emit("onUpdateHideSourceItems", localHideSourceItems.value);
     }
 );
+
+watch(
+    () => props.collectionName,
+    () => {
+        name.value = props.collectionName;
+    }
+);
 </script>
 
 <template>
@@ -165,8 +180,9 @@ watch(
                                 :extensions-toggle="extensionsToggle"
                                 @remove-extensions-toggle="removeExtensionsToggle" />
                             <CollectionNameInput
-                                v-model="collectionName"
-                                :short-what-is-being-created="shortWhatIsBeingCreated" />
+                                :value="name"
+                                :short-what-is-being-created="shortWhatIsBeingCreated"
+                                @input="updateName" />
                         </div>
                     </div>
 
@@ -203,8 +219,9 @@ watch(
                                     :render-extensions-toggle="renderExtensionsToggle"
                                     :extensions-toggle="extensionsToggle" />
                                 <CollectionNameInput
-                                    v-model="collectionName"
-                                    :short-what-is-being-created="shortWhatIsBeingCreated" />
+                                    :value="collectionName"
+                                    :short-what-is-being-created="shortWhatIsBeingCreated"
+                                    @input="updateName" />
                             </div>
                         </div>
 
diff --git a/client/src/components/Collections/common/CollectionNameInput.vue b/client/src/components/Collections/common/CollectionNameInput.vue
index 7f299899efb9..4d712162eb8f 100644
--- a/client/src/components/Collections/common/CollectionNameInput.vue
+++ b/client/src/components/Collections/common/CollectionNameInput.vue
@@ -37,11 +37,12 @@ watch(name, (newValue) => {
         label-for="collection-name">
         <BFormInput
             id="collection-name"
-            v-model="name"
+            :value="name"
             class="collection-name"
             :placeholder="localize('Enter a name for your new ' + shortWhatIsBeingCreated)"
             size="sm"
             required
-            :state="!name ? false : null" />
+            :state="!name ? false : null"
+            @update="(v) => (name = v)" />
     </BFormGroup>
 </template>
diff --git a/client/src/components/Collections/common/PairedDatasetCellComponent.vue b/client/src/components/Collections/common/PairedDatasetCellComponent.vue
new file mode 100644
index 000000000000..c8d6c808a41a
--- /dev/null
+++ b/client/src/components/Collections/common/PairedDatasetCellComponent.vue
@@ -0,0 +1,151 @@
+<script lang="ts">
+/* cannot use a setup block and get params injection in Vue 2.7 I think */
+
+import { library } from "@fortawesome/fontawesome-svg-core";
+import { faLink, faUndo, faUnlink } from "@fortawesome/free-solid-svg-icons";
+import { FontAwesomeIcon } from "@fortawesome/vue-fontawesome";
+import { type ICellRendererParams } from "ag-grid-community";
+import { defineComponent } from "vue";
+
+import { usePairingDatasetTargetsStore } from "@/stores/collectionBuilderItemsStore";
+
+type StoreType = ReturnType<typeof usePairingDatasetTargetsStore>;
+
+library.add(faLink, faUndo, faUnlink);
+
+export default defineComponent({
+    components: {
+        FontAwesomeIcon,
+    },
+    data() {
+        return {
+            params: {} as ICellRendererParams,
+        };
+    },
+    computed: {
+        isPaired(): boolean {
+            return "forward" in (this.params?.value || {});
+        },
+        dragging(): boolean {
+            return this.pairingTargetsStore().draggedNodeId == this.params.value.unpaired?.id;
+        },
+        dropOver() {
+            return this.pairingTargetsStore().dropTargetId == this.params.value.unpaired?.id;
+        },
+    },
+    methods: {
+        pairingTargetsStore(): StoreType {
+            const pinia = this.params.context.pinia;
+            const pairingTargetsStore = usePairingDatasetTargetsStore(pinia);
+            return pairingTargetsStore;
+        },
+        onSwap() {
+            this.params.context.onSwap(this.params.value);
+        },
+        onDragStart() {
+            this.pairingTargetsStore().startDrag(this.params.value.unpaired?.id);
+        },
+        onDragEnd() {
+            this.pairingTargetsStore().endDrag();
+        },
+        onDragEnter() {
+            this.pairingTargetsStore().setDropTarget(this.params.value.unpaired?.id);
+        },
+        onDragLeave() {
+            this.pairingTargetsStore().setDropTarget(null);
+        },
+        onUnpair() {
+            this.params.context.onUnpair(this.params.value);
+        },
+        onDrop() {
+            const pairingTargetsStore = this.pairingTargetsStore();
+            const draggedNodeId = pairingTargetsStore.draggedNodeId;
+            const dropTargetId = this.params.value.unpaired?.id;
+
+            if (draggedNodeId && draggedNodeId !== dropTargetId) {
+                this.params.context.onPair(dropTargetId, draggedNodeId);
+            }
+
+            pairingTargetsStore.endDrag(); // Clear drag state
+        },
+    },
+});
+</script>
+<template>
+    <div>
+        <div v-if="isPaired" class="paired-datasets-cell">
+            <FontAwesomeIcon size="2x" icon="fa-undo" class="paired-action-icon" @click="onSwap" />
+            <FontAwesomeIcon size="2x" icon="fa-unlink" class="paired-action-icon" @click="onUnpair" />
+            <div class="text-container">
+                <span><span class="direction">FORWARD</span> {{ params.value.forward.name }}</span>
+                <span><span class="direction">REVERSE</span> {{ params.value.reverse.name }}</span>
+            </div>
+        </div>
+        <div v-else class="paired-datasets-cell">
+            <div
+                class="icon-wrapper"
+                :class="{ dragging: dragging, 'drop-target': dropOver }"
+                :draggable="true"
+                @dragstart="onDragStart"
+                @dragover.prevent
+                @dragenter="onDragEnter"
+                @dragleave="onDragLeave"
+                @dragend="onDragEnd"
+                @drop="onDrop">
+                <FontAwesomeIcon size="2x" icon="fa-link" class="paired-action-icon" :class="{ dragging: dragging }" />
+            </div>
+            <div class="text-container">
+                <div><span class="direction">UNPAIRED</span></div>
+                <div>{{ params.value.unpaired.name }}</div>
+            </div>
+        </div>
+    </div>
+</template>
+
+<style lang="scss">
+@import "theme/blue.scss";
+
+.paired-datasets-cell {
+    display: flex;
+    align-items: center; /* Vertically center icon and text */
+    height: 100%; /* Ensure it spans the full cell height */
+    padding: 5px; /* Add padding for spacing */
+    box-sizing: border-box;
+    font-weight: bold;
+}
+
+.paired-datasets-cell .paired-action-icon {
+    margin-right: 10px;
+}
+
+.paired-datasets-cell .direction {
+    font-weight: normal;
+    color: gray;
+}
+
+.paired-datasets-cell .icon-wrapper {
+    display: flex; /* Ensure the wrapper uses flex layout */
+    align-items: center; /* Center the icon within the wrapper */
+    justify-content: center; /* Center horizontally for safety */
+    margin: 0; /* Remove any default margins */
+    padding: 0; /* Remove any default padding */
+}
+
+.paired-datasets-cell .dragging {
+    color: $brand-primary;
+}
+
+.paired-datasets-cell .drop-target {
+    color: $brand-success;
+}
+
+.paired-datasets-cell .text-container {
+    display: flex;
+    flex-direction: column; /* Stack lines vertically */
+    justify-content: center; /* Center the text vertically within its area */
+    line-height: 1.2; /* Adjust spacing between lines */
+    overflow: hidden; /* Prevent overflow if text is too long */
+    white-space: nowrap; /* Prevent wrapping if needed */
+    text-overflow: ellipsis; /* Add ellipsis for long text */
+}
+</style>
diff --git a/client/src/components/Collections/common/PairingFilterInputGroup.vue b/client/src/components/Collections/common/PairingFilterInputGroup.vue
new file mode 100644
index 000000000000..632d60ad7f97
--- /dev/null
+++ b/client/src/components/Collections/common/PairingFilterInputGroup.vue
@@ -0,0 +1,65 @@
+<script setup lang="ts">
+import { BDropdown, BDropdownItem, BFormInput, BInputGroup } from "bootstrap-vue";
+import { ref, watch } from "vue";
+
+import { COMMON_FILTERS } from "@/components/Collections/pairing";
+
+interface Props {
+    forwardFilter: string;
+    reverseFilter: string;
+}
+
+const emit = defineEmits<{
+    (e: "on-update", forwardFilter: string, reverseFilter: string): void;
+}>();
+
+function update(forward: string, reverse: string) {
+    emit("on-update", forward, reverse);
+}
+
+const props = defineProps<Props>();
+
+const currentForwardFilter = ref(props.forwardFilter);
+const currentReverseFilter = ref(props.reverseFilter);
+
+watch(
+    () => props.forwardFilter,
+    () => {
+        currentForwardFilter.value = props.forwardFilter;
+    }
+);
+watch(
+    () => props.reverseFilter,
+    () => {
+        currentReverseFilter.value = props.reverseFilter;
+    }
+);
+
+function resync() {
+    emit("on-update", currentForwardFilter.value, currentReverseFilter.value);
+}
+
+watch(currentForwardFilter, resync);
+watch(currentForwardFilter, resync);
+</script>
+
+<template>
+    <BInputGroup size="lg">
+        <template v-slot:prepend>
+            <BDropdown text="Filters" variant="info">
+                <BDropdownItem
+                    v-for="([forward, reverse], index) of COMMON_FILTERS"
+                    :key="index"
+                    @click="update(forward, reverse)">
+                    {{ forward }} / {{ reverse }}
+                </BDropdownItem>
+                <BDropdownItem @click="update('', '')">
+                    <i>Clear All Filtering</i>
+                </BDropdownItem>
+            </BDropdown>
+        </template>
+
+        <BFormInput v-model="currentForwardFilter"></BFormInput>
+        <BFormInput v-model="currentReverseFilter"></BFormInput>
+    </BInputGroup>
+</template>
diff --git a/client/src/components/Collections/common/useCollectionCreation.ts b/client/src/components/Collections/common/useCollectionCreation.ts
new file mode 100644
index 000000000000..49e96819e804
--- /dev/null
+++ b/client/src/components/Collections/common/useCollectionCreation.ts
@@ -0,0 +1,33 @@
+import { storeToRefs } from "pinia";
+
+import {
+    type CollectionElementIdentifiers,
+    createCollectionPayload,
+    type CreateNewCollectionPayload,
+} from "@/api/datasetCollections";
+import { useHistoryStore } from "@/stores/historyStore";
+
+export function useCollectionCreation() {
+    const historyStore = useHistoryStore();
+    const { currentHistoryId } = storeToRefs(historyStore);
+
+    function createPayload(
+        name: string,
+        collection_type: string,
+        element_identifiers: CollectionElementIdentifiers,
+        hide_source_items: boolean
+    ): CreateNewCollectionPayload {
+        return createCollectionPayload({
+            name: name,
+            collection_type: collection_type,
+            element_identifiers: element_identifiers,
+            hide_source_items: hide_source_items,
+            history_id: currentHistoryId.value || "current",
+        });
+    }
+
+    return {
+        currentHistoryId,
+        createPayload,
+    };
+}
diff --git a/client/src/components/Collections/common/useCollectionCreator.ts b/client/src/components/Collections/common/useCollectionCreator.ts
index 2025601b2ba0..d2f76d0f932e 100644
--- a/client/src/components/Collections/common/useCollectionCreator.ts
+++ b/client/src/components/Collections/common/useCollectionCreator.ts
@@ -1,21 +1,68 @@
-import { ref } from "vue";
+import { computed, ref, watch } from "vue";
 
 import { type HistoryItemSummary } from "@/api";
+import { type CollectionElementIdentifiers, type CreateNewCollectionPayload } from "@/api/datasetCollections";
 import STATES from "@/mvc/dataset/states";
 import localize from "@/utils/localization";
 
+import { useCollectionCreation } from "./useCollectionCreation";
 import { useExtensionFiltering } from "./useExtensionFilter";
 
+export type Mode = "modal" | "wizard";
+
 interface CommonCollectionBuilderProps {
     extensions?: string[];
     defaultHideSourceItems?: boolean;
+    mode: Mode;
 }
 
-export function useCollectionCreator(props: CommonCollectionBuilderProps) {
+type EmitsName = {
+    (e: "name", value: string): void;
+    (e: "input-valid", value: boolean): void;
+    (e: "on-create", options: CreateNewCollectionPayload): void;
+};
+
+export type SupportedPairedOrPairedBuilderCollectionTypes =
+    | "list:paired"
+    | "list:paired_or_unpaired"
+    | "list:list"
+    | "list:list:paired";
+
+export function useCollectionCreator(props: CommonCollectionBuilderProps, emit?: EmitsName) {
     const removeExtensions = ref(true);
     const hideSourceItems = ref(props.defaultHideSourceItems || false);
+    const collectionName = ref("");
+
+    const showButtonsForModal = computed(() => {
+        return props.mode === "modal";
+    });
+
+    function onUpdateCollectionName(name: string) {
+        collectionName.value = name;
+    }
+
+    const validInput = computed(() => !!collectionName.value);
+
+    if (emit) {
+        watch(collectionName, (newValue) => {
+            console.log("name upated...");
+            emit("name", newValue);
+        });
+        watch(validInput, (newValue) => {
+            console.log("emitting...");
+            emit("input-valid", newValue);
+        });
+    }
 
     const { hasInvalidExtension } = useExtensionFiltering(props);
+    const { createPayload } = useCollectionCreation();
+
+    function onCollectionCreate(collectionType: string, elementIdentifiers: CollectionElementIdentifiers) {
+        const payload = createPayload(collectionName.value, collectionType, elementIdentifiers, hideSourceItems.value);
+        if (emit) {
+            emit("on-create", payload);
+        }
+    }
 
     function onUpdateHideSourceItems(newHideSourceItems: boolean) {
         hideSourceItems.value = newHideSourceItems;
@@ -44,5 +91,16 @@ export function useCollectionCreator(props: CommonCollectionBuilderProps) {
         return null;
     }
 
-    return { removeExtensions, hideSourceItems, hasInvalidExtension, onUpdateHideSourceItems, isElementInvalid };
+    return {
+        collectionName,
+        removeExtensions,
+        hideSourceItems,
+        hasInvalidExtension,
+        onUpdateHideSourceItems,
+        onUpdateCollectionName,
+        isElementInvalid,
+        validInput,
+        onCollectionCreate,
+        showButtonsForModal,
+    };
 }
diff --git a/client/src/components/Collections/common/usePairingSummary.ts b/client/src/components/Collections/common/usePairingSummary.ts
new file mode 100644
index 000000000000..099439be3190
--- /dev/null
+++ b/client/src/components/Collections/common/usePairingSummary.ts
@@ -0,0 +1,33 @@
+import { computed, ref } from "vue";
+
+import { type AutoPairingResult, type HasName, splitIntoPairedAndUnpaired } from "@/components/Collections/pairing";
+
+export function usePairingSummary<T extends HasName>() {
+    const currentSummary = ref<AutoPairingResult<T>>();
+
+    const summaryText = computed(() => {
+        const summary = currentSummary.value;
+        if (summary) {
+            const numMatchedText = `Auto-matched ${summary.pairs.length} pair(s) of datasets from target datasets.`;
+            const numUnmatched = summary.unpaired.length;
+            let numUnmatchedText = "";
+            if (numUnmatched > 0) {
+                numUnmatchedText = `${numUnmatched} dataset(s) were not paired and will not be included in the resulting list of pairs.`;
+            }
+            return `${numMatchedText} ${numUnmatchedText}`;
+        } else {
+            return "Auto-pairing...";
+        }
+    });
+
+    function autoPair(elements: T[], forwardFilter: string, reverseFilter: string, willRemoveExtensions: boolean) {
+        const summary = splitIntoPairedAndUnpaired(elements, forwardFilter, reverseFilter, willRemoveExtensions);
+        currentSummary.value = summary;
+    }
+
+    return {
+        currentSummary,
+        summaryText,
+        autoPair,
+    };
+}
diff --git a/client/src/components/Collections/pairing.test.ts b/client/src/components/Collections/pairing.test.ts
index 6f39297688e6..e6494a6e5468 100644
--- a/client/src/components/Collections/pairing.test.ts
+++ b/client/src/components/Collections/pairing.test.ts
@@ -1,4 +1,10 @@
-import { autoDetectPairs, autoPairWithCommonFilters, guessInitialFilterType, guessNameForPair } from "./pairing";
+import {
+    autoDetectPairs,
+    autoPairWithCommonFilters,
+    guessInitialFilterType,
+    guessNameForPair,
+    splitIntoPairedAndUnpaired,
+} from "./pairing";
 
 function mockDataset(name: string) {
     return { name };
@@ -13,6 +19,13 @@ const F2 = mockDataset("foo_2.fastq");
 const B1 = mockDataset("bar_1.fastq");
 const B2 = mockDataset("bar_2.fastq");
 
+const L1 = mockDataset("thisisalongmatchforpercentbasedtests_thisisthened.fastq");
+const L2 = mockDataset("thisisalongmatchforpercentbasedtests_1thisisthened.fastq");
+
+// These two matched on empty filters in playing around with the GUI and that confused me. -John
+const E1 = mockDataset("cool11_fastq_2.fq");
+const E2 = mockDataset("cool11_fastq_1.fq");
+
 describe("guessInitialFilterType", () => {
     test("should return 'illumina' when illumina matches are most common", () => {
         const elements = [
@@ -96,3 +109,11 @@ describe("autoPairWithCommonFilters", () => {
         expect(summary.unpaired[0]?.name).toEqual("moo_1.fastq");
     });
 });
+
+describe("splitIntoPairedAndUnpaired", () => {
+    test("if filters are empty, there should be not matching", () => {
+        // we cannot deduce forward from reverse
+        const summary = splitIntoPairedAndUnpaired([B1, M1, F1, F2, B2, L1, L2, E1, E2], "", "", true);
+        expect(summary.pairs).toHaveLength(0);
+    });
+});
diff --git a/client/src/components/Collections/pairing.ts b/client/src/components/Collections/pairing.ts
index a27fb0561b9a..fe35301f2bf2 100644
--- a/client/src/components/Collections/pairing.ts
+++ b/client/src/components/Collections/pairing.ts
@@ -8,7 +8,7 @@ export const COMMON_FILTERS = {
 export type CommonFiltersType = keyof typeof COMMON_FILTERS;
 export const DEFAULT_FILTER: CommonFiltersType = "illumina";
 
-interface HasName {
+export interface HasName {
     name: string | null;
 }
 
@@ -348,12 +348,22 @@ export function autoDetectPairs<T extends HasName>(
     return paired;
 }
 
+export type AutoPairingResult<T extends HasName> = {
+    pairs: GenericPair<T>[];
+    unpaired: T[];
+    forwardFilter: string;
+    reverseFilter: string;
+};
+
 export function splitIntoPairedAndUnpaired<T extends HasName>(
     elements: T[],
     forwardFilter: string,
     reverseFilter: string,
     willRemoveExtensions: boolean
-) {
+): AutoPairingResult<T> {
+    if (forwardFilter === "" || reverseFilter === "") {
+        return { pairs: [], unpaired: elements.slice(), forwardFilter, reverseFilter };
+    }
     const [forwardEls, reverseEls] = splitElementsByFilter(elements, forwardFilter, reverseFilter);
     const pairs = autoDetectPairs(forwardEls, reverseEls, forwardFilter, reverseFilter, willRemoveExtensions);
     const unpaired = elements.slice();
@@ -367,7 +377,7 @@ export function splitIntoPairedAndUnpaired<T extends HasName>(
             unpaired.splice(indexR, 1);
         }
     }
-    return { pairs: pairs, unpaired: unpaired };
+    return { pairs: pairs, unpaired: unpaired, forwardFilter, reverseFilter };
 }
 
 export function autoPairWithCommonFilters<T extends HasName>(elements: T[], willRemoveExtensions: boolean) {
diff --git a/client/src/components/History/Content/Collection/CollectionDescription.vue b/client/src/components/History/Content/Collection/CollectionDescription.vue
index af91aeef5a9e..13e33e5811c0 100644
--- a/client/src/components/History/Content/Collection/CollectionDescription.vue
+++ b/client/src/components/History/Content/Collection/CollectionDescription.vue
@@ -20,12 +20,14 @@ const props = withDefaults(defineProps<Props>(), {
 const labels = new Map([
     ["list", "list"],
     ["list:paired", "list"],
-    ["list:list", "list"],
+    ["list:paired_or_unpaired", "list"],
+    ["list:list", "nested list"],
     ["paired", "pair"],
 ]);
 
 const collectionLabel = computed(() => {
-    return labels.get(props.collectionType) ?? "nested list";
+    const collectionType = props.collectionType;
+    return labels.get(collectionType) ?? "nested list";
 });
 const hasSingleElement = computed(() => {
     return props.elementCount === 1;
@@ -43,6 +45,20 @@ const pluralizedItem = computed(() => {
     if (props.collectionType === "list:paired") {
         return pluralize("pair");
     }
+    if (props.collectionType === "list:paired_or_unpaired") {
+        if (!hasSingleElement.value) {
+            return "paired and unpaired datasets";
+        } else {
+            return "dataset pair or unpaired dataset";
+        }
+    }
+    if (props.collectionType === "paired_or_unpaired") {
+        if (!hasSingleElement.value) {
+            return "dataset pair";
+        } else {
+            return "unpaired dataset";
+        }
+    }
     if (!labels.has(props.collectionType)) {
         return pluralize("dataset collection");
     }
@@ -56,7 +72,10 @@ function pluralize(word: string) {
 
 <template>
     <div>
-        <span class="description mt-1 mb-1">
+        <span v-if="collectionType == 'paired_or_unpaired'" class="description mt-1 mb-1">
+            a <b>{{ homogeneousDatatype }}</b> {{ pluralizedItem }}
+        </span>
+        <span v-else class="description mt-1 mb-1">
             a {{ collectionLabel }} with {{ elementCount || 0 }}<b>{{ homogeneousDatatype }}</b> {{ pluralizedItem }}
         </span>
 
diff --git a/client/src/components/History/CurrentHistory/HistoryOperations/SelectionOperations.vue b/client/src/components/History/CurrentHistory/HistoryOperations/SelectionOperations.vue
index 5546e71a1df8..658034a1d50c 100644
--- a/client/src/components/History/CurrentHistory/HistoryOperations/SelectionOperations.vue
+++ b/client/src/components/History/CurrentHistory/HistoryOperations/SelectionOperations.vue
@@ -58,16 +58,34 @@
                 <span v-localize>Remove tags</span>
             </b-dropdown-item>
             <b-dropdown-divider v-if="showBuildOptions" />
-            <b-dropdown-item v-if="showBuildOptions" data-description="build list" @click="listWizard">
-                <span v-localize>Build a List</span>
+            <b-dropdown-item v-if="showBuildOptions" data-description="auto build list" @click="listWizard(false)">
+                <span v-localize>Auto Build List</span>
+            </b-dropdown-item>
+            <b-dropdown-item v-if="showBuildOptions" data-description="advanced build list" @click="listWizard(true)">
+                <span v-localize>Advanced Build List</span>
             </b-dropdown-item>
             <b-dropdown-group header-classes="subtle-header" header="Advanced">
                 <b-dropdown-item v-if="showBuildOptions" data-description="build list" @click="buildDatasetList">
                     <span v-localize>Build Dataset List</span>
                 </b-dropdown-item>
-                <b-dropdown-item v-if="showBuildOptions" data-description="build list of pairs" @click="buildListOfPairs">
+                <b-dropdown-item
+                    v-if="showBuildOptions"
+                    data-description="build list of pairs"
+                    @click="buildListOfPairs">
                     <span v-localize>Build List of Dataset Pairs</span>
                 </b-dropdown-item>
+                <b-dropdown-item
+                    v-if="showBuildOptions"
+                    data-description="build list of paires 2"
+                    @click="buildListOfPairsV2">
+                    <span v-localize>Build List of Dataset Pairs (v2)</span>
+                </b-dropdown-item>
+                <b-dropdown-item
+                    v-if="showBuildOptions"
+                    data-description="build list of paired_or_unpaired"
+                    @click="buildListOfMixedPaired">
+                    <span v-localize>Build List with Optional Pairing</span>
+                </b-dropdown-item>
                 <b-dropdown-item
                     v-if="showBuildOptions"
                     data-description="build collection from rules"
@@ -150,6 +168,7 @@
             :collection-type="collectionModalType"
             :filter-text="filterText"
             :selected-items="collectionSelection"
+            :use-beta-components="useBetaComponents"
             :show-modal.sync="collectionModalShow"
             hide-modal-on-create
             default-hide-source-items
@@ -211,6 +230,7 @@ export default {
             selectedDbKey: { id: "?", text: "unspecified (?)" },
             selectedDatatype: { id: "auto", text: "Auto-detect" },
             selectedTags: [],
+            useBetaComponents: false,
         };
     },
     computed: {
@@ -312,11 +332,11 @@ export default {
         },
     },
     methods: {
-        listWizard() {
+        listWizard(advanced) {
             const { setSelectedItems } = useCollectionBuilderItemSelection();
             const selection = Array.from(this.contentSelection.values());
             setSelectedItems(selection);
-            this.$router.push({ path: "/collection/new_list" });
+            this.$router.push({ path: "/collection/new_list?advanced=true" });
         },
         // Selected content manipulation, hide/show/delete/purge
         hideSelected() {
@@ -402,6 +422,18 @@ export default {
         buildListOfPairs() {
             this.collectionModalType = "list:paired";
             this.collectionSelection = Array.from(this.contentSelection.values());
+            this.useBetaComponents = false;
+            this.collectionModalShow = true;
+        },
+        buildListOfPairsV2() {
+            this.collectionModalType = "list:paired";
+            this.collectionSelection = Array.from(this.contentSelection.values());
+            this.useBetaComponents = true;
+            this.collectionModalShow = true;
+        },
+        buildListOfMixedPaired() {
+            this.collectionModalType = "list:paired_or_unpaired";
+            this.collectionSelection = Array.from(this.contentSelection.values());
             this.collectionModalShow = true;
         },
         createdCollection(collection) {
diff --git a/client/src/components/History/model/queries.ts b/client/src/components/History/model/queries.ts
index 21ee64e4ddb9..b2f76cb1a47a 100644
--- a/client/src/components/History/model/queries.ts
+++ b/client/src/components/History/model/queries.ts
@@ -1,5 +1,5 @@
 import { type components, GalaxyApi, type HistoryItemSummary, type HistorySummary } from "@/api";
-import { createHistoryDatasetCollectionInstance } from "@/api/datasetCollections";
+import { createHistoryDatasetCollectionInstanceSimple } from "@/api/datasetCollections";
 import { rethrowSimple } from "@/utils/simple-error";
 
 type BulkOperation = components["schemas"]["HistoryContentItemOperation"];
@@ -92,5 +92,5 @@ export async function createDatasetCollection(history: HistorySummary, inputs =
         history_id: history.id,
     };
     const payload = Object.assign({}, defaults, inputs);
-    return createHistoryDatasetCollectionInstance(payload);
+    return createHistoryDatasetCollectionInstanceSimple(payload);
 }
diff --git a/client/src/components/RuleCollectionBuilder.vue b/client/src/components/RuleCollectionBuilder.vue
index ff2ecdf7ec1a..f506fa5179eb 100644
--- a/client/src/components/RuleCollectionBuilder.vue
+++ b/client/src/components/RuleCollectionBuilder.vue
@@ -512,7 +512,7 @@
                     </div>
                 </div>
             </template>
-            <b-row class="mx-auto">
+            <b-row v-if="mode == 'modal'" class="mx-auto">
                 <b-button
                     :help="titleCancel"
                     class="creator-cancel-btn rule-btn-cancel"
@@ -690,6 +690,11 @@ export default {
             required: false,
             default: "aggrid",
         },
+        mode: {
+            type: String,
+            required: false,
+            default: "modal", // set to wizard to use embedded formatting
+        },
     },
     data: function () {
         let orientation = "vertical";
@@ -1172,6 +1177,10 @@ export default {
                 }
             }
         },
+        validInput: function (newState) {
+            console.log("watching validInput....");
+            this.$emit("validInput", newState);
+        },
     },
     created() {
         if (this.elementsType !== "collection_contents") {
@@ -1415,6 +1424,9 @@ export default {
                 });
             }
         },
+        attemptCreate() {
+            this.createCollection();
+        },
         createCollection() {
             const asJson = {
                 rules: this.rules,
@@ -1432,15 +1444,27 @@ export default {
             if (this.elementsType == "datasets" || this.elementsType == "library_datasets") {
                 const elements = this.creationElementsFromDatasets();
                 if (this.state !== "error") {
-                    const deferreds = Object.entries(elements).map(([name, els]) => {
-                        // This looks like a promise but it is not one because creationFn and
-                        // oncreate are references to function from the backbone models which means
-                        // they are expecting their arguments in a different order. So, looks like,
-                        // jQuery.Deferred and therefore jQuery are still dependencies
-                        return this.creationFn(els, collectionType, name, hideSourceItems).then(this.oncreate);
-                    });
-                    const promises = deferreds.map(deferredToPromise);
-                    return Promise.all(promises).catch((err) => this.renderFetchError(err));
+                    if (this.creationFn) {
+                        const deferreds = Object.entries(elements).map(([name, els]) => {
+                            // This looks like a promise but it is not one because creationFn and
+                            // oncreate are references to function from the backbone models which means
+                            // they are expecting their arguments in a different order. So, looks like,
+                            // jQuery.Deferred and therefore jQuery are still dependencies
+                            return this.creationFn(els, collectionType, name, hideSourceItems).then(this.oncreate);
+                        });
+                        const promises = deferreds.map(deferredToPromise);
+                        return Promise.all(promises).catch((err) => this.renderFetchError(err));
+                    } else {
+                        const request = Object.entries(elements).map(([name, els]) => {
+                            return {
+                                name,
+                                elementIdentifiers: els,
+                                collectionType: collectionType,
+                                hideSourceItems,
+                            };
+                        });
+                        this.$emit("onAttemptCreate", request);
+                    }
                 }
             } else if (this.elementsType == "collection_contents") {
                 this.resetSource();
diff --git a/client/src/components/Workflow/Editor/modules/collectionTypeDescription.ts b/client/src/components/Workflow/Editor/modules/collectionTypeDescription.ts
index cc48c2a69117..3118b3c26690 100644
--- a/client/src/components/Workflow/Editor/modules/collectionTypeDescription.ts
+++ b/client/src/components/Workflow/Editor/modules/collectionTypeDescription.ts
@@ -85,19 +85,44 @@ export class CollectionTypeDescription implements CollectionTypeDescriptor {
         return new CollectionTypeDescription(`${this.collectionType}:${other.collectionType}`);
     }
     canMatch(other: CollectionTypeDescriptor) {
+        const otherCollectionType = other.collectionType;
         if (other === NULL_COLLECTION_TYPE_DESCRIPTION) {
             return false;
         }
         if (other === ANY_COLLECTION_TYPE_DESCRIPTION) {
             return true;
         }
-        return other.collectionType == this.collectionType;
+        if (otherCollectionType === "paired" && this.collectionType == "paired_or_unpaired") {
+            return true;
+        }
+        if (otherCollectionType === "paired_or_unpaired" && this.collectionType == "paired") {
+            return true;
+        }
+        if (this.collectionType.endsWith(":paired_or_unpaired")) {
+            const asPlainList = this.collectionType.slice(0, -":paired_or_unpaired".length);
+            if (otherCollectionType === asPlainList) {
+                return true;
+            }
+            const asPairedList = `${asPlainList}:paired`;
+            if (otherCollectionType === asPairedList) {
+                return true;
+            }
+        }
+        return otherCollectionType == this.collectionType;
     }
     canMapOver(other: CollectionTypeDescriptor) {
         if (!other.collectionType || other.collectionType === "any") {
             return false;
         }
         if (this.rank <= other.rank) {
+            if (other.collectionType == "paired_or_unpaired") {
+                // this can be thought of as a subcollection of anything except a pair
+                // since it would match a pair exactly
+                return this.collectionType != "paired";
+            }
+            if (this.rank == other.rank) {
+                console.log("skipping over this because may be equal rank...");
+            }
             // Cannot map over self...
             return false;
         }
@@ -105,11 +130,17 @@ export class CollectionTypeDescription implements CollectionTypeDescriptor {
         return this._endsWith(this.collectionType, requiredSuffix);
     }
     effectiveMapOver(other: CollectionTypeDescriptor): CollectionTypeDescriptor {
+        const thisCollectionType = this.collectionType;
         if (other.collectionType && this.canMapOver(other)) {
             const otherCollectionType = other.collectionType;
-            const effectiveCollectionType = this.collectionType.substring(
+            if (otherCollectionType == "paired_or_unpaired") {
+                if (thisCollectionType == "list") {
+                    return new CollectionTypeDescription("list");
+                }
+            }
+            const effectiveCollectionType = thisCollectionType.substring(
                 0,
-                this.collectionType.length - otherCollectionType.length - 1
+                thisCollectionType.length - otherCollectionType.length - 1
             );
             return new CollectionTypeDescription(effectiveCollectionType);
         }
diff --git a/client/src/components/Workflow/Editor/modules/terminals.test.ts b/client/src/components/Workflow/Editor/modules/terminals.test.ts
index e8213e49a2db..4d184a081568 100644
--- a/client/src/components/Workflow/Editor/modules/terminals.test.ts
+++ b/client/src/components/Workflow/Editor/modules/terminals.test.ts
@@ -209,6 +209,72 @@ describe("canAccept", () => {
         expect(dataIn.canAccept(collectionOut).canAccept).toBe(true);
         expect(dataIn.mapOver).toEqual(NULL_COLLECTION_TYPE_DESCRIPTION);
     });
+    it("accepts paired_or_unpaired data -> data connection", () => {
+        const collectionOut = terminals["paired_or_unpaired input"]!["output"] as OutputCollectionTerminal;
+        const dataIn = terminals["simple data"]!["input"] as InputTerminal;
+        expect(dataIn.mapOver).toBe(NULL_COLLECTION_TYPE_DESCRIPTION);
+        expect(dataIn.canAccept(collectionOut).canAccept).toBe(true);
+        dataIn.connect(collectionOut);
+        expect(dataIn.mapOver).toEqual({ collectionType: "paired_or_unpaired", isCollection: true, rank: 1 });
+        expect(dataIn.canAccept(collectionOut).canAccept).toBe(false);
+        dataIn.disconnect(collectionOut);
+        expect(dataIn.canAccept(collectionOut).canAccept).toBe(true);
+        expect(dataIn.mapOver).toEqual(NULL_COLLECTION_TYPE_DESCRIPTION);
+    });
+    it("accepts list:paired_or_unpaired data -> data connection", () => {
+        const collectionOut = terminals["list:paired_or_unpaired input"]!["output"] as OutputCollectionTerminal;
+        const dataIn = terminals["simple data"]!["input"] as InputTerminal;
+        expect(dataIn.mapOver).toBe(NULL_COLLECTION_TYPE_DESCRIPTION);
+        expect(dataIn.canAccept(collectionOut).canAccept).toBe(true);
+        dataIn.connect(collectionOut);
+        expect(dataIn.mapOver).toEqual({ collectionType: "list:paired_or_unpaired", isCollection: true, rank: 2 });
+        expect(dataIn.canAccept(collectionOut).canAccept).toBe(false);
+        dataIn.disconnect(collectionOut);
+        expect(dataIn.canAccept(collectionOut).canAccept).toBe(true);
+        expect(dataIn.mapOver).toEqual(NULL_COLLECTION_TYPE_DESCRIPTION);
+    });
+    it("accepts paired_or_unpaired data -> paired_or_unpaired connection", () => {
+        const collectionOut = terminals["paired_or_unpaired input"]!["output"] as OutputCollectionTerminal;
+        const dataIn = terminals["paired_or_unpaired collection input"]!["f1"] as InputTerminal;
+        expect(dataIn.mapOver).toBe(NULL_COLLECTION_TYPE_DESCRIPTION);
+        expect(dataIn.canAccept(collectionOut).canAccept).toBe(true);
+        dataIn.connect(collectionOut);
+        expect(dataIn.mapOver).toBe(NULL_COLLECTION_TYPE_DESCRIPTION);
+        expect(dataIn.canAccept(collectionOut).canAccept).toBe(false);
+        dataIn.disconnect(collectionOut);
+        expect(dataIn.canAccept(collectionOut).canAccept).toBe(true);
+        expect(dataIn.mapOver).toEqual(NULL_COLLECTION_TYPE_DESCRIPTION);
+    });
+    it("accepts list -> paired_or_unpaired connection", () => {
+        const collectionOut = terminals["list input"]!["output"] as OutputCollectionTerminal;
+        const dataIn = terminals["paired_or_unpaired collection input"]!["f1"] as InputTerminal;
+        expect(dataIn.mapOver).toBe(NULL_COLLECTION_TYPE_DESCRIPTION);
+        expect(dataIn.canAccept(collectionOut).canAccept).toBe(true);
+        dataIn.connect(collectionOut);
+        expect(dataIn.mapOver).toEqual({ collectionType: "list", isCollection: true, rank: 1 });
+        expect(dataIn.canAccept(collectionOut).canAccept).toBe(false);
+        expect(dataIn.canAccept(collectionOut).reason).toBe(
+            "Input already filled with another connection, delete it before connecting another output."
+        );
+        dataIn.disconnect(collectionOut);
+        expect(dataIn.canAccept(collectionOut).canAccept).toBe(true);
+        expect(dataIn.mapOver).toEqual(NULL_COLLECTION_TYPE_DESCRIPTION);
+    });
+    it("accepts paired -> paired_or_unpaired connection", () => {
+        const collectionOut = terminals["paired input"]!["output"] as OutputCollectionTerminal;
+        const dataIn = terminals["paired_or_unpaired collection input"]!["f1"] as InputTerminal;
+        expect(dataIn.mapOver).toBe(NULL_COLLECTION_TYPE_DESCRIPTION);
+        expect(dataIn.canAccept(collectionOut).canAccept).toBe(true);
+        dataIn.connect(collectionOut);
+        expect(dataIn.mapOver).toBe(NULL_COLLECTION_TYPE_DESCRIPTION);
+        expect(dataIn.canAccept(collectionOut).canAccept).toBe(false);
+        expect(dataIn.canAccept(collectionOut).reason).toBe(
+            "Input already filled with another connection, delete it before connecting another output."
+        );
+        dataIn.disconnect(collectionOut);
+        expect(dataIn.canAccept(collectionOut).canAccept).toBe(true);
+        expect(dataIn.mapOver).toEqual(NULL_COLLECTION_TYPE_DESCRIPTION);
+    });
     it("treats multi data input as list input", () => {
         const collectionOut = terminals["list input"]!["output"] as OutputCollectionTerminal;
         const multiDataIn = terminals["multi data"]!["f1"] as InputTerminal;
diff --git a/client/src/components/Workflow/Editor/test-data/parameter_steps.json b/client/src/components/Workflow/Editor/test-data/parameter_steps.json
index ef4db3bb7564..3fc3c03a7d91 100644
--- a/client/src/components/Workflow/Editor/test-data/parameter_steps.json
+++ b/client/src/components/Workflow/Editor/test-data/parameter_steps.json
@@ -977,5 +977,128 @@
       "left": 148.72970581054688,
       "top": 620.5069274902344
     }
+  },
+  "21": {
+    "id": 21,
+    "type": "data_collection_input",
+    "label": "paired_or_unpaired input",
+    "content_id": null,
+    "name": "Input dataset collection",
+    "tool_state": {
+      "collection_type": "paired_or_unpaired",
+      "optional": "\"false\"",
+      "tag": "\"\"",
+      "__page__": null,
+      "__rerun_remap_job_id__": null
+    },
+    "errors": null,
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "output",
+        "extensions": [
+          "input"
+        ],
+        "collection": true,
+        "collection_type": "paired_or_unpaired",
+        "optional": false
+      }
+    ],
+    "annotation": "",
+    "post_job_actions": {},
+    "workflow_outputs": [],
+    "input_connections": {},
+    "position": {
+      "left": 70.45245361328125,
+      "top": 316.3525695800781
+    }
+  },
+  "22": {
+    "id": 22,
+    "type": "data_collection_input",
+    "label": "list:paired_or_unpaired input",
+    "content_id": null,
+    "name": "Input dataset collection",
+    "tool_state": {
+      "collection_type": "list:paired_or_unpaired",
+      "optional": "\"false\"",
+      "tag": "\"\"",
+      "__page__": null,
+      "__rerun_remap_job_id__": null
+    },
+    "errors": null,
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "output",
+        "extensions": [
+          "input"
+        ],
+        "collection": true,
+        "collection_type": "list:paired_or_unpaired",
+        "optional": false
+      }
+    ],
+    "annotation": "",
+    "post_job_actions": {},
+    "workflow_outputs": [],
+    "input_connections": {},
+    "position": {
+      "left": 70.45245361328125,
+      "top": 316.3525695800781
+    }
+  },
+  "23": {
+    "id": 23,
+    "type": "tool",
+    "label": "paired_or_unpaired collection input",
+    "content_id": "collection_paired_or_unpaired",
+    "name": "collection_paired_or_unpaired",
+    "tool_state": {
+      "f1": "{\"__class__\": \"RuntimeValue\"}",
+      "__page__": null,
+      "__rerun_remap_job_id__": null
+    },
+    "errors": null,
+    "inputs": [
+      {
+        "name": "f1",
+        "label": "f1",
+        "multiple": false,
+        "input_type": "dataset_collection",
+        "collection_types": [
+          "paired_or_unpaired"
+        ],
+        "optional": false,
+        "extensions": [
+          "data"
+        ]
+      }
+    ],
+    "outputs": [
+      {
+        "name": "out1",
+        "extensions": [
+          "txt"
+        ],
+        "type": "data",
+        "optional": false
+      }
+    ],
+    "annotation": "",
+    "post_job_actions": {
+      "HideDatasetActionout_file1": {
+        "action_type": "HideDatasetAction",
+        "output_name": "out_file1",
+        "action_arguments": {}
+      }
+    },
+    "uuid": "b7cc7fff-d167-4333-a0cd-f7a23c3420d4",
+    "workflow_outputs": [],
+    "input_connections": {},
+    "position": {
+      "left": 867.0313110351562,
+      "top": 390.6929626464844
+    }
   }
 }
diff --git a/client/src/entry/analysis/router.js b/client/src/entry/analysis/router.js
index 8d90ac29cb0a..d85c4d3d0530 100644
--- a/client/src/entry/analysis/router.js
+++ b/client/src/entry/analysis/router.js
@@ -217,6 +217,9 @@ export function getRouter(Galaxy) {
                     {
                         path: "collection/new_list",
                         component: ListWizard,
+                        props: (route) => ({
+                            initialAdvanced: Boolean(route.query.advanced),
+                        }),
                     },
                     {
                         path: "collection/:collectionId/edit",
diff --git a/client/src/stores/collectionBuilderItemsStore.ts b/client/src/stores/collectionBuilderItemsStore.ts
index 68f382c9458b..2e39344afe5f 100644
--- a/client/src/stores/collectionBuilderItemsStore.ts
+++ b/client/src/stores/collectionBuilderItemsStore.ts
@@ -89,3 +89,27 @@ export const useCollectionBuilderItemSelection = defineStore("collectionBuilderI
 
     return { selectedItems, setSelectedItems };
 });
+
+export const usePairingDatasetTargetsStore = defineStore("pairingDatasetTargets", {
+    state: () => ({
+        // Currently dragged node (null if no drag in progress)
+        draggedNodeId: null as string | null,
+        // Current drop target node (null if no target)
+        dropTargetId: null as string | null,
+    }),
+    actions: {
+        // Start dragging a node by its ID
+        startDrag(nodeId: string) {
+            this.draggedNodeId = nodeId;
+        },
+        // Set the current drop target by its ID
+        setDropTarget(nodeId: string | null) {
+            this.dropTargetId = nodeId;
+        },
+        // Clear drag state
+        endDrag() {
+            this.draggedNodeId = null;
+            this.dropTargetId = null;
+        },
+    },
+});
diff --git a/lib/galaxy/model/dataset_collections/adapters.py b/lib/galaxy/model/dataset_collections/adapters.py
new file mode 100644
index 000000000000..fad149221247
--- /dev/null
+++ b/lib/galaxy/model/dataset_collections/adapters.py
@@ -0,0 +1,257 @@
+from typing import TYPE_CHECKING
+
+from pydantic import ValidationError
+from typing_extensions import Self
+
+from galaxy.tool_util.parameters.models import (
+    AdaptedDataCollectionPromoteCollectionElementToCollectionRequestInternal,
+    AdaptedDataCollectionPromoteDatasetsToCollectionRequestInternal,
+    AdaptedDataCollectionPromoteDatasetToCollectionRequestInternal,
+    AdaptedDataCollectionRequestInternalTypeAdapter,
+    AdaptedDataCollectionRequestTypeAdapter,
+    AdapterElementRequestInternal,
+    DataRequestInternalHda,
+    DatasetCollectionElementReference,
+)
+
+if TYPE_CHECKING:
+    from galaxy.model import (
+        DatasetCollectionElement,
+        HistoryDatasetAssociation,
+    )
+
+
+class CollectionAdapter:
+    # wrap model objects with extra context to create psuedo or ephemeral
+    # collections for tool processing code. Used across tool actions and
+    # tool evaluation.
+
+    @property
+    def dataset_action_tuples(self):
+        raise NotImplementedError()
+
+    @property
+    def dataset_states_and_extensions_summary(self):
+        raise NotImplementedError()
+
+    @property
+    def dataset_instances(self):
+        raise NotImplementedError()
+
+    @property
+    def elements(self):
+        raise NotImplementedError()
+
+    def to_adapter_model(self, adapting):
+        # json kwds to recover state from database after the job has been
+        # recorded
+        raise NotImplementedError()
+
+    @property
+    def adapting(self):
+        # return the the thing we're adapting for recording an actual link
+        # in the database
+        raise NotImplementedError()
+
+    @property
+    def collection(self) -> Self:
+        # this object serves an adapter to the collection instance and to the collection,
+        # may want to break this out someday. For now though just return self when asking for
+        # the collection object.
+        return self
+
+
+class DCECollectionAdapter(CollectionAdapter):
+    # adapt a DatasetCollectionElement to act as collection.
+    _dce: "DatasetCollectionElement"
+
+    def __init__(self, dataset_collection_element: "DatasetCollectionElement"):
+        self._dce = dataset_collection_element
+
+    @property
+    def dataset_action_tuples(self):
+        if self._dce.child_collection:
+            return self._dce.child_collection.dataset_action_tuples
+        else:
+            hda = self._dce.dataset_instance
+            return [(permission.action, permission.role_id) for permission in hda.dataset.actions]
+
+    @property
+    def dataset_states_and_extensions_summary(self):
+        if self._dce.child_collection:
+            return self._dce.child_collection.dataset_states_and_extensions_summary
+        else:
+            hda = self._dce.dataset_instance
+            extensions = set()
+            states = set()
+            states.add(hda.dataset.state)
+            extensions.add(hda.extension)
+            return (states, extensions)
+
+    @property
+    def dataset_instances(self):
+        return self._dce.dataset_instances
+
+    @property
+    def elements(self):
+        if self._dce.child_collection:
+            return self._dce.child_collection.elements
+        else:
+            return [self._dce]
+
+    @property
+    def adapting(self):
+        return self._dce
+
+
+class PromoteCollectionElementToCollectionAdapter(DCECollectionAdapter):
+    # allow a singleton list element to act as paired_or_unpaired collection
+
+    def to_adapter_model(self, adapting) -> AdaptedDataCollectionPromoteCollectionElementToCollectionRequestInternal:
+        adapting_model = DatasetCollectionElementReference.model_validate(adapting)
+        return AdaptedDataCollectionPromoteCollectionElementToCollectionRequestInternal(
+            src="CollectionAdapter",
+            adapter_type="PromoteCollectionElementToCollection",
+            adapting=adapting_model,
+        )
+
+
+class PromoteDatasetToCollection(CollectionAdapter):
+
+    def __init__(self, hda: "HistoryDatasetAssociation", collection_type: str):
+        assert collection_type in ["list", "paired_or_unpaired"]
+        self._hda = hda
+        self._collection_type = collection_type
+
+    def to_adapter_model(self, adapting) -> AdaptedDataCollectionPromoteDatasetToCollectionRequestInternal:
+        adapting_model = DataRequestInternalHda.model_validate(adapting)
+        return AdaptedDataCollectionPromoteDatasetToCollectionRequestInternal(
+            src="CollectionAdapter",
+            adapter_type="PromoteDatasetToCollection",
+            collection_type=self._collection_type,
+            adapting=adapting_model,
+        )
+
+    @property
+    def dataset_action_tuples(self):
+        hda = self._hda
+        return [(permission.action, permission.role_id) for permission in hda.dataset.actions]
+
+    @property
+    def dataset_states_and_extensions_summary(self):
+        hda = self._hda
+        extensions = set()
+        states = set()
+        states.add(hda.dataset.state)
+        extensions.add(hda.extension)
+        return (states, extensions)
+
+    @property
+    def dataset_instances(self):
+        return [self._hda]
+
+    @property
+    def elements(self):
+        identifier = self._hda.name
+        if self._collection_type == "paired_or_unpaired":
+            identifier = "unpaired"
+        return [TransientCollectionAdapterDatasetInstanceElement(identifier, self._hda)]
+
+    @property
+    def adapting(self):
+        return self._hda
+
+
+class PromoteDatasetsToCollection(CollectionAdapter):
+
+    def __init__(self, elements: "TransientCollectionAdapterDatasetInstanceElement", collection_type: str):
+        assert collection_type in ["paired", "paired_or_unpaired"]
+        self._collection_type = collection_type
+        self._elements = elements
+
+    def to_adapter_model(self, adapting) -> AdaptedDataCollectionPromoteDatasetsToCollectionRequestInternal:
+        element_models = []
+        for element in self._elements:
+            element_model = AdapterElementRequestInternal(
+                src="hda",
+                id=element.hda.id,
+                name=element.element_identifier,
+            )
+            element_models.append(element_model)
+        return AdaptedDataCollectionPromoteDatasetsToCollectionRequestInternal(
+            src="CollectionAdapter",
+            adapter_type="PromoteDatasetsToCollection",
+            collection_type=self._collection_type,
+            adapting=element_models,
+        )
+
+    @property
+    def dataset_instances(self):
+        return [e.dataset_instance for e in self._elements]
+
+    @property
+    def elements(self):
+        return self._elements
+
+    @property
+    def element_object(self) -> Self:
+        # this is a stand-in or adapter for a real collection so this might be the object?
+        return self
+
+    @property
+    def dataset_action_tuples(self):
+        tuples = []
+        for hda in self.dataset_instances:
+            tuples.append([(permission.action, permission.role_id) for permission in hda.dataset.actions])
+        return tuples
+
+    @property
+    def dataset_states_and_extensions_summary(self):
+        extensions = set()
+        states = set()
+        for hda in self.dataset_instances:
+            states.add(hda.dataset.state)
+            extensions.add(hda.extension)
+        return (states, extensions)
+
+    @property
+    def adapting(self):
+        return self._elements
+
+
+class TransientCollectionAdapterDatasetInstanceElement:
+    def __init__(self, element_identifier, hda: "HistoryDatasetAssociation"):
+        self.element_identifier = element_identifier
+        self.child_collection = None
+        self.hda = hda
+
+    @property
+    def element_object(self):
+        return self.hda
+
+    @property
+    def dataset_instance(self):
+        return self.hda
+
+    @property
+    def is_collection(self):
+        return False
+
+
+def recover_adapter(wrapped_object, adapter_model):
+    adapter_type = adapter_model.adapter_type
+    if adapter_type == "PromoteCollectionElementToCollection":
+        return PromoteCollectionElementToCollectionAdapter(wrapped_object)
+    elif adapter_type == "PromoteDatasetToCollection":
+        return PromoteDatasetToCollection(wrapped_object, adapter_model.collection_type)
+    elif adapter_type == "PromoteDatasetsToCollection":
+        return PromoteDatasetsToCollection(wrapped_object, adapter_model.collection_type)
+    else:
+        raise Exception(f"Unknown collection adapter encountered {adapter_type}")
+
+
+def validate_collection_adapter_src_dict(value):
+    try:
+        return AdaptedDataCollectionRequestInternalTypeAdapter.validate_python(value)
+    except ValidationError:
+        return AdaptedDataCollectionRequestTypeAdapter.validate_python(value)
diff --git a/lib/galaxy/model/dataset_collections/registry.py b/lib/galaxy/model/dataset_collections/registry.py
index bd148edafd2d..ed75294f68e7 100644
--- a/lib/galaxy/model/dataset_collections/registry.py
+++ b/lib/galaxy/model/dataset_collections/registry.py
@@ -2,6 +2,7 @@
 from .types import (
     list,
     paired,
+    paired_or_unpaired,
     record,
 )
 
@@ -9,6 +10,7 @@
     list.ListDatasetCollectionType,
     paired.PairedDatasetCollectionType,
     record.RecordDatasetCollectionType,
+    paired_or_unpaired.PairedOrUnpairedDatasetCollectionType,
 ]
 
 
diff --git a/lib/galaxy/model/dataset_collections/structure.py b/lib/galaxy/model/dataset_collections/structure.py
index 673585a8c87f..83de5c9a87a9 100644
--- a/lib/galaxy/model/dataset_collections/structure.py
+++ b/lib/galaxy/model/dataset_collections/structure.py
@@ -1,9 +1,10 @@
 """ Module for reasoning about structure of and matching hierarchical collections of data.
 """
 
-import logging
+from typing import TYPE_CHECKING
 
-log = logging.getLogger(__name__)
+if TYPE_CHECKING:
+    from .type_description import CollectionTypeDescription
 
 
 class Leaf:
@@ -149,7 +150,7 @@ def clone(self):
         return Tree(cloned_children, self.collection_type_description)
 
     def __str__(self):
-        return f"Tree[collection_type={self.collection_type_description},children={','.join(f'{identifier_and_element[0]}={identifier_and_element[1]}' for identifier_and_element in self.children)}]"
+        return f"Tree[collection_type={self.collection_type_description},children=({','.join(f'{identifier_and_element[0]}={identifier_and_element[1]}' for identifier_and_element in self.children)})]"
 
 
 def tool_output_to_structure(get_sliced_input_collection_structure, tool_output, collections_manager):
@@ -190,7 +191,9 @@ def dict_map(func, input_dict):
     return {k: func(v) for k, v in input_dict.items()}
 
 
-def get_structure(dataset_collection_instance, collection_type_description, leaf_subcollection_type=None):
+def get_structure(
+    dataset_collection_instance, collection_type_description: "CollectionTypeDescription", leaf_subcollection_type=None
+):
     if leaf_subcollection_type:
         collection_type_description = collection_type_description.effective_collection_type_description(
             leaf_subcollection_type
diff --git a/lib/galaxy/model/dataset_collections/subcollections.py b/lib/galaxy/model/dataset_collections/subcollections.py
index af6c2a397326..a47f8594ee16 100644
--- a/lib/galaxy/model/dataset_collections/subcollections.py
+++ b/lib/galaxy/model/dataset_collections/subcollections.py
@@ -1,4 +1,5 @@
 from galaxy import exceptions
+from .adapters import PromoteCollectionElementToCollectionAdapter
 
 
 def split_dataset_collection_instance(dataset_collection_instance, collection_type):
@@ -6,13 +7,27 @@ def split_dataset_collection_instance(dataset_collection_instance, collection_ty
     return _split_dataset_collection(dataset_collection_instance.collection, collection_type)
 
 
+def _is_a_subcollection_type(this_collection_type: str, collection_type: str):
+    if collection_type == "single_datasets":
+        # can be a subcollection of anything effectively...
+        return True
+    if not this_collection_type.endswith(collection_type) or this_collection_type == collection_type:
+        return False
+    return True
+
+
 def _split_dataset_collection(dataset_collection, collection_type):
     this_collection_type = dataset_collection.collection_type
-    if not this_collection_type.endswith(collection_type) or this_collection_type == collection_type:
+    is_this_collection_nested = ":" in this_collection_type
+    if not _is_a_subcollection_type(this_collection_type, collection_type):
         raise exceptions.MessageException("Cannot split collection in desired fashion.")
 
     split_elements = []
     for element in dataset_collection.elements:
+        if not is_this_collection_nested and collection_type == "single_datasets":
+            split_elements.append(PromoteCollectionElementToCollectionAdapter(element))
+            continue
+
         child_collection = element.child_collection
         if child_collection is None:
             raise exceptions.MessageException("Cannot split collection in desired fashion.")
diff --git a/lib/galaxy/model/dataset_collections/type_description.py b/lib/galaxy/model/dataset_collections/type_description.py
index 4120db4c6f94..2ade4056dc6f 100644
--- a/lib/galaxy/model/dataset_collections/type_description.py
+++ b/lib/galaxy/model/dataset_collections/type_description.py
@@ -51,9 +51,12 @@ def effective_collection_type(self, subcollection_type):
         if not self.has_subcollections_of_type(subcollection_type):
             raise ValueError(f"Cannot compute effective subcollection type of {subcollection_type} over {self}")
 
+        if subcollection_type == "single_datasets":
+            return self.collection_type
+
         return self.collection_type[: -(len(subcollection_type) + 1)]
 
-    def has_subcollections_of_type(self, other_collection_type):
+    def has_subcollections_of_type(self, other_collection_type) -> bool:
         """Take in another type (either flat string or another
         CollectionTypeDescription) and determine if this collection contains
         subcollections matching that type.
@@ -65,18 +68,45 @@ def has_subcollections_of_type(self, other_collection_type):
         if hasattr(other_collection_type, "collection_type"):
             other_collection_type = other_collection_type.collection_type
         collection_type = self.collection_type
-        return collection_type.endswith(other_collection_type) and collection_type != other_collection_type
+        if collection_type == other_collection_type:
+            return False
+        if collection_type.endswith(other_collection_type):
+            return True
+        if other_collection_type == "paired_or_unpaired":
+            # this can be thought of as a subcollection of anything except a pair
+            # since it would match a pair exactly
+            return collection_type != "paired"
+        if other_collection_type == "single_datasets":
+            # effectively any collection has unpaired subcollections
+            return True
+        return False
 
     def is_subcollection_of_type(self, other_collection_type):
         if not hasattr(other_collection_type, "collection_type"):
             other_collection_type = self.collection_type_description_factory.for_collection_type(other_collection_type)
         return other_collection_type.has_subcollections_of_type(self)
 
-    def can_match_type(self, other_collection_type):
+    def can_match_type(self, other_collection_type) -> bool:
         if hasattr(other_collection_type, "collection_type"):
             other_collection_type = other_collection_type.collection_type
         collection_type = self.collection_type
-        return other_collection_type == collection_type
+        if other_collection_type == collection_type:
+            return True
+        elif other_collection_type == "paired" and collection_type == "paired_or_unpaired":
+            return True
+        elif other_collection_type == "paired_or_unpaired" and collection_type == "paired":
+            return True
+
+        if collection_type.endswith(":paired_or_unpaired"):
+            as_plain_list = collection_type[: -len(":paired_or_unpaired")]
+            if other_collection_type == as_plain_list:
+                return True
+            as_paired_list = f"{as_plain_list}:paired"
+            if other_collection_type == as_paired_list:
+                return True
+
+        # can we push this to the type registry somehow?
+        return False
 
     def subcollection_type_description(self):
         if not self.__has_subcollections:
diff --git a/lib/galaxy/model/dataset_collections/types/__init__.py b/lib/galaxy/model/dataset_collections/types/__init__.py
index c294f6957be6..30eee0489d58 100644
--- a/lib/galaxy/model/dataset_collections/types/__init__.py
+++ b/lib/galaxy/model/dataset_collections/types/__init__.py
@@ -21,3 +21,11 @@ def generate_elements(self, dataset_instances: dict, **kwds):
 class BaseDatasetCollectionType(DatasetCollectionType):
     def _validation_failed(self, message):
         raise exceptions.ObjectAttributeInvalidException(message)
+
+    def _ensure_dataset_with_identifier(self, dataset_instances: dict, name: str):
+        dataset_instance = dataset_instances.get(name)
+        if dataset_instance is None:
+            raise exceptions.ObjectAttributeInvalidException(
+                f"An element with the identifier {name} is required to create this collection type"
+            )
+        return dataset_instance
diff --git a/lib/galaxy/model/dataset_collections/types/collection_semantics.yml b/lib/galaxy/model/dataset_collections/types/collection_semantics.yml
index 9b6a2f96482b..753a0e4f5e6d 100644
--- a/lib/galaxy/model/dataset_collections/types/collection_semantics.yml
+++ b/lib/galaxy/model/dataset_collections/types/collection_semantics.yml
@@ -144,3 +144,63 @@
     - "tool(i=C) is invalid"
     tests:
     - wf_editor: "rejects paired input on multi-data input"
+
+PAIRED_OR_UNPAIRED_1:
+
+If tool(i: data) => {o: data}
+
+tool(i: collection<paired_or_unpaired>) => {o: collection<paired_or_unpaired>}
+
+Mapping a collection of type `paired_or_unpaired` over tool
+input i, yields an implicit collection of type `paired_or_unpaired`
+composed of the outputs o.
+ 
+- toolruntime: test_map_over_data_with_paired_or_unpaired
+- wfeditor: it("accepts paired_or_unpaired data -> data connection")
+
+PAIRED_OR_UNPAIRED_2:
+
+tool(i: collection<list:paired_or_unpaired>) => {o: collection<list:paired_or_unpaired>}
+
+- toolruntime: test_map_over_data_with_list_paired_or_unpaired
+- wfeditor:   it("accepts list:paired_or_unpaired data -> data connection", () => {
+
+
+PAIRED_OR_UNPAIRED_2, IDENTITY_1
+
+If tool(i: collection<paired_or_unpaired>) => {o: data}
+tool(i: collection<paired_or_unpaired>) => {o: data}
+
+- toolruntime: collection_paired_or_unpaired tool framework tests
+- wfeditor: accepts paired_or_unpaired data -> paired_or_unpaired connection
+
+PAIRED_OR_UNPAIRED_3, IDENTITY_2
+
+If tool(i: collection<list:paired_or_unpaired>) => {o: data}
+tool(i: collection<list:paired_or_unpaired>) => {o: data}
+
+- toolruntime: collection_list_paired_or_unpaired tool framework tests
+- wfeditor: accepts list:paired_or_unpaired data -> data connection
+
+PAIRED_OR_UNPAIRED_4
+
+If tool(i: collection<paired_or_unpaired>) => {o: data}
+tool(map_over(i, list, "single_datasets")) => {o: collection<list>}
+
+- toolruntime: test_map_over_paired_or_unpaired_with_list
+- wfeditor: "accepts list:paired_or_unpaired -> data connection"
+
+PAIRED_OR_UNPAIRED_5
+
+If tool(i: collection<paired_or_unpaired>) => {o: data}
+tool(map_over(i, list, "single_datasets")) => {o: collection<list>}
+
+- test_map_over_paired_or_unpaired_with_list
+- wfeditor: "accepts list -> paired_or_unpaired connection"
+
+PAIRED_OR_UNPAIRED_6
+If tool(i: collection<paired_or_unpaired>) => {o: data}
+tool(i: collection<paired>) => {o: data}
+
+- toolruntime: collection_paired_or_unpaired tool framework test (third)
+- wfeditor: "accepts paired -> paired_or_unpaired connection"
diff --git a/lib/galaxy/model/dataset_collections/types/paired.py b/lib/galaxy/model/dataset_collections/types/paired.py
index e774ab67aace..989adb8a23e1 100644
--- a/lib/galaxy/model/dataset_collections/types/paired.py
+++ b/lib/galaxy/model/dataset_collections/types/paired.py
@@ -1,3 +1,4 @@
+from galaxy.exceptions import RequestParameterInvalidException
 from galaxy.model import (
     DatasetCollectionElement,
     HistoryDatasetAssociation,
@@ -16,13 +17,19 @@ class PairedDatasetCollectionType(BaseDatasetCollectionType):
     collection_type = "paired"
 
     def generate_elements(self, dataset_instances, **kwds):
-        if forward_dataset := dataset_instances.get(FORWARD_IDENTIFIER):
+        num_datasets = len(dataset_instances)
+        if num_datasets != 2:
+            raise RequestParameterInvalidException(
+                "Incorrect number of datasets - 2 datasets exactly are required to create a single_or_paired collection"
+            )
+
+        if forward_dataset := self._ensure_dataset_with_identifier(dataset_instances, FORWARD_IDENTIFIER):
             left_association = DatasetCollectionElement(
                 element=forward_dataset,
                 element_identifier=FORWARD_IDENTIFIER,
             )
             yield left_association
-        if reverse_dataset := dataset_instances.get(REVERSE_IDENTIFIER):
+        if reverse_dataset := self._ensure_dataset_with_identifier(dataset_instances, REVERSE_IDENTIFIER):
             right_association = DatasetCollectionElement(
                 element=reverse_dataset,
                 element_identifier=REVERSE_IDENTIFIER,
diff --git a/lib/galaxy/model/dataset_collections/types/paired_or_unpaired.py b/lib/galaxy/model/dataset_collections/types/paired_or_unpaired.py
new file mode 100644
index 000000000000..bf55cafe3904
--- /dev/null
+++ b/lib/galaxy/model/dataset_collections/types/paired_or_unpaired.py
@@ -0,0 +1,43 @@
+from galaxy.exceptions import RequestParameterInvalidException
+from galaxy.model import DatasetCollectionElement
+from . import BaseDatasetCollectionType
+from .paired import (
+    FORWARD_IDENTIFIER,
+    REVERSE_IDENTIFIER,
+)
+
+SINGLETON_IDENTIFIER = "unpaired"
+
+
+class PairedOrUnpairedDatasetCollectionType(BaseDatasetCollectionType):
+    """ """
+
+    collection_type = "paired_or_unpaired"
+
+    def generate_elements(self, dataset_instances, **kwds):
+        num_datasets = len(dataset_instances)
+        if num_datasets > 2 or num_datasets < 1:
+            raise RequestParameterInvalidException(
+                "Incorrect number of datasets - 1 or 2 datasets is required to create a paired_or_unpaired collection"
+            )
+
+        if num_datasets == 2:
+            if forward_dataset := self._ensure_dataset_with_identifier(dataset_instances, FORWARD_IDENTIFIER):
+                left_association = DatasetCollectionElement(
+                    element=forward_dataset,
+                    element_identifier=FORWARD_IDENTIFIER,
+                )
+                yield left_association
+            if reverse_dataset := self._ensure_dataset_with_identifier(dataset_instances, REVERSE_IDENTIFIER):
+                right_association = DatasetCollectionElement(
+                    element=reverse_dataset,
+                    element_identifier=REVERSE_IDENTIFIER,
+                )
+                yield right_association
+        else:
+            if single_datasets := self._ensure_dataset_with_identifier(dataset_instances, SINGLETON_IDENTIFIER):
+                single_association = DatasetCollectionElement(
+                    element=single_datasets,
+                    element_identifier=SINGLETON_IDENTIFIER,
+                )
+                yield single_association
diff --git a/lib/galaxy/schema/schema.py b/lib/galaxy/schema/schema.py
index 8c031a0fcfe1..010e7a78c278 100644
--- a/lib/galaxy/schema/schema.py
+++ b/lib/galaxy/schema/schema.py
@@ -33,6 +33,8 @@
 from typing_extensions import (
     Annotated,
     Literal,
+    NotRequired,
+    TypedDict,
 )
 
 from galaxy.schema import partial_model
diff --git a/lib/galaxy/tool_util/parameters/models.py b/lib/galaxy/tool_util/parameters/models.py
index d0e7e6bbcb8f..1c6eddfc403a 100644
--- a/lib/galaxy/tool_util/parameters/models.py
+++ b/lib/galaxy/tool_util/parameters/models.py
@@ -33,6 +33,7 @@
     StrictInt,
     StrictStr,
     Tag,
+    TypeAdapter,
     ValidationError,
 )
 from typing_extensions import (
@@ -329,6 +330,7 @@ def request_requires_value(self) -> bool:
 
 DataSrcT = Literal["hda", "ldda"]
 MultiDataSrcT = Literal["hda", "ldda", "hdca"]
+# @jmchilton you meant CollectionSrcT - fix that at some point please.
 CollectionStrT = Literal["hdca"]
 
 TestCaseDataSrcT = Literal["File"]
@@ -527,6 +529,78 @@ class DataCollectionRequestInternal(StrictModel):
     id: StrictInt
 
 
+CollectionAdapterSrcT = Literal["CollectionAdapter"]
+
+
+class AdaptedDataCollectionRequestBase(StrictModel):
+    src: CollectionAdapterSrcT
+
+
+class AdaptedDataCollectionPromoteDatasetToCollectionRequest(AdaptedDataCollectionRequestBase):
+    adapter_type: Literal["PromoteDatasetToCollection"]
+    collection_type: Literal["list", "paired_or_unpaired"]
+    adapting: DataRequestHda
+
+
+# calling this name and element_identifier to align with fetch API, etc...
+class AdapterElementRequest(DataRequestHda):
+    name: str  # element_identifier
+
+
+class AdaptedDataCollectionPromoteDatasetsToCollectionRequest(AdaptedDataCollectionRequestBase):
+    adapter_type: Literal["PromoteDatasetsToCollection"]
+    # could allow list in here without changing much else I think but I'm trying to keep these tight in scope
+    collection_type: Literal["paired", "paired_or_unpaired"]
+    adapting: List[AdapterElementRequest]
+
+
+AdaptedDataCollectionRequest = Annotated[
+    Union[
+        AdaptedDataCollectionPromoteDatasetToCollectionRequest, AdaptedDataCollectionPromoteDatasetsToCollectionRequest
+    ],
+    Field(discriminator="adapter_type"),
+]
+AdaptedDataCollectionRequestTypeAdapter = TypeAdapter(AdaptedDataCollectionRequest)
+
+
+class DatasetCollectionElementReference(StrictModel):
+    src: Literal["dce"]
+    id: StrictInt
+
+
+class AdaptedDataCollectionPromoteCollectionElementToCollectionRequestInternal(AdaptedDataCollectionRequestBase):
+    adapter_type: Literal["PromoteCollectionElementToCollection"]
+    adapting: DatasetCollectionElementReference
+
+
+class AdaptedDataCollectionPromoteDatasetToCollectionRequestInternal(AdaptedDataCollectionRequestBase):
+    adapter_type: Literal["PromoteDatasetToCollection"]
+    collection_type: Literal["list", "paired_or_unpaired"]
+    adapting: DataRequestInternalHda
+
+
+class AdapterElementRequestInternal(DataRequestInternalHda):
+    name: str  # element_identifier
+
+
+class AdaptedDataCollectionPromoteDatasetsToCollectionRequestInternal(AdaptedDataCollectionRequestBase):
+    adapter_type: Literal["PromoteDatasetsToCollection"]
+    # could allow list in here without changing much else I think but I'm trying to keep these tight in scope
+    collection_type: Literal["paired", "paired_or_unpaired"]
+    adapting: List[AdapterElementRequestInternal]
+
+
+AdaptedDataCollectionRequestInternal = Annotated[
+    Union[
+        AdaptedDataCollectionPromoteCollectionElementToCollectionRequestInternal,
+        AdaptedDataCollectionPromoteDatasetToCollectionRequestInternal,
+        AdaptedDataCollectionPromoteDatasetsToCollectionRequestInternal,
+    ],
+    Field(discriminator="adapter_type"),
+]
+AdaptedDataCollectionRequestInternalTypeAdapter = TypeAdapter(AdaptedDataCollectionRequestInternal)
+
+
 class DataCollectionParameterModel(BaseGalaxyToolParameterModelDefinition):
     parameter_type: Literal["gx_data_collection"] = "gx_data_collection"
     collection_type: Optional[str] = None
diff --git a/lib/galaxy/tools/__init__.py b/lib/galaxy/tools/__init__.py
index 1174db417b3b..08a6a0054ec4 100644
--- a/lib/galaxy/tools/__init__.py
+++ b/lib/galaxy/tools/__init__.py
@@ -3534,6 +3534,63 @@ def produce_outputs(self, trans, out_data, output_collections, incoming, history
         )
 
 
+class SplitPairedAndUnpairedTool(DatabaseOperationTool):
+    tool_type = "split_paired_and_unpaired"
+    require_terminal_states = False
+    require_dataset_ok = False
+
+    def produce_outputs(self, trans, out_data, output_collections, incoming, history, **kwds):
+        has_collection = incoming["input"]
+        if hasattr(has_collection, "element_type"):
+            # It is a DCE
+            collection = has_collection.element_object
+        else:
+            # It is an HDCA
+            collection = has_collection.collection
+
+        collection_type = collection.collection_type
+        assert collection_type in ["list", "list:paired", "list:paired_or_unpaired"]
+
+        unpaired_dce_copies = {}
+        paired_dce_copies = {}
+        paired_datasets = []
+
+        def _handle_unpaired(dce):
+            element_identifier = dce.element_identifier
+            assert getattr(dce.element_object, "history_content_type", None) == "dataset"
+            copied_value = dce.element_object.copy(copy_tags=dce.element_object.tags, flush=False)
+            unpaired_dce_copies[element_identifier] = copied_value
+
+        def _handle_paired(dce):
+            element_identifier = dce.element_identifier
+            copied_value = dce.element_object.copy(flush=False)
+            paired_dce_copies[element_identifier] = copied_value
+            paired_datasets.append(copied_value.elements[0].element_object)
+            paired_datasets.append(copied_value.elements[1].element_object)
+
+        if collection_type == "list":
+            for element in collection.elements:
+                _handle_unpaired(element)
+        elif collection_type == "list:paired":
+            for element in collection.elements:
+                _handle_paired(element)
+        elif collection_type == "list:paired_or_unpaired":
+            for element in collection.elements:
+                if getattr(element.element_object, "history_content_type", None) == "dataset":
+                    _handle_unpaired(element)
+                else:
+                    _handle_paired(element)
+
+        self._add_datasets_to_history(history, unpaired_dce_copies.values())
+        self._add_datasets_to_history(history, paired_datasets)
+        output_collections.create_collection(
+            self.outputs["output_unpaired"], "output_unpaired", elements=unpaired_dce_copies, propagate_hda_tags=False
+        )
+        output_collections.create_collection(
+            self.outputs["output_paired"], "output_paired", elements=paired_dce_copies, propagate_hda_tags=False
+        )
+
+
 class ExtractDatasetCollectionTool(DatabaseOperationTool):
     tool_type = "extract_dataset"
     require_terminal_states = False
diff --git a/lib/galaxy/tools/actions/__init__.py b/lib/galaxy/tools/actions/__init__.py
index f7a2138795a3..df4f87ad009d 100644
--- a/lib/galaxy/tools/actions/__init__.py
+++ b/lib/galaxy/tools/actions/__init__.py
@@ -34,6 +34,7 @@
     WorkflowRequestInputParameter,
 )
 from galaxy.model.base import transaction
+from galaxy.model.dataset_collections.adapters import CollectionAdapter
 from galaxy.model.dataset_collections.builder import CollectionBuilder
 from galaxy.model.dataset_collections.matching import MatchingCollections
 from galaxy.model.none_like import NoneDataset
@@ -265,12 +266,16 @@ def process_dataset(data, formats=None):
 
                 collection = None
                 child_collection = False
-                if hasattr(value, "child_collection"):
-                    # if we are mapping a collection over a tool, we only require the child_collection
+                if isinstance(value, CollectionAdapter):
+                    # collection was created for this execution, use it as is
+                    collection = value
+                elif hasattr(value, "child_collection"):
+                    # if we are mapping a collection over a tool, so value is a DCE and
+                    # we only require the child_collection
                     child_collection = True
                     collection = value.child_collection
                 else:
-                    # else the tool takes a collection as input so we need everything
+                    # else the tool takes the collection as input so we need everything
                     collection = value.collection
 
                 action_tuples = collection.dataset_action_tuples
@@ -935,6 +940,19 @@ def _record_inputs(self, trans, tool, job, incoming, inp_data, inp_dataset_colle
                     job.add_input_dataset_collection(name, dataset_collection)
                 elif isinstance(dataset_collection, model.DatasetCollectionElement):
                     job.add_input_dataset_collection_element(name, dataset_collection)
+                elif isinstance(dataset_collection, CollectionAdapter):
+                    adapting = dataset_collection.adapting
+                    # TODO: record adapter json in the association I think... -John
+                    if isinstance(adapting, model.DatasetCollectionElement):
+                        job.add_input_dataset_collection_element(name, adapting)
+                    elif isinstance(adapting, model.HistoryDatasetAssociation):
+                        job.add_input_dataset(name, dataset=adapting)
+                    elif isinstance(adapting, list):
+                        for element in adapting:
+                            input_key = f"{name}|__adapter_part__|{element.element_identifier}"
+                            job.add_input_dataset(input_key, dataset=element.hda)
+                else:
+                    log.info(f"not recording something as a collection in here... for name {name}")
 
         # If this an input collection is a reduction, we expanded it for dataset security, type
         # checking, and such, but the persisted input must be the original collection
diff --git a/lib/galaxy/tools/parameters/basic.py b/lib/galaxy/tools/parameters/basic.py
index 6b06711c9c1f..b5951dc46634 100644
--- a/lib/galaxy/tools/parameters/basic.py
+++ b/lib/galaxy/tools/parameters/basic.py
@@ -40,6 +40,12 @@
     LibraryDatasetDatasetAssociation,
 )
 from galaxy.model.dataset_collections import builder
+from galaxy.model.dataset_collections.adapters import (
+    CollectionAdapter,
+    recover_adapter,
+    TransientCollectionAdapterDatasetInstanceElement,
+    validate_collection_adapter_src_dict,
+)
 from galaxy.schema.fetch_data import FilesPayload
 from galaxy.tool_util.parameters.factory import get_color_value
 from galaxy.tool_util.parser import get_input_source as ensure_input_source
@@ -2013,6 +2019,21 @@ def src_id_to_item(
     HistoryDatasetCollectionAssociation,
     LibraryDatasetDatasetAssociation,
 ]:
+    adapter_model = None
+    if value["src"] == "CollectionAdapter":
+        adapter_model = validate_collection_adapter_src_dict(value)
+        adapting = adapter_model.adapting
+        if isinstance(adapting, list):
+            elements = []
+            for item in adapting:
+                element = TransientCollectionAdapterDatasetInstanceElement(
+                    item.name,
+                    src_id_to_item(sa_session, item.dict(), security),
+                )
+                elements.append(element)
+            return recover_adapter(elements, adapter_model)
+        else:
+            value = adapting.dict()
     src_to_class = {
         "hda": HistoryDatasetAssociation,
         "ldda": LibraryDatasetDatasetAssociation,
@@ -2027,6 +2048,8 @@ def src_id_to_item(
         raise ValueError(f"Unknown input source {value['src']} passed to job submission API.")
     if not item:
         raise ValueError("Invalid input id passed to job submission API.")
+    if adapter_model is not None:
+        item = recover_adapter(item, adapter_model)
     item.extra_params = {k: v for k, v in value.items() if k not in ("src", "id")}
     return item
 
@@ -2477,9 +2500,14 @@ def from_json(self, value, trans, other_values=None):
             # a DatasetCollectionElement instead of a
             # HistoryDatasetCollectionAssociation.
             rval = value
-        elif isinstance(value, MutableMapping) and "src" in value and "id" in value:
-            if value["src"] == "hdca":
-                rval = session.get(HistoryDatasetCollectionAssociation, trans.security.decode_id(value["id"]))
+        elif isinstance(value, CollectionAdapter):
+            rval = value
+        elif (
+            isinstance(value, MutableMapping)
+            and "src" in value
+            and ("id" in value or value["src"] == "CollectionAdapter")
+        ):
+            rval = src_id_to_item(sa_session=trans.sa_session, value=value, security=trans.security)
         elif isinstance(value, list):
             if len(value) > 0:
                 value = value[0]
@@ -2571,6 +2599,12 @@ def to_dict(self, trans, other_values=None):
         # append matching subcollections
         for hdca, implicit_conversion in self.match_multirun_collections(trans, history, dataset_collection_matcher):
             subcollection_type = self._history_query(trans).can_map_over(hdca).collection_type
+            collection_type = hdca.collection.collection_type
+            if subcollection_type == "paired_or_unpaired" and not collection_type.endswith("paired_or_unpaired"):
+                if collection_type.endswith("paired"):
+                    subcollection_type = "paired"
+                else:
+                    subcollection_type = "single_datasets"
             name = hdca.name
             if implicit_conversion:
                 name = f"{name} (with implicit datatype conversion)"
@@ -2801,13 +2835,25 @@ def write_elements_to_collection(has_elements, collection_builder):
 
 def history_item_dict_to_python(value, app, name):
     if isinstance(value, MutableMapping) and "src" in value:
-        if value["src"] not in ("hda", "dce", "ldda", "hdca"):
+        if value["src"] not in ("hda", "dce", "ldda", "hdca", "CollectionAdapter"):
             raise ParameterValueError(f"Invalid value {value}", name)
         return src_id_to_item(sa_session=app.model.context, security=app.security, value=value)
 
 
 def history_item_to_json(value, app, use_security):
     src = None
+
+    # unwrap adapter
+    collection_adapter: Optional[CollectionAdapter] = None
+    if isinstance(value, CollectionAdapter):
+        collection_adapter = value
+        value = value.adapting
+        if isinstance(value, list):
+            # if we are not just adapting one thing... skip the rest of this
+            # and just serialize the stuff we know we want anyway. Perhaps all
+            # this should just be the only path through. The CollectionAdapter
+            # should know what to do with just use_security I think?
+            return collection_adapter.to_adapter_model(value).dict()
     if isinstance(value, MutableMapping) and "src" in value and "id" in value:
         return value
     elif isinstance(value, DatasetCollectionElement):
@@ -2823,4 +2869,7 @@ def history_item_to_json(value, app, use_security):
         src = "hda"
     if src is not None:
         object_id = cached_id(value)
-        return {"id": app.security.encode_id(object_id) if use_security else object_id, "src": src}
+        rval = {"id": app.security.encode_id(object_id) if use_security else object_id, "src": src}
+        if collection_adapter:
+            rval = collection_adapter.to_adapter_model(rval).dict()
+        return rval
diff --git a/lib/galaxy/tools/parameters/dataset_matcher.py b/lib/galaxy/tools/parameters/dataset_matcher.py
index 4a9d2a552561..15a63e75937d 100644
--- a/lib/galaxy/tools/parameters/dataset_matcher.py
+++ b/lib/galaxy/tools/parameters/dataset_matcher.py
@@ -188,6 +188,7 @@ def implicit_conversion(self):
 
 class HdcaDirectMatch:
     implicit_conversion = False
+    requires_adapter = False
 
     def __init__(self):
         pass
diff --git a/lib/galaxy/tools/parameters/history_query.py b/lib/galaxy/tools/parameters/history_query.py
index 4e6ebf11c02f..b570a774ec45 100644
--- a/lib/galaxy/tools/parameters/history_query.py
+++ b/lib/galaxy/tools/parameters/history_query.py
@@ -42,7 +42,8 @@ def direct_match(self, hdca):
         collection_type_descriptions = self.collection_type_descriptions
         if collection_type_descriptions is not None:
             for collection_type_description in collection_type_descriptions:
-                if collection_type_description.can_match_type(hdca.collection.collection_type):
+                matches = collection_type_description.can_match_type(hdca.collection.collection_type)
+                if matches:
                     return True
             return False
 
diff --git a/lib/galaxy/tools/split_paired_and_unpaired.xml b/lib/galaxy/tools/split_paired_and_unpaired.xml
new file mode 100644
index 000000000000..b05db5207fac
--- /dev/null
+++ b/lib/galaxy/tools/split_paired_and_unpaired.xml
@@ -0,0 +1,132 @@
+<tool id="__SPLIT_PAIRED_AND_UNPAIRED__"
+      name="Split Paired and Unpaired"
+      version="1.0.0"
+      tool_type="split_paired_and_unpaired">
+  <description></description>
+  <type class="SplitPairedAndUnpairedTool" module="galaxy.tools" />
+  <action module="galaxy.tools.actions.model_operations"
+          class="ModelOperationToolAction"/>
+  <edam_operations>
+    <edam_operation>operation_2409</edam_operation>
+  </edam_operations>
+  <inputs>
+    <param name="input" type="data_collection" label="Input Collection" collection_type="list:paired,list,list:paired_or_unpaired" />
+  </inputs>
+  <outputs>
+    <collection name="output_unpaired" format_source="input" type="list" label="${on_string} (unpaired)" >
+    </collection>
+    <collection name="output_paired" format_source="input" type="list:paired" label="${on_string} (paired)" >
+    </collection>
+  </outputs>
+  <tests>
+    <test>
+      <param name="input">
+        <collection type="list">
+          <element name="el1" value="simple_line.txt" />
+          <element name="el2" value="simple_line_alternative.txt" />
+        </collection>
+      </param>
+      <output_collection name="output_unpaired" type="list" count="2">
+        <element name="el1" ftype="txt">
+          <assert_contents>
+            <has_line line="This is a line of text." />
+          </assert_contents>
+        </element>
+        <element name="el2" ftype="txt">
+          <assert_contents>
+            <has_line line="This is a different line of text." />
+          </assert_contents>
+        </element>
+      </output_collection>
+      <output_collection name="output_paired" type="list:paired" count="0">
+      </output_collection>
+    </test>
+    <test>
+      <param name="input">
+        <collection type="list:paired">
+          <element name="el1">
+            <collection type="paired">
+              <element name="forward" value="simple_line.txt" />
+              <element name="reverse" value="simple_line_alternative.txt" />
+            </collection>
+          </element>
+        </collection>
+      </param>
+      <output_collection name="output_unpaired" type="list" count="0">
+      </output_collection>
+      <output_collection name="output_paired" type="list:paired" count="1">
+        <element name="el1">
+          <element name="forward">
+            <assert_contents>
+              <has_line line="This is a line of text." />
+            </assert_contents>
+          </element>
+          <element name="reverse">
+            <assert_contents>
+              <has_line line="This is a different line of text." />
+            </assert_contents>
+          </element>
+        </element>
+      </output_collection>
+    </test>
+    <test>
+      <param name="input">
+        <collection type="list:paired_or_unpaired">
+          <element name="el1">
+            <collection type="paired">
+              <element name="forward" value="simple_line.txt" />
+              <element name="reverse" value="simple_line_alternative.txt" />
+            </collection>
+          </element>
+          <element name="el2" value="simple_line.txt">
+          </element>
+          <element name="el3" value="simple_line_alternative.txt">
+          </element>
+        </collection>
+      </param>
+      <output_collection name="output_unpaired" type="list" count="2">
+        <element name="el2" ftype="txt">
+          <assert_contents>
+            <has_line line="This is a line of text." />
+          </assert_contents>
+        </element>
+        <element name="el3" ftype="txt">
+          <assert_contents>
+            <has_line line="This is a different line of text." />
+          </assert_contents>
+        </element>
+      </output_collection>
+      <output_collection name="output_paired" type="list:paired" count="1">
+        <element name="el1">
+          <element name="forward">
+            <assert_contents>
+              <has_line line="This is a line of text." />
+            </assert_contents>
+          </element>
+          <element name="reverse">
+            <assert_contents>
+              <has_line line="This is a different line of text." />
+            </assert_contents>
+          </element>
+        </element>
+      </output_collection>
+    </test>
+  </tests>
+  <help><![CDATA[
+
+========
+Synopsis
+========
+
+
+===========
+Description
+===========
+
+
+.. class:: infomark
+
+This tool will create new history datasets for your collection but your quota usage will not increase.
+
+  ]]></help>
+</tool>
diff --git a/lib/galaxy/tools/wrappers.py b/lib/galaxy/tools/wrappers.py
index 12d3d779cafc..7cefacbd4269 100644
--- a/lib/galaxy/tools/wrappers.py
+++ b/lib/galaxy/tools/wrappers.py
@@ -19,7 +19,10 @@
     Union,
 )
 
-from typing_extensions import TypeAlias
+from typing_extensions import (
+    Self,
+    TypeAlias,
+)
 
 from galaxy.model import (
     DatasetCollection,
@@ -489,6 +492,14 @@ def _path_or_uri(self) -> str:
     def file_name(self) -> str:
         return str(self)
 
+    @property
+    def has_single_item(self) -> bool:
+        return True
+
+    @property
+    def single_item(self) -> Self:
+        return self
+
     def __getattr__(self, key: Any) -> Any:
         if key in ("extra_files_path", "files_path"):
             if not self.compute_environment:
@@ -766,6 +777,14 @@ def serialize(
             include_collection_name=include_collection_name,
         )
 
+    @property
+    def has_single_item(self) -> bool:
+        return self.__input_supplied and len(self.__element_instance_list) == 1
+
+    @property
+    def single_item(self) -> Self:
+        return self[0]
+
     @property
     def is_input_supplied(self) -> bool:
         return self.__input_supplied
diff --git a/lib/galaxy_test/api/test_dataset_collections.py b/lib/galaxy_test/api/test_dataset_collections.py
index 372d693d4fd0..d2b3e416f5a2 100644
--- a/lib/galaxy_test/api/test_dataset_collections.py
+++ b/lib/galaxy_test/api/test_dataset_collections.py
@@ -101,6 +101,25 @@ def test_create_list_of_new_pairs(self):
             pair_1_element_1 = pair_elements[0]
             assert pair_1_element_1["element_index"] == 0
 
+    def test_create_paried_or_unpaired(self, history_id):
+        collection_name = "a singleton in a paired_or_unpaired collection"
+        contents = [
+            ("unpaired", "1\t2\t3"),
+        ]
+        single_identifier = self.dataset_collection_populator.list_identifiers(history_id, contents)
+        payload = dict(
+            name=collection_name,
+            instance_type="history",
+            history_id=history_id,
+            element_identifiers=single_identifier,
+            collection_type="paired_or_unpaired",
+        )
+        create_response = self._post("dataset_collections", payload, json=True)
+        dataset_collection = self._check_create_response(create_response)
+        assert dataset_collection["collection_type"] == "paired_or_unpaired"
+        returned_collections = dataset_collection["elements"]
+        assert len(returned_collections) == 1, dataset_collection
+
     def test_create_record(self, history_id):
         contents = [
             ("condition", "1\t2\t3"),
diff --git a/lib/galaxy_test/api/test_tool_execute.py b/lib/galaxy_test/api/test_tool_execute.py
index 95bf43e27921..cedeb4605dc8 100644
--- a/lib/galaxy_test/api/test_tool_execute.py
+++ b/lib/galaxy_test/api/test_tool_execute.py
@@ -380,6 +380,125 @@ def test_map_over_collection(
     output_collection.assert_has_dataset_element("reverse").with_contents_stripped("456")
 
 
+@requires_tool_id("cat|cat1")
+def test_map_over_data_with_paired_or_unpaired(target_history: TargetHistory, required_tool: RequiredTool):
+    hdca = target_history.with_unpaired()
+    execute = required_tool.execute.with_inputs({"input1": {"batch": True, "values": [hdca.src_dict]}})
+    execute.assert_has_n_jobs(1).assert_creates_n_implicit_collections(1)
+    output_collection = execute.assert_creates_implicit_collection(0)
+    output_collection.assert_collection_type_is("paired_or_unpaired")
+    output_collection.assert_has_dataset_element("unpaired").with_contents_stripped("123")
+
+
+@requires_tool_id("cat|cat1")
+def test_map_over_data_with_list_paired_or_unpaired(target_history: TargetHistory, required_tool: RequiredTool):
+    hdca = target_history.with_list_of_paired_and_unpaired()
+    execute = required_tool.execute.with_inputs({"input1": {"batch": True, "values": [hdca.src_dict]}})
+    execute.assert_creates_n_implicit_collections(1)
+    output_collection = execute.assert_creates_implicit_collection(0)
+    output_collection.assert_collection_type_is("list:paired_or_unpaired")
+    output_collection.with_element_dict("paired_el")
+    output_collection.with_element_dict("unpaired_el")
+
+
+@requires_tool_id("collection_paired_or_unpaired")
+def test_map_over_paired_or_unpaired_with_list_paired(target_history: TargetHistory, required_tool: RequiredTool):
+    hdca = target_history.with_example_list_of_pairs()
+    execute = required_tool.execute.with_inputs(
+        {"f1": {"batch": True, "values": [{"map_over_type": "paired", **hdca.src_dict}]}}
+    )
+    execute.assert_has_n_jobs(2).assert_creates_n_implicit_collections(1)
+    output_collection = execute.assert_creates_implicit_collection(0)
+    output_collection.assert_has_dataset_element("test0").with_contents_stripped("123\n456")
+    output_collection.assert_has_dataset_element("test1").with_contents_stripped("789\n0ab")
+
+
+@requires_tool_id("collection_paired_or_unpaired")
+def test_map_over_paired_or_unpaired_with_list(target_history: TargetHistory, required_tool: RequiredTool):
+    contents = [("foo", "text for foo element")]
+    hdca = target_history.with_list(contents)
+    execute = required_tool.execute.with_inputs(
+        {"f1": {"batch": True, "values": [{"map_over_type": "single_datasets", **hdca.src_dict}]}}
+    )
+    execute.assert_has_n_jobs(1).assert_creates_n_implicit_collections(1)
+    output_collection = execute.assert_creates_implicit_collection(0)
+    output_collection.assert_has_dataset_element("foo").with_contents_stripped("text for foo element")
+
+
+@requires_tool_id("collection_paired_or_unpaired")
+def test_map_over_paired_or_unpaired_with_list_of_lists(target_history: TargetHistory, required_tool: RequiredTool):
+    hdca = target_history.with_example_list_of_lists()
+    execute = required_tool.execute.with_inputs(
+        {"f1": {"batch": True, "values": [{"map_over_type": "single_datasets", **hdca.src_dict}]}}
+    )
+    execute.assert_has_n_jobs(3).assert_creates_n_implicit_collections(1)
+    output_collection = execute.assert_creates_implicit_collection(0)
+    print(output_collection.details)
+    assert output_collection.details["collection_type"] == "list:list"
+    as_dict_0 = output_collection.with_element_dict(0)
+    assert len(as_dict_0["object"]["elements"]) == 3
+
+
+@requires_tool_id("collection_paired_or_unpaired")
+def test_adapting_dataset_to_paired_or_unpaired(target_history: TargetHistory, required_tool: RequiredTool):
+    hda1 = target_history.with_dataset("1\t2\t3").src_dict
+    execution = required_tool.execute.with_inputs(
+        {
+            "f1": {
+                "src": "CollectionAdapter",
+                "adapter_type": "PromoteDatasetToCollection",
+                "collection_type": "paired_or_unpaired",
+                "adapting": hda1,
+            }
+        }
+    )
+    execution.assert_has_job(0).with_output("out1").with_contents_stripped("1\t2\t3")
+
+
+@requires_tool_id("cat_collection")
+def test_adapting_dataset_to_list(target_history: TargetHistory, required_tool: RequiredTool):
+    hda1 = target_history.with_dataset("1\t2\t3").src_dict
+    execution = required_tool.execute.with_inputs(
+        {
+            "input1": {
+                "src": "CollectionAdapter",
+                "adapter_type": "PromoteDatasetToCollection",
+                "collection_type": "list",
+                "adapting": hda1,
+            }
+        }
+    )
+    execution.assert_has_job(0).with_output("out_file1").with_contents_stripped("1\t2\t3")
+
+
+@requires_tool_id("collection_paired_test")
+def test_adapting_two_datasets_to_paired_collection(target_history: TargetHistory, required_tool: RequiredTool):
+    hda1 = target_history.with_dataset("1\t2\t3").src_dict
+    hda2 = target_history.with_dataset("4\t5\t6").src_dict
+    execution = required_tool.execute.with_inputs(
+        {
+            "f1": {
+                "src": "CollectionAdapter",
+                "adapter_type": "PromoteDatasetsToCollection",
+                "collection_type": "paired",
+                "adapting": [
+                    {"name": "forward", **hda1},
+                    {"name": "reverse", **hda2},
+                ],
+            }
+        }
+    )
+    execution.assert_has_job(0).with_output("out1").with_contents_stripped("1\t2\t3\n4\t5\t6")
+
+
+@requires_tool_id("gx_data")
+def test_map_over_data_param_with_list_of_lists(target_history: TargetHistory, required_tool: RequiredTool):
+    hdca = target_history.with_example_list_of_lists()
+    execute = required_tool.execute.with_inputs({"parameter": {"batch": True, "values": [hdca.src_dict]}})
+    execute.assert_has_n_jobs(3).assert_creates_n_implicit_collections(1)
+    execute.assert_creates_implicit_collection(0)
+
+
 @requires_tool_id("gx_repeat_boolean_min")
 def test_optional_repeats_with_mins_filled_id(target_history: TargetHistory, required_tool: RequiredTool):
     # we have a tool test for this but I wanted to verify it wasn't just the
diff --git a/lib/galaxy_test/base/populators.py b/lib/galaxy_test/base/populators.py
index ee32c27b822c..81be13b1b2a2 100644
--- a/lib/galaxy_test/base/populators.py
+++ b/lib/galaxy_test/base/populators.py
@@ -3077,6 +3077,32 @@ def create_list_of_list_in_history(self, history_id: str, **kwds):
             list = response.json()
         return response
 
+    def create_unpaired_in_history(self, history_id: str, wait: bool = False, **kwds):
+        contents = [("unpaired", "123")]
+        payload = self.__create_payload(history_id, contents=contents, collection_type="paired_or_unpaired", **kwds)
+        return self.__create(payload, wait=wait)
+
+    def create_list_of_paired_and_unpaired_in_history(self, history_id: str, wait: bool = False, **kwds):
+        contents = [
+            {
+                "name": "paired_el",
+                "elements": [
+                    {"src": "pasted", "paste_content": "paired1", "name": "forward"},
+                    {"src": "pasted", "paste_content": "paired2", "name": "reverse"},
+                ],
+            },
+            {
+                "name": "unpaired_el",
+                "elements": [
+                    {"src": "pasted", "paste_content": "unpaired", "name": "unpaired"},
+                ],
+            },
+        ]
+        payload = self.__create_payload(
+            history_id, contents=contents, collection_type="list:paired_or_unpaired", **kwds
+        )
+        return self.__create(payload, wait=wait)
+
     def create_pair_in_history(self, history_id: str, wait: bool = False, **kwds):
         payload = self.create_pair_payload(history_id, instance_type="history", **kwds)
         return self.__create(payload, wait=wait)
@@ -3584,6 +3610,9 @@ def named(self, expected_name: str) -> Self:
     def assert_has_dataset_element(self, index: Union[str, int]) -> "DescribeToolExecutionOutput":
         return self.with_dataset_element(index)
 
+    def assert_collection_type_is(self, collection_type: str):
+        assert self.details["collection_type"] == collection_type
+
 
 class DescribeJob:
 
@@ -3934,6 +3963,18 @@ def with_dataset(
         )
         return HasSrcDict("hda", new_dataset)
 
+    def with_unpaired(self) -> "HasSrcDict":
+        return self._fetch_response(
+            self._dataset_collection_populator.create_unpaired_in_history(self._history_id, wait=True)
+        )
+
+    def with_list_of_paired_and_unpaired(self) -> "HasSrcDict":
+        return self._fetch_response(
+            self._dataset_collection_populator.create_list_of_paired_and_unpaired_in_history(
+                self._history_id, wait=True
+            )
+        )
+
     def with_pair(self, contents: Optional[List[str]] = None) -> "HasSrcDict":
         return self._fetch_response(
             self._dataset_collection_populator.create_pair_in_history(
@@ -3951,6 +3992,12 @@ def with_list(self, contents: Optional[ListContentsDescription] = None) -> "HasS
     def with_example_list_of_pairs(self) -> "HasSrcDict":
         return HasSrcDict("hdca", self._dataset_collection_populator.example_list_of_pairs(self._history_id))
 
+    def with_example_list_of_lists(self) -> "HasSrcDict":
+        return HasSrcDict(
+            "hdca",
+            self._dataset_collection_populator.create_list_of_list_in_history(self._history_id, wait=True).json()["id"],
+        )
+
     @classmethod
     def _fetch_response(clz, response: Response) -> "HasSrcDict":
         api_asserts.assert_status_code_is_ok(response)
diff --git a/test/functional/tools/collection_list_paired_or_unpaired.xml b/test/functional/tools/collection_list_paired_or_unpaired.xml
new file mode 100644
index 000000000000..40dc07ecbab1
--- /dev/null
+++ b/test/functional/tools/collection_list_paired_or_unpaired.xml
@@ -0,0 +1,88 @@
+<tool id="collection_list_paired_or_unpaired" name="collection_list_paired_or_unpaired" version="0.1.0">
+  <command>
+    #for $key in $f1.keys()#
+      echo "identifier is $key";
+      #set $element = $f1[$key]
+
+    #if $element.has_single_item:
+        cat $element.single_item >> $out1;
+        echo "Single item";
+    #else
+        cat $element.forward $element['reverse'] >> $out1;
+        echo "Paired items";
+    #end if
+    #end for#
+  </command>
+  <inputs>
+    <param name="f1" type="data_collection" collection_type="list:paired_or_unpaired" label="Input" />
+  </inputs>
+  <outputs>
+    <data format="txt" name="out1" />
+  </outputs>
+  <tests>
+    <test>
+      <param name="f1">
+        <collection type="list:paired_or_unpaired">
+          <element name="i1">
+            <collection type="paired_or_unpaired" name="collection name">
+            <element name="forward" value="simple_line.txt" />
+            <element name="reverse" value="simple_line_alternative.txt" />
+            </collection>
+          </element>
+        </collection>
+      </param>
+      <output name="out1">
+        <assert_contents>
+          <has_line line="This is a line of text." />
+          <has_line line="This is a different line of text." />
+        </assert_contents>
+      </output>
+      <assert_stdout>
+          <has_line line="identifier is i1" />
+          <has_line line="Paired items" />
+      </assert_stdout>
+    </test>
+    <test>
+      <param name="f1">
+        <collection type="list:paired">
+          <element name="i1">
+            <collection type="paired" name="collection name">
+            <element name="forward" value="simple_line.txt" />
+            <element name="reverse" value="simple_line_alternative.txt" />
+            </collection>
+          </element>
+        </collection>
+      </param>
+      <output name="out1">
+        <assert_contents>
+          <has_line line="This is a line of text." />
+          <has_line line="This is a different line of text." />
+        </assert_contents>
+      </output>
+      <assert_stdout>
+          <has_line line="identifier is i1" />
+          <has_line line="Paired items" />
+      </assert_stdout>
+    </test>
+    <test>
+      <param name="f1">
+        <collection type="list">
+            <element name="i1" value="simple_line.txt" />
+            <element name="i2" value="simple_line_alternative.txt" />
+            <element name="i3" value="simple_line.txt" />
+        </collection>
+      </param>
+      <output name="out1">
+        <assert_contents>
+          <has_line line="This is a line of text." />
+        </assert_contents>
+      </output>
+      <assert_stdout>
+          <has_line line="identifier is i1" />
+          <has_line line="identifier is i2" />
+          <has_line line="identifier is i3" />
+          <has_line line="Single item" />
+      </assert_stdout>
+    </test>
+  </tests>
+</tool>
diff --git a/test/functional/tools/collection_paired_or_unpaired.xml b/test/functional/tools/collection_paired_or_unpaired.xml
new file mode 100644
index 000000000000..9712f6b4e738
--- /dev/null
+++ b/test/functional/tools/collection_paired_or_unpaired.xml
@@ -0,0 +1,68 @@
+<tool id="collection_paired_or_unpaired" name="collection_paired_or_unpaired" version="0.1.0">
+  <command>
+    #if $f1.has_single_item:
+        cat $f1.single_item >> $out1;
+        echo "Single item"
+    #else
+        cat $f1.forward $f1['reverse'] >> $out1;
+        echo "Paired items"
+    #end if
+  </command>
+  <inputs>
+    <param name="f1" type="data_collection" collection_type="paired_or_unpaired" label="Input" />
+  </inputs>
+  <outputs>
+    <data format="txt" name="out1" />
+  </outputs>
+  <tests>
+    <test>
+      <param name="f1">
+        <collection type="paired_or_unpaired" name="collection name">
+          <element name="forward" value="simple_line.txt" />
+          <element name="reverse" value="simple_line_alternative.txt" />
+        </collection>
+      </param>
+      <output name="out1">
+        <assert_contents>
+          <has_line line="This is a line of text." />
+          <has_line line="This is a different line of text." />
+        </assert_contents>
+      </output>
+      <assert_stdout>
+          <has_line line="Paired items" />
+      </assert_stdout>
+    </test>
+    <test>
+      <param name="f1">
+        <collection type="paired_or_unpaired" name="collection name">
+          <element name="unpaired" value="simple_line.txt" />
+        </collection>
+      </param>
+      <output name="out1">
+        <assert_contents>
+          <has_line line="This is a line of text." />
+        </assert_contents>
+      </output>
+      <assert_stdout>
+          <has_line line="Single item" />
+      </assert_stdout>
+    </test>
+    <test>
+      <param name="f1">
+        <collection type="paired" name="collection name">
+          <element name="forward" value="simple_line.txt" />
+          <element name="reverse" value="simple_line_alternative.txt" />
+        </collection>
+      </param>
+      <output name="out1">
+        <assert_contents>
+          <has_line line="This is a line of text." />
+          <has_line line="This is a different line of text." />
+        </assert_contents>
+      </output>
+      <assert_stdout>
+          <has_line line="Paired items" />
+      </assert_stdout>
+    </test>
+  </tests>
+</tool>
diff --git a/test/functional/tools/sample_tool_conf.xml b/test/functional/tools/sample_tool_conf.xml
index 477fe69bde34..e5d947904626 100644
--- a/test/functional/tools/sample_tool_conf.xml
+++ b/test/functional/tools/sample_tool_conf.xml
@@ -213,6 +213,8 @@
   <tool file="collection_cat_group_tag.xml" />
   <tool file="collection_cat_group_tag_multiple.xml" />
   <tool file="collection_field_test_two_files.xml" />
+  <tool file="collection_paired_or_unpaired.xml" />
+  <tool file="collection_list_paired_or_unpaired.xml" />
   <tool file="discover_sort_by.xml" />
   <tool file="discover_default_ext.xml" />
   <tool file="expression_forty_two.xml" />
@@ -320,5 +322,5 @@
   <tool file="${model_tools_path}/build_list_1.2.0.xml" />
   <tool file="${model_tools_path}/extract_dataset.xml" />
   <tool file="${model_tools_path}/duplicate_file_to_collection.xml" />
-
+  <tool file="${model_tools_path}/split_paired_and_unpaired.xml" />
 </toolbox>
diff --git a/test/unit/data/dataset_collections/test_matching.py b/test/unit/data/dataset_collections/test_matching.py
index 3ea1747d38df..c6fdac01f750 100644
--- a/test/unit/data/dataset_collections/test_matching.py
+++ b/test/unit/data/dataset_collections/test_matching.py
@@ -48,6 +48,12 @@ def test_valid_collection_subcollection_matching():
     assert_can_match((nested_list, "paired"), flat_list)
 
 
+def test_paired_can_act_as_paired_or_unpaired():
+    paired = pair_instance()
+    optional_paired = paired_or_unpaired_pair_instance()
+    assert_can_match(paired, optional_paired)
+
+
 def assert_can_match(*items):
     to_match = build_collections_to_match(*items)
     matching.MatchingCollections.for_collections(to_match, TYPE_DESCRIPTION_FACTORY)
@@ -114,6 +120,44 @@ def list_paired_instance():
     )
 
 
+def list_of_paired_and_unpaired_instance():
+    return collection_instance(
+        collection_type="list:paired_or_unpaired",
+        elements=[
+            collection_element(
+                "el1",
+                collection(
+                    "paired_or_unpaired",
+                    [
+                        hda_element("forward"),
+                        hda_element("reverse"),
+                    ],
+                ),
+            ),
+            collection_element(
+                "el2",
+                collection(
+                    "paired_or_unpaired",
+                    [
+                        hda_element("unpaired"),
+                    ],
+                ),
+            ),
+        ],
+    )
+
+
+def paired_or_unpaired_pair_instance():
+    paired_collection_instance = collection_instance(
+        collection_type="paired_or_unpaired",
+        elements=[
+            hda_element("forward"),
+            hda_element("reverse"),
+        ],
+    )
+    return paired_collection_instance
+
+
 def list_instance(collection_type="list", elements=None, ids=None):
     if not elements:
         if ids is None:
diff --git a/test/unit/data/dataset_collections/test_structure.py b/test/unit/data/dataset_collections/test_structure.py
index 1c97d353a768..438c6c1c3690 100644
--- a/test/unit/data/dataset_collections/test_structure.py
+++ b/test/unit/data/dataset_collections/test_structure.py
@@ -2,6 +2,7 @@
 from galaxy.model.dataset_collections.type_description import CollectionTypeDescriptionFactory
 from .test_matching import (
     list_of_lists_instance,
+    list_of_paired_and_unpaired_instance,
     list_paired_instance,
     pair_instance,
 )
@@ -25,6 +26,7 @@ def test_get_structure_list_paired_over_paired():
     assert tree.children[0][0] == "data1"
     assert tree.children[0][1].is_leaf
 
+
 def test_get_structure_list_of_lists():
     list_of_lists_type_description = factory.for_collection_type("list:list")
     tree = get_structure(list_of_lists_instance(), list_of_lists_type_description)
@@ -41,3 +43,32 @@ def test_get_structure_list_of_lists_over_list():
     assert len(tree.children) == 2
     assert tree.children[0][0] == "outer1"
     assert tree.children[0][1].is_leaf
+
+
+def test_get_structure_list_paired_or_unpaired():
+    list_pair_or_unpaired_description = factory.for_collection_type("list:paired_or_unpaired")
+    tree = get_structure(list_of_paired_and_unpaired_instance(), list_pair_or_unpaired_description)
+    assert tree.collection_type_description.collection_type == "list:paired_or_unpaired"
+    assert len(tree.children) == 2
+    assert tree.children[0][0] == "el1"
+    assert not tree.children[0][1].is_leaf
+
+
+def test_get_structure_list_paired_or_unpaired_over_paired_or_unpaired():
+    list_pair_or_unpaired_description = factory.for_collection_type("list:paired_or_unpaired")
+    tree = get_structure(
+        list_of_paired_and_unpaired_instance(), list_pair_or_unpaired_description, "paired_or_unpaired"
+    )
+    assert tree.collection_type_description.collection_type == "list"
+    assert len(tree.children) == 2
+    assert tree.children[0][0] == "el1"
+    assert tree.children[0][1].is_leaf
+
+
+def test_get_structure_list_of_lists_over_single_datasests():
+    list_of_lists_type_description = factory.for_collection_type("list:list")
+    tree = get_structure(list_of_lists_instance(), list_of_lists_type_description, "single_datasets")
+    assert tree.collection_type_description.collection_type == "list:list"
+    assert len(tree.children) == 2
+    assert tree.children[0][0] == "outer1"
+    assert not tree.children[0][1].is_leaf
diff --git a/test/unit/data/dataset_collections/test_type_descriptions.py b/test/unit/data/dataset_collections/test_type_descriptions.py
index 11a1f7282a48..48510829420e 100644
--- a/test/unit/data/dataset_collections/test_type_descriptions.py
+++ b/test/unit/data/dataset_collections/test_type_descriptions.py
@@ -1,8 +1,9 @@
 from galaxy.model.dataset_collections.type_description import CollectionTypeDescriptionFactory
 
+factory = CollectionTypeDescriptionFactory(None)
+
 
 def test_simple_descriptions():
-    factory = CollectionTypeDescriptionFactory(None)
     nested_type_description = factory.for_collection_type("list:paired")
     paired_type_description = factory.for_collection_type("paired")
     assert not nested_type_description.has_subcollections_of_type("list")
@@ -11,8 +12,28 @@ def test_simple_descriptions():
     assert nested_type_description.has_subcollections_of_type(paired_type_description)
     assert nested_type_description.has_subcollections()
     assert not paired_type_description.has_subcollections()
-    assert paired_type_description.rank_collection_type() == 'paired'
-    assert nested_type_description.rank_collection_type() == 'list'
-    assert nested_type_description.effective_collection_type(paired_type_description) == 'list'
-    assert nested_type_description.effective_collection_type_description(paired_type_description).collection_type == 'list'
-    assert nested_type_description.child_collection_type() == 'paired'
+    assert paired_type_description.rank_collection_type() == "paired"
+    assert nested_type_description.rank_collection_type() == "list"
+    assert nested_type_description.effective_collection_type(paired_type_description) == "list"
+    assert (
+        nested_type_description.effective_collection_type_description(paired_type_description).collection_type == "list"
+    )
+    assert nested_type_description.child_collection_type() == "paired"
+
+
+def test_paired_or_unpaired_handling():
+    list_type_description = factory.for_collection_type("list")
+    assert list_type_description.has_subcollections_of_type("paired_or_unpaired")
+    paired_type_description = factory.for_collection_type("paired")
+    assert not paired_type_description.has_subcollections_of_type("paired_or_unpaired")
+
+    nested_type_description = factory.for_collection_type("list:paired")
+    assert nested_type_description.has_subcollections_of_type("paired_or_unpaired")
+
+    nested_list_type_description = factory.for_collection_type("list:list")
+    assert nested_list_type_description.has_subcollections_of_type("paired_or_unpaired")
+
+    mixed_list_type_description = factory.for_collection_type("list:paired_or_unpaired")
+    assert mixed_list_type_description.can_match_type("list:paired_or_unpaired")
+    assert mixed_list_type_description.can_match_type("list:paired")
+    assert mixed_list_type_description.can_match_type("list")