From 0e141738af56976128fa38320a60d97e376ba79e 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    |  89 +-
 .../Collections/ListCollectionCreator.vue     |  75 +-
 .../src/components/Collections/ListWizard.vue | 215 ++++-
 .../Collections/ListWizard/WhichBuilder.vue   | 141 +++-
 .../Collections/ListWizard/types.ts           |   8 +-
 .../Collections/PairCollectionCreator.vue     |  36 +-
 .../PairedListCollectionCreator.test.js       | 147 ----
 .../Collections/PairedOrUnpairedComponents.ts |  13 +
 .../PairedOrUnpairedListCollectionCreator.vue | 684 ++++++++++++++++
 .../PairedOrUnpairedListCreatorHelp.vue       | 115 +++
 .../Collections/common/AutoPairing.vue        | 157 ++++
 .../common/CellDiscardComponent.vue           |  35 +
 .../common/CellStatusComponent.vue            |  77 ++
 .../Collections/common/CollectionCreator.vue  |  41 +-
 .../common/CollectionCreatorHelpHeader.vue    |  18 +-
 .../common/CollectionNameInput.vue            |   5 +-
 .../common/PairedDatasetCellComponent.vue     | 151 ++++
 .../common/PairingFilterInputGroup.vue        |  65 ++
 .../Collections/common/stripExtension.ts      |  60 ++
 .../common/useCollectionCreation.ts           |  33 +
 .../common/useCollectionCreator.ts            |  64 +-
 .../Collections/common/usePairingSummary.ts   |  41 +
 .../components/Collections/pairing.test.ts    |  23 +-
 client/src/components/Collections/pairing.ts  |  16 +-
 .../Form/Elements/FormData/FormData.vue       |  14 +-
 .../Collection/CollectionDescription.vue      |  23 +-
 .../HistoryOperations/SelectionOperations.vue |  42 +-
 .../History/adapters/buildCollectionModal.ts  |   9 +-
 .../src/components/History/model/queries.ts   |   4 +-
 .../src/components/RuleCollectionBuilder.vue  |  44 +-
 .../Editor/Forms/FormCollectionType.vue       |   1 +
 .../modules/collectionTypeDescription.ts      |  88 +-
 .../Workflow/Editor/modules/terminals.test.ts | 223 ++++-
 .../Workflow/Editor/modules/terminals.ts      |  12 +-
 .../Editor/test-data/parameter_steps.json     | 352 ++++++++
 client/src/entry/analysis/router.js           |   3 +
 .../src/stores/collectionBuilderItemsStore.ts |  24 +
 doc/source/conf.py                            |   3 +-
 doc/source/dev/collection_semantics.md        | 762 ++++++++++++++++++
 doc/source/dev/index.rst                      |   1 +
 lib/galaxy/model/__init__.py                  |  26 +-
 .../model/dataset_collections/adapters.py     | 262 ++++++
 .../model/dataset_collections/registry.py     |   2 +
 .../model/dataset_collections/structure.py    |  11 +-
 .../dataset_collections/subcollections.py     |  17 +-
 .../dataset_collections/type_description.py   |  36 +-
 .../dataset_collections/types/__init__.py     |   8 +
 .../types/collection_semantics.yml            | 511 ++++++++++--
 .../model/dataset_collections/types/paired.py |  11 +-
 .../types/paired_or_unpaired.py               |  43 +
 .../dataset_collections/types/semantics.py    | 208 +++++
 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          |  30 +-
 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      | 130 +++
 lib/galaxy_test/base/populators.py            |  57 ++
 .../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 |  51 ++
 .../dataset_collections/test_structure.py     |  31 +
 .../test_type_descriptions.py                 |  41 +-
 70 files changed, 5457 insertions(+), 473 deletions(-)
 delete mode 100644 client/src/components/Collections/PairedListCollectionCreator.test.js
 create mode 100644 client/src/components/Collections/PairedOrUnpairedComponents.ts
 create mode 100644 client/src/components/Collections/PairedOrUnpairedListCollectionCreator.vue
 create mode 100644 client/src/components/Collections/PairedOrUnpairedListCreatorHelp.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 doc/source/dev/collection_semantics.md
 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/model/dataset_collections/types/semantics.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..18689f2e317b 100644
--- a/client/src/components/Collections/CollectionCreatorModal.vue
+++ b/client/src/components/Collections/CollectionCreatorModal.vue
@@ -4,18 +4,19 @@ 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 { type SupportedPairedOrPairedBuilderCollectionTypes } from "./common/useCollectionCreator";
 
 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 +31,7 @@ interface Props {
     fromRulesInput?: boolean;
     hideModalOnCreate?: boolean;
     filterText?: string;
+    useBetaComponents?: boolean;
 }
 const props = defineProps<Props>();
 
@@ -67,6 +69,15 @@ const historyDatasets = computed(() => {
         return [];
     }
 });
+const pairedOrUnpairedSupportedCollectionType = computed<SupportedPairedOrPairedBuilderCollectionTypes | null>(() => {
+    if (
+        ["list:paired", "list:list", "list:paired_or_unpaired", "list:list:paired"].indexOf(props.collectionType) !== -1
+    ) {
+        return props.collectionType as SupportedPairedOrPairedBuilderCollectionTypes;
+    } else {
+        return null;
+    }
+});
 
 /** Flag for the initial fetch of history items */
 const initialFetch = ref(false);
@@ -141,63 +152,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 +252,19 @@ 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
-            v-else-if="props.collectionType === 'list:paired'"
+        <PairedOrUnpairedListCollectionCreator
+            v-else-if="pairedOrUnpairedSupportedCollectionType"
             :history-id="props.historyId"
             :initial-elements="creatorItems || []"
             :default-hide-source-items="props.defaultHideSourceItems"
             :from-selection="fromSelection"
             :extensions="props.extensions"
-            @on-create="createListPairedCollection"
+            :collection-type="pairedOrUnpairedSupportedCollectionType"
+            mode="modal"
+            @on-create="createHDCA"
             @on-cancel="hideModal" />
         <PairCollectionCreator
             v-else-if="props.collectionType === 'paired'"
@@ -311,7 +273,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..cb8377eda4fd 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 { stripExtension, useUpdateIdentifiersForRemoveExtensions } from "./common/stripExtension";
+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");
@@ -45,13 +48,7 @@ const workingElements = ref<HDASummary[]>([]);
 const selectedDatasetElements = ref<string[]>([]);
 const atLeastOneElement = ref(true);
 
-const initialElementsById = computed(() => {
-    const byId = {} as Record<string, HistoryItemSummary>;
-    for (const initialElement of props.initialElements) {
-        byId[initialElement.id] = initialElement;
-    }
-    return byId;
-});
+const { updateIdentifierIfUnchanged } = useUpdateIdentifiersForRemoveExtensions(props);
 
 const atLeastOneDatasetIsSelected = computed(() => {
     return selectedDatasetElements.value.length > 0;
@@ -81,7 +78,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 */
@@ -161,29 +167,11 @@ function _validateElements() {
 }
 
 function removeExtensionsToggle() {
-    const byId = initialElementsById.value;
-
     removeExtensions.value = !removeExtensions.value;
-    if (removeExtensions.value) {
-        workingElements.value.forEach((el) => {
-            const oName = byId[el.id]?.name;
-            if (oName && el.name == oName) {
-                el.name = stripExtension(oName);
-            }
-        });
-    } else {
-        workingElements.value.forEach((el) => {
-            const originalName = byId[el.id]?.name;
-            console.log(originalName);
-            if (originalName) {
-                const strippedOriginalName = stripExtension(originalName);
-                if (strippedOriginalName && el.name == strippedOriginalName) {
-                    console.log("restoring... to" + originalName);
-                    el.name = originalName;
-                }
-            }
-        });
-    }
+    const removeExtensionsValue = removeExtensions.value;
+    workingElements.value.forEach((el) => {
+        updateIdentifierIfUnchanged(el, removeExtensionsValue);
+    });
     _mangleDuplicateNames();
 }
 
@@ -245,7 +233,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 +249,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 +395,15 @@ 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"
+                :mode="mode"
+                @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..d584f818db52 100644
--- a/client/src/components/Collections/ListWizard.vue
+++ b/client/src/components/Collections/ListWizard.vue
@@ -1,31 +1,61 @@
 <script setup lang="ts">
+import { BAlert } from "bootstrap-vue";
 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 { errorMessageAsString } from "@/utils/simple-error";
 
+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("");
+const creationError = ref<string | null>(null);
+const collectionCreated = ref(false);
 
+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 +65,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 +90,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 +113,185 @@ 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!");
+        collectionCreated.value = true;
+    } catch (e) {
+        creationError.value = errorMessageAsString(e);
+    }
+}
+
+type RuleCreationRequestT = {
+    name: string;
+    collectionType: string;
+    elementIdentifiers: CollectionElementIdentifiers;
+    hide_source_items: boolean;
+}[];
+
+async function ruleOnAttemptCreate(createRequest: RuleCreationRequestT) {
+    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>
-        <GenericWizard :use="wizard" :is-busy="isBusy" :submit-button-label="buildButtonLabel" @submit="submit">
+    <div v-if="currentHistoryId">
+        <div v-if="creationError">
+            <BAlert variant="danger">
+                {{ creationError }}
+            </BAlert>
+        </div>
+        <div v-if="collectionCreated">
+            <BAlert variant="success"> Collection created and it has been added to your history. </BAlert>
+        </div>
+        <GenericWizard v-else :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/PairedListCollectionCreator.test.js b/client/src/components/Collections/PairedListCollectionCreator.test.js
deleted file mode 100644
index d62270b04335..000000000000
--- a/client/src/components/Collections/PairedListCollectionCreator.test.js
+++ /dev/null
@@ -1,147 +0,0 @@
-import { createTestingPinia } from "@pinia/testing";
-import DATA from "@tests/test-data/paired-collection-creator.data.js";
-import { mount, shallowMount } from "@vue/test-utils";
-import PairedListCollectionCreator from "components/Collections/PairedListCollectionCreator";
-import flushPromises from "flush-promises";
-import Vue from "vue";
-
-import { useServerMock } from "@/api/client/__mocks__";
-
-// Mock the localize directive
-// (otherwise we get: [Vue warn]: Failed to resolve directive: localize)
-Vue.directive("localize", {
-    bind(el, binding) {
-        el.textContent = binding.value;
-    },
-});
-
-const { server, http } = useServerMock();
-
-describe("PairedListCollectionCreator", () => {
-    let wrapper;
-    const pinia = createTestingPinia();
-
-    beforeEach(() => {
-        server.use(
-            http.get("/api/configuration", ({ response }) => {
-                return response(200).json({
-                    chunk_upload_size: 100,
-                    file_sources_configured: true,
-                });
-            })
-        );
-    });
-
-    it("performs an autopair on startup if we have a selection", async () => {
-        // Kind of deprecated because we are never using `props.fromSelection: true` anywhere
-
-        wrapper = shallowMount(PairedListCollectionCreator, {
-            propsData: {
-                historyId: "history_id",
-                initialElements: DATA._1,
-                fromSelection: true,
-            },
-            pinia,
-        });
-
-        await flushPromises();
-        // Autopair is called on startup
-        const pairsCountDisplay = wrapper.find('[data-description="number of pairs"]');
-        expect(pairsCountDisplay.text()).toContain(`${DATA._1.length / 2} pairs`);
-    });
-
-    it("selects the correct name for an autopair", async () => {
-        wrapper = mount(PairedListCollectionCreator, {
-            propsData: {
-                historyId: "history_id",
-                initialElements: DATA._2,
-            },
-            pinia,
-            stubs: {
-                FontAwesomeIcon: true,
-                BPopover: true,
-            },
-        });
-
-        await flushPromises();
-        //change filter to .1.fastq/.2.fastq
-        await wrapper.find("div.forward-unpaired-filter > div.input-group-append > button").trigger("click");
-        await wrapper
-            .findAll("div.dropdown-menu > a.dropdown-item")
-            .wrappers.find((e) => e.text() == ".1.fastq")
-            .trigger("click");
-        //assert forward filter
-        const forwardFilter = wrapper.find("div.forward-unpaired-filter > input").element.value;
-        expect(forwardFilter).toBe(".1.fastq");
-        //assert reverse filter
-        const reverseFilter = wrapper.find("div.reverse-unpaired-filter > input").element.value;
-        expect(reverseFilter).toBe(".2.fastq");
-        // click Autopair
-        await wrapper.find(".autopair-link").trigger("click");
-        //assert pair-name longer name
-        const pairname = wrapper.find("span.pair-name");
-        expect(pairname.text()).toBe("DP134_1_FS_PSII_FSB_42C_A10");
-    });
-
-    it("removes the period from autopair name", async () => {
-        wrapper = mount(PairedListCollectionCreator, {
-            propsData: {
-                historyId: "history_id",
-                initialElements: DATA._3,
-            },
-            pinia,
-            stubs: {
-                FontAwesomeIcon: true,
-                BPopover: true,
-            },
-        });
-
-        await flushPromises();
-        //change filter to .1.fastq/.2.fastq
-        await wrapper.find("div.forward-unpaired-filter > div.input-group-append > button").trigger("click");
-        await wrapper
-            .findAll("div.dropdown-menu > a.dropdown-item")
-            .wrappers.find((e) => e.text() == ".1.fastq")
-            .trigger("click");
-        //assert forward filter
-        const forwardFilter = wrapper.find("div.forward-unpaired-filter > input").element.value;
-        expect(forwardFilter).toBe(".1.fastq");
-        //assert reverse filter
-        const reverseFilter = wrapper.find("div.reverse-unpaired-filter > input").element.value;
-        expect(reverseFilter).toBe(".2.fastq");
-        // click Autopair
-        await wrapper.find(".autopair-link").trigger("click");
-        //assert pair-name longer name
-        const pairname = wrapper.find("span.pair-name");
-        expect(pairname.text()).toBe("UII_moo_1");
-    });
-
-    it("autopairs correctly when filters are typed in", async () => {
-        wrapper = mount(PairedListCollectionCreator, {
-            propsData: {
-                historyId: "history_id",
-                initialElements: DATA._4,
-            },
-            pinia,
-            stubs: {
-                FontAwesomeIcon: true,
-                BPopover: true,
-            },
-        });
-
-        await flushPromises();
-        //change filter to _R1/_R2
-        await wrapper.find("div.forward-unpaired-filter > input").setValue("_R1");
-        await wrapper.find("div.reverse-unpaired-filter > input").setValue("_R2");
-        //assert forward filter
-        const forwardFilter = wrapper.find("div.forward-unpaired-filter > input").element.value;
-        expect(forwardFilter).toBe("_R1");
-        //assert reverse filter
-        const reverseFilter = wrapper.find("div.reverse-unpaired-filter > input").element.value;
-        expect(reverseFilter).toBe("_R2");
-        // click Autopair
-        await wrapper.find(".autopair-link").trigger("click");
-        //assert all pairs matched
-        expect(wrapper.findAll("li.dataset unpaired").length == 0).toBeTruthy();
-    });
-});
diff --git a/client/src/components/Collections/PairedOrUnpairedComponents.ts b/client/src/components/Collections/PairedOrUnpairedComponents.ts
new file mode 100644
index 000000000000..f974a34bc55a
--- /dev/null
+++ b/client/src/components/Collections/PairedOrUnpairedComponents.ts
@@ -0,0 +1,13 @@
+// Vue 2.7 <-> AG Grid - legacy stuff
+// see comments around "export default {" in PairedOrUnpairedListCollectionCreator
+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";
+
+export const components = {
+    CellDiscardComponent,
+    CellStatusComponent,
+    PairedDatasetCellComponent,
+    CollectionCreator,
+};
diff --git a/client/src/components/Collections/PairedOrUnpairedListCollectionCreator.vue b/client/src/components/Collections/PairedOrUnpairedListCollectionCreator.vue
new file mode 100644
index 000000000000..1a1f5ac12396
--- /dev/null
+++ b/client/src/components/Collections/PairedOrUnpairedListCollectionCreator.vue
@@ -0,0 +1,684 @@
+<script setup lang="ts">
+import { type ColDef, type GetRowIdParams, type IRowDragItem, type NewValueParams } from "ag-grid-community";
+import { BAlert, 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 { stripExtension, useUpdateIdentifiersForRemoveExtensions } from "./common/stripExtension";
+import {
+    type SupportedPairedOrPairedBuilderCollectionTypes,
+    useCollectionCreator,
+} from "./common/useCollectionCreator";
+import { usePairingSummary } from "./common/usePairingSummary";
+import { type AutoPairingResult, autoPairWithCommonFilters, guessNameForPair } from "./pairing";
+
+import AutoPairing from "./common/AutoPairing.vue";
+import PairedOrUnpairedListCreatorHelp from "./PairedOrUnpairedListCreatorHelp.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 { updateIdentifierIfUnchanged } = useUpdateIdentifiersForRemoveExtensions(props);
+
+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>(props);
+
+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,
+});
+
+type StatusType = "ok" | "duplicate" | "requires_pairing";
+
+type UnpairedDataset = { unpaired: HistoryItemSummary };
+
+interface RowT {
+    id: string;
+    datasets: GenericPair<HistoryItemSummary> | UnpairedDataset;
+    identifier: string;
+    outerIdentifier?: string;
+    status: StatusType;
+}
+
+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) {
+    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) {
+        if (item.status == "ok") {
+            item.status = isDuplicate[item.identifier] ? "duplicate" : "ok";
+        }
+    }
+    if (refresh) {
+        _refresh();
+        gridApi.value?.redrawRows();
+    }
+    return anyDuplicated;
+}
+
+function unpairedRow(item: HistoryItemSummary): RowT {
+    let name = item.name || "";
+    if (removeExtensions.value) {
+        name = stripExtension(name);
+    }
+    let status: StatusType = "ok";
+    if (props.collectionType.endsWith(":paired")) {
+        status = "requires_pairing";
+    }
+    return { identifier: name || "", datasets: { unpaired: item }, id: item.id, status: status };
+}
+
+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() {
+    return (rowData.value || []).map((v) => {
+        if ("forward" in v.datasets) {
+            const previousRemoveExtensions = !removeExtensions.value;
+            const previousUnchangedIdentifier = guessNameForPair(
+                v.datasets.forward,
+                v.datasets.reverse,
+                currentForwardFilter.value || "",
+                currentReverseFilter.value || "",
+                previousRemoveExtensions
+            );
+            if (v.identifier == previousUnchangedIdentifier) {
+                v.identifier = guessNameForPair(
+                    v.datasets.forward,
+                    v.datasets.reverse,
+                    currentForwardFilter.value || "",
+                    currentReverseFilter.value || "",
+                    removeExtensions.value
+                );
+            }
+        } else {
+            updateIdentifierIfUnchanged(v, removeExtensions.value);
+        }
+    });
+}
+
+function removeExtensionsToggle() {
+    removeExtensions.value = !removeExtensions.value;
+    updatePairNames();
+    _refresh();
+    gridApi.value?.redrawRows();
+}
+
+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 pairedListIdentifiers(): 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 = pairedListIdentifiers();
+    }
+    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 nameForPair = guessNameForPair(
+            forward,
+            reverse,
+            currentForwardFilter.value || "",
+            currentReverseFilter.value || "",
+            removeExtensions.value
+        );
+        const pair = { forward, reverse, name: nameForPair };
+        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;
+}
+
+const unpairedProblemDatasetCount = computed(() => {
+    if (!props.collectionType.endsWith(":paired")) {
+        return 0;
+    }
+    let count = 0;
+    rowData.value.forEach((v) => {
+        if ("unpaired" in v.datasets) {
+            count += 1;
+        }
+    });
+    return count;
+});
+
+function dismissUnmatchedDatasets() {
+    const toRemove: UnpairedDataset[] = [];
+    rowData.value.forEach((v) => {
+        if ("unpaired" in v.datasets) {
+            toRemove.push(v.datasets);
+        }
+    });
+    toRemove.forEach((v) => {
+        onRemove(v, false);
+    });
+    _refresh();
+}
+
+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;
+    }
+}
+
+function rowDragText(params: IRowDragItem) {
+    return params.rowNode?.data.identifier;
+}
+
+const context = {
+    pinia,
+    onPair,
+    onUnpair,
+    onRemove,
+    onSwap,
+};
+</script>
+
+<script lang="ts">
+// eslint-disable-next-line import/first
+import { components as VueComponents } from "./PairedOrUnpairedComponents";
+
+// 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: VueComponents,
+};
+</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"
+            :mode="mode"
+            @on-update-collection-name="onUpdateCollectionName"
+            @add-uploaded-files="addUploadedFiles"
+            @onUpdateHideSourceItems="onUpdateHideSourceItems"
+            @clicked-create="attemptCreate"
+            @remove-extensions-toggle="removeExtensionsToggle">
+            <template v-slot:help-content>
+                <PairedOrUnpairedListCreatorHelp
+                    :from-selection="props.fromSelection"
+                    :collection-type="props.collectionType"
+                    :mode="mode" />
+            </template>
+            <template v-slot:middle-content>
+                <div>
+                    <BRow v-if="!flatLists">
+                        <BCol>
+                            <BAlert show variant="info" dismissible>
+                                {{ summaryText }}
+                                If this isn't correct,
+                                <BLink style="font-weight: bold" @click="goToAutoPairing">configure auto-pairing</BLink
+                                >.
+                            </BAlert>
+                        </BCol>
+                    </BRow>
+                    <BRow v-if="unpairedProblemDatasetCount > 0">
+                        <BCol>
+                            <BAlert show variant="warning" dismissible>
+                                {{ unpairedProblemDatasetCount }} unmatched datasets, these should be either dismissed
+                                or paired off.
+                                <BLink style="font-weight: bold" @click="dismissUnmatchedDatasets"
+                                    >Click here to discard all remaining unpaired datasets.</BLink
+                                >
+                            </BAlert>
+                        </BCol>
+                    </BRow>
+                    <div :style="style" :class="theme">
+                        <AgGridVue
+                            :row-drag-managed="true"
+                            :row-drag-text="rowDragText"
+                            :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/PairedOrUnpairedListCreatorHelp.vue b/client/src/components/Collections/PairedOrUnpairedListCreatorHelp.vue
new file mode 100644
index 000000000000..899d564b674d
--- /dev/null
+++ b/client/src/components/Collections/PairedOrUnpairedListCreatorHelp.vue
@@ -0,0 +1,115 @@
+<script setup lang="ts">
+// TODO: configure pairing link...
+import { faGripHorizontal, faLink, faTimes, faUndo, faUnlink } from "@fortawesome/free-solid-svg-icons";
+import { FontAwesomeIcon } from "@fortawesome/vue-fontawesome";
+import { BCol, BRow } from "bootstrap-vue";
+import { computed } from "vue";
+
+import { type SupportedPairedOrPairedBuilderCollectionTypes } from "./common/useCollectionCreator";
+
+interface Props {
+    fromSelection?: boolean;
+    collectionType: SupportedPairedOrPairedBuilderCollectionTypes;
+    mode: "wizard" | "modal";
+}
+
+const props = defineProps<Props>();
+
+const usesPairing = computed(() => {
+    return props.collectionType.indexOf("paired") !== -1;
+});
+const requiresPairing = computed(() => {
+    return props.collectionType.endsWith("paired");
+});
+</script>
+
+<template>
+    <BRow>
+        <BCol>
+            <p v-if="collectionType == 'list:paired'" data-description="what is being built">
+                This interface allows you to build a new Galaxy list of pairs. List of pairs are an ordered list of
+                individual datasets paired together in their own paired collection (often forward and reverse reads).
+            </p>
+            <p v-else-if="collectionType == 'list:list:paired'" data-description="what is being built">
+                This interface allows you to build a new Galaxy nested list of pairs. A nested list of pairs are a
+                nested list of individual lists. Each these inner lists consists of elements which are datasets paired
+                together in their own paired collection (often forward and reverse reads).
+            </p>
+            <p v-else-if="collectionType == 'list:list'" data-description="what is being built">
+                This interface allows you to build a new Galaxy nested list. A nested list is a list where each element
+                is in turn a list of datasets. Each dataset in this structure has an inner and outer element identifier
+                that together uniquely identify it and these identifiers are preserved through an analysis.
+            </p>
+            <p v-else-if="collectionType == 'list:paired_or_unpaired'" data-description="what is being built">
+                This interface allows you to build a new Galaxy list of mixed paired and unpaired datasets. In general,
+                tools are better at using a flat list or a list of pairs, so this mixed version should only be used if
+                you have an analysis and data that requires paired and unpaired data to be processed together in a
+                uniform way.
+            </p>
+            <p data-description="info about lists">
+                These lists can be passed to tools and workflows in order to have analyses done on each member of the
+                entire group. This interface allows you to create such a list, choose the structure, assign list
+                identifiers, and re-order the final collection.
+            </p>
+            <p v-if="usesPairing">
+                Any rows corresponding to datasets or pairs of datasets that should not be included in the resulting
+                list can be discarded by click the <FontAwesomeIcon :icon="faTimes" />
+                icon in that row.
+            </p>
+            <p v-else>
+                Any datasets that should not be included in the resulting list can be discarded by click the
+                <FontAwesomeIcon :icon="faTimes" /> icon in that row.
+            </p>
+            <p data-description="what is included in the final collection">
+                <span v-if="usesPairing">
+                    Each row in the table below corresponds to a dataset or a pair of datasets. Galaxy attempts to
+                    auto-pair your datasets but this can be controlled or pairing can be done manually using the
+                    controls below.
+                    <span v-if="requiresPairing">
+                        Any individual datasets that are unmatched will not be included in the final list.
+                    </span>
+                    <span v-else>
+                        Any individual datasets that are unmatched will be included in the final list as a single
+                        'unpaired' dataset.
+                    </span>
+                </span>
+                <span v-else>
+                    Each row in the table corresponds to a dataset. Any datasets not discarded will be a member of the
+                    resulting collection.
+                </span>
+            </p>
+            <p data-description="more about pairing">
+                If the Galaxy auto-pairing is off, it can be configured using regular expressions by clicking on the
+                "configure auto-pairing" link in the summary box above the grid
+                <span v-if="mode == 'modal'"> below or just navigating to the previous step of this wizard. </span>
+                <span v-else> below. </span>
+                <span>
+                    If your datasets are not named with a pattern that would allow doing this, the pairing can be
+                    configured manually. This can be done by clicking the
+                    <FontAwesomeIcon :icon="faLink" /> on one dataset and dragging on top of the
+                    <FontAwesomeIcon :icon="faLink" /> of the other dataset to be paired. If the pairing direction is
+                    wrong, the forward is labelled reverse or the first and second dataset are wrong - this can be
+                    corrected by simply clicking the <FontAwesomeIcon :icon="faUndo" /> icon to swap them. If datasets
+                    are mis-paired, either automatically by Galaxy or by mis-clicking, simply click the
+                    <FontAwesomeIcon :icon="faUnlink" />
+                    to unlink the row and turn a dataset pair into two individual datasets.
+                </span>
+            </p>
+            <p data-description="element identifiers">
+                Each element of the final list should have a unique list identifier. This builder will warn you if there
+                are duplicate identifiers found and will require you to fix them before a list can be created. You can
+                change guessed list identifier by double clicking on the value in the grid and changing the text. This
+                list identifier is preserved as you run tools over the elements of your collection - so it is best to
+                strip extensions like <code>.fq</code>, <code>.bam</code>, etc. from your collection identifiers.
+            </p>
+            <p data-description="element order">
+                The order of elements in the collection will also be preserved as your run tools over the collection and
+                some tools and workflows will consume multiple collections together and expect elements to match up in
+                specific ways. If any of these are concerns for your data, you can sort the list. The order in the grid
+                below will be the order they appear in the final collection. You can sort by list identifier by clicking
+                on the column header for that column. Alternatively, you can manually reorder a row by clicking on the
+                <FontAwesomeIcon :icon="faGripHorizontal" /> and dragging the row up or down to the desired location.
+            </p>
+        </BCol>
+    </BRow>
+</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..3ce23ce9bd41
--- /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>(props);
+
+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..73698bcb26b2
--- /dev/null
+++ b/client/src/components/Collections/common/CellStatusComponent.vue
@@ -0,0 +1,77 @@
+<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";
+        },
+        requiresPairing() {
+            return this.params.value == "requires_pairing";
+        },
+        statusClass() {
+            if (this.isDuplicate || this.requiresPairing) {
+                return "status-warn";
+            } else {
+                return "status-ok";
+            }
+        },
+        popoverContent() {
+            if (this.isDuplicate) {
+                return "This element has a duplicate identifier with another element, please edit one or the other by double clicking on the identifier value in the table and changing it.";
+            } else if (this.requiresPairing) {
+                return "This dataset must be paired or it will not be included in the final list.";
+            } else {
+                return "This element is ok and will be included in the generated list.";
+            }
+        },
+        icon() {
+            if (this.isDuplicate || this.requiresPairing) {
+                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="Status" triggers="hover focus" :content="popoverContent"></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..f381a45b1a3e 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,8 @@ interface Props {
     collectionType?: string;
     showUpload: boolean;
     showButtons?: boolean;
+    collectionName: string;
+    mode: "wizard" | "modal";
 }
 
 const props = withDefaults(defineProps<Props>(), {
@@ -46,9 +49,11 @@ const props = withDefaults(defineProps<Props>(), {
     extensionsToggle: false,
     showUpload: true,
     showButtons: true,
+    mode: "modal",
 });
 
 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 +62,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 +136,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>
@@ -146,7 +163,7 @@ watch(
                 <CollectionCreatorNoItemsMessage @click-upload="currentTab = Tabs.upload" />
             </div>
             <div v-else>
-                <CollectionCreatorHelpHeader>
+                <CollectionCreatorHelpHeader :mode="mode">
                     <slot name="help-content"></slot>
                 </CollectionCreatorHelpHeader>
 
@@ -165,8 +182,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>
 
@@ -185,7 +203,7 @@ watch(
                     <CollectionCreatorNoItemsMessage @click-upload="currentTab = Tabs.upload" />
                 </div>
                 <div v-else>
-                    <CollectionCreatorHelpHeader>
+                    <CollectionCreatorHelpHeader :mode="mode">
                         <slot name="help-content"></slot>
                     </CollectionCreatorHelpHeader>
 
@@ -203,8 +221,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>
 
@@ -413,13 +432,17 @@ $fa-font-path: "../../../../node_modules/@fortawesome/fontawesome-free/webfonts/
                 .help-content {
                     p:first-child {
                         overflow: hidden;
-                        white-space: nowrap;
                         text-overflow: ellipsis;
                     }
                     > *:not(:first-child) {
                         display: none;
                     }
                 }
+                .help-content-nowrap {
+                    p:first-child {
+                        white-space: nowrap;
+                    }
+                }
             }
             &.expanded {
                 max-height: none;
diff --git a/client/src/components/Collections/common/CollectionCreatorHelpHeader.vue b/client/src/components/Collections/common/CollectionCreatorHelpHeader.vue
index 2564230253d3..0a96abe18ab3 100644
--- a/client/src/components/Collections/common/CollectionCreatorHelpHeader.vue
+++ b/client/src/components/Collections/common/CollectionCreatorHelpHeader.vue
@@ -1,16 +1,30 @@
 <script setup lang="ts">
 import { faChevronDown, faChevronUp } from "@fortawesome/free-solid-svg-icons";
 import { FontAwesomeIcon } from "@fortawesome/vue-fontawesome";
-import { ref } from "vue";
+import { computed, ref } from "vue";
 
 import localize from "@/utils/localization";
 
+interface Props {
+    mode: "wizard" | "modal";
+}
+
+const props = defineProps<Props>();
+
 const isExpanded = ref(false);
 
 function clickForHelp() {
     isExpanded.value = !isExpanded.value;
     return isExpanded.value;
 }
+
+const helpContentClasses = computed(() => {
+    const classes = ["help-content"];
+    if (props.mode == "modal") {
+        classes.push("help-content-nowrap");
+    }
+    return classes;
+});
 </script>
 
 <template>
@@ -32,7 +46,7 @@ function clickForHelp() {
                 </div>
             </a>
 
-            <div class="help-content">
+            <div :class="helpContentClasses">
                 <!-- each collection that extends this will add their own help content -->
                 <slot></slot>
 
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/stripExtension.ts b/client/src/components/Collections/common/stripExtension.ts
index 8d4317103310..261b9c5280ee 100644
--- a/client/src/components/Collections/common/stripExtension.ts
+++ b/client/src/components/Collections/common/stripExtension.ts
@@ -1,3 +1,7 @@
+import { computed } from "vue";
+
+import type { HistoryItemSummary } from "@/api";
+
 export function stripExtension(filename_: string): string {
     let filename = filename_;
     let strippedSecondaryExtension = false;
@@ -32,3 +36,59 @@ export function stripExtension(filename_: string): string {
 
     return filename;
 }
+
+interface HasInitialItemsProp {
+    initialElements: HistoryItemSummary[];
+}
+
+interface HasNameAndIdentifier {
+    id: string;
+    identifier: string | null;
+}
+
+export function useUpdateIdentifiersForRemoveExtensions(props: HasInitialItemsProp) {
+    const initialElementsById = computed(() => {
+        const byId = {} as Record<string, HistoryItemSummary>;
+        for (const initialElement of props.initialElements) {
+            byId[initialElement.id] = initialElement;
+        }
+        return byId;
+    });
+
+    function updateIdentifierIfUnchanged(
+        element: HistoryItemSummary | HasNameAndIdentifier,
+        updatedRemoveExtensions: boolean
+    ) {
+        const byId = initialElementsById.value;
+        const originalName = byId[element.id]?.name;
+
+        if (updatedRemoveExtensions) {
+            // switching from not remove extensions to remove extensions
+            const originalName = byId[element.id]?.name;
+            if ("name" in element) {
+                if (originalName && element.name == originalName) {
+                    element.name = stripExtension(originalName);
+                }
+            } else {
+                if (originalName && element.identifier == originalName) {
+                    element.identifier = stripExtension(originalName);
+                }
+            }
+        } else {
+            if (originalName) {
+                const strippedOriginalName = stripExtension(originalName);
+                if ("name" in element) {
+                    if (strippedOriginalName && element.name == strippedOriginalName) {
+                        element.name = originalName;
+                    }
+                } else {
+                    if (strippedOriginalName && element.identifier == strippedOriginalName) {
+                        element.identifier = originalName;
+                    }
+                }
+            }
+        }
+    }
+
+    return { updateIdentifierIfUnchanged, initialElementsById };
+}
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..dae3cc9ff24d
--- /dev/null
+++ b/client/src/components/Collections/common/usePairingSummary.ts
@@ -0,0 +1,41 @@
+import { computed, ref } from "vue";
+
+import { type AutoPairingResult, type HasName, splitIntoPairedAndUnpaired } from "@/components/Collections/pairing";
+
+import { type SupportedPairedOrPairedBuilderCollectionTypes } from "./useCollectionCreator";
+
+interface PropsWithCollectionType {
+    collectionType: SupportedPairedOrPairedBuilderCollectionTypes;
+}
+
+export function usePairingSummary<T extends HasName>(props: PropsWithCollectionType) {
+    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 && props.collectionType.endsWith("paired")) {
+                numUnmatchedText = `${numUnmatched} dataset(s) were not paired and will not be included in the resulting list of pairs.`;
+            } else if (numUnmatched > 0) {
+                numUnmatchedText = `${numUnmatched} dataset(s) were not paired and will be included in the resulting list as unpaired datasets.`;
+            }
+            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/Form/Elements/FormData/FormData.vue b/client/src/components/Form/Elements/FormData/FormData.vue
index b13dd87ae8e9..902173f1717f 100644
--- a/client/src/components/Form/Elements/FormData/FormData.vue
+++ b/client/src/components/Form/Elements/FormData/FormData.vue
@@ -15,6 +15,7 @@ import { computed, onMounted, type Ref, ref, watch } from "vue";
 
 import { isDatasetElement, isDCE } from "@/api";
 import { getGalaxyInstance } from "@/app";
+import type { CollectionType } from "@/components/History/adapters/buildCollectionModal";
 import { useDatatypesMapper } from "@/composables/datatypesMapper";
 import { useUid } from "@/composables/utils/uid";
 import { type EventData, useEventStore } from "@/stores/eventStore";
@@ -88,7 +89,7 @@ const dragTarget: Ref<EventTarget | null> = ref(null);
 
 // Collection creator modal settings
 const collectionModalShow = ref(false);
-const collectionModalType = ref<"list" | "list:paired" | "paired">("list");
+const collectionModalType = ref<CollectionType>("list");
 const { currentHistoryId } = storeToRefs(useHistoryStore());
 const restrictsExtensions = computed(() => {
     const extensions = props.extensions;
@@ -497,7 +498,14 @@ function canAcceptSrc(historyContentType: "dataset" | "dataset_collection", coll
     }
 }
 
-const collectionTypesWithBuilders = ["list", "list:paired", "paired"];
+const collectionTypesWithBuilders = [
+    "list",
+    "list:paired",
+    "paired",
+    "list:list",
+    "list:list:paired",
+    "list:paired_or_unpaired",
+];
 
 /** Allowed collection types for collection creation */
 const effectiveCollectionTypes = props.collectionTypes?.filter((collectionType) =>
@@ -508,7 +516,7 @@ function buildNewCollection(collectionType: string) {
     if (!collectionTypesWithBuilders.includes(collectionType)) {
         throw Error(`Unknown collection type: ${collectionType}`);
     }
-    collectionModalType.value = collectionType as "list" | "list:paired" | "paired";
+    collectionModalType.value = collectionType as CollectionType;
     collectionModalShow.value = true;
 }
 
diff --git a/client/src/components/History/Content/Collection/CollectionDescription.vue b/client/src/components/History/Content/Collection/CollectionDescription.vue
index af91aeef5a9e..7bfe378878b6 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:paired_or_unpaired", "list"],
     ["list:list", "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..c978c95b8cfc 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=${advanced}` });
         },
         // 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/adapters/buildCollectionModal.ts b/client/src/components/History/adapters/buildCollectionModal.ts
index cf1b24ba8ebe..890d489abf4b 100644
--- a/client/src/components/History/adapters/buildCollectionModal.ts
+++ b/client/src/components/History/adapters/buildCollectionModal.ts
@@ -14,7 +14,14 @@ import jQuery from "jquery";
 import type { HDASummary, HistoryItemSummary } from "@/api";
 import RULE_BASED_COLLECTION_CREATOR from "@/components/Collections/RuleBasedCollectionCreatorModal";
 
-export type CollectionType = "list" | "paired" | "list:paired" | "rules";
+export type CollectionType =
+    | "list"
+    | "paired"
+    | "list:paired"
+    | "rules"
+    | "list:paired_or_unpaired"
+    | "list:list"
+    | "list:list:paired";
 
 interface HasName {
     name: string | null;
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/Forms/FormCollectionType.vue b/client/src/components/Workflow/Editor/Forms/FormCollectionType.vue
index 6714e6e6c711..f337d2d48c5a 100644
--- a/client/src/components/Workflow/Editor/Forms/FormCollectionType.vue
+++ b/client/src/components/Workflow/Editor/Forms/FormCollectionType.vue
@@ -25,6 +25,7 @@ const collectionTypeOptions = [
     { value: "record", label: "Record" },
     { value: "list:record", label: "List of Records" },
     { value: "list:paired", label: "List of Dataset Pairs" },
+    { value: "list:paired_or_unpaired", label: "Mixed List of Paired and Unpaired Datasets" },
 ];
 
 function updateValue(newValue: string | undefined) {
diff --git a/client/src/components/Workflow/Editor/modules/collectionTypeDescription.ts b/client/src/components/Workflow/Editor/modules/collectionTypeDescription.ts
index 582823aedb9c..5b80fe20a27c 100644
--- a/client/src/components/Workflow/Editor/modules/collectionTypeDescription.ts
+++ b/client/src/components/Workflow/Editor/modules/collectionTypeDescription.ts
@@ -85,31 +85,111 @@ 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 (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.endsWith("paired");
+            }
+            if (other.collectionType.endsWith(":paired_or_unpaired")) {
+                return !this.collectionType.endsWith(":paired");
+            }
+            if (this.rank == other.rank) {
+                console.log("skipping over this because may be equal rank...");
+            }
             // Cannot map over self...
             return false;
         }
         const requiredSuffix = other.collectionType;
-        return this._endsWith(this.collectionType, requiredSuffix);
+        const directMatch = this._endsWith(this.collectionType, `:${requiredSuffix}`);
+        if (directMatch) {
+            return true;
+        }
+        // this really needs to be extended to include anything suffixed with :paired_or_unpaired
+        if (requiredSuffix == "paired_or_unpaired") {
+            // anything can be mapped over this since it can always act a dataset
+            return true;
+        } else if (requiredSuffix.endsWith(":paired_or_unpaired")) {
+            const higherRanksRequired = requiredSuffix.substring(0, requiredSuffix.lastIndexOf(":"));
+            let higherRanks: string;
+            if (this.collectionType.endsWith(":paired")) {
+                higherRanks = this.collectionType.substring(0, this.collectionType.lastIndexOf(":"));
+            } else {
+                higherRanks = this.collectionType;
+            }
+            return this._endsWith(higherRanks, higherRanksRequired);
+        }
+        return false;
     }
     effectiveMapOver(other: CollectionTypeDescriptor): CollectionTypeDescriptor {
+        const thisCollectionType = this.collectionType;
         if (other.collectionType && this.canMapOver(other)) {
             const otherCollectionType = other.collectionType;
-            const effectiveCollectionType = this.collectionType.substring(
+            // needs to be extended to include ending in :paired_or_unpaired.
+            if (otherCollectionType.endsWith("paired_or_unpaired")) {
+                if (otherCollectionType == "paired_or_unpaired") {
+                    if (thisCollectionType.endsWith("list")) {
+                        // the elements of the inner most list are consumed by the
+                        // paired_or_unpaired input.
+                        return new CollectionTypeDescription(thisCollectionType);
+                    }
+                    return new CollectionTypeDescription(
+                        thisCollectionType.substring(0, thisCollectionType.lastIndexOf(":"))
+                    );
+                } else if (thisCollectionType.endsWith(":paired") || thisCollectionType.endsWith(":list")) {
+                    // otherCollectionType endswith :paired_or_unpaired
+                    let currentCollectionType = thisCollectionType;
+                    let currentOther = otherCollectionType;
+                    while (currentOther.lastIndexOf(":") !== -1) {
+                        currentOther = currentOther.substring(0, currentOther.lastIndexOf(":"));
+                        currentCollectionType = currentCollectionType.substring(
+                            0,
+                            currentCollectionType.lastIndexOf(":")
+                        );
+                    }
+                    // and strip the last rank off for the remaining currentOther if
+                    // the paired_or_unpaired consumed the inner paired collection
+                    if (thisCollectionType.endsWith(":paired")) {
+                        currentCollectionType = currentCollectionType.substring(
+                            0,
+                            currentCollectionType.lastIndexOf(":")
+                        );
+                    } else {
+                        // this was a list so paired_or_unpaired will consume the datasets of the
+                        // inner list and we can just stop here.
+                    }
+                    return new CollectionTypeDescription(currentCollectionType);
+                }
+            }
+            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..579219cc454b 100644
--- a/client/src/components/Workflow/Editor/modules/terminals.test.ts
+++ b/client/src/components/Workflow/Editor/modules/terminals.test.ts
@@ -116,6 +116,7 @@ describe("terminalFactory", () => {
         expect(terminals["optional data input"]?.["output"]).toBeInstanceOf(OutputTerminal);
         expect(terminals["list input"]?.["output"]).toBeInstanceOf(OutputCollectionTerminal);
         expect(terminals["list:list input"]?.["output"]).toBeInstanceOf(OutputCollectionTerminal);
+        expect(terminals["list:list:paired input"]?.["output"]).toBeInstanceOf(OutputCollectionTerminal);
         expect(terminals["paired input"]?.["output"]).toBeInstanceOf(OutputCollectionTerminal);
         expect(terminals["multi data"]?.["f1"]).toBeInstanceOf(InputTerminal);
         expect(terminals["multi data"]?.["f2"]).toBeInstanceOf(InputTerminal);
@@ -126,6 +127,9 @@ describe("terminalFactory", () => {
         expect(terminals["any collection"]?.["output"]).toBeInstanceOf(OutputCollectionTerminal);
         expect(terminals["multi data"]?.["advanced|advanced_threshold"]).toBeInstanceOf(InputParameterTerminal);
         expect(terminals["list collection input"]?.["input1"]).toBeInstanceOf(InputCollectionTerminal);
+        expect(terminals["paired collection input"]?.["f1"]).toBeInstanceOf(InputCollectionTerminal);
+        expect(terminals["paired_or_unpaired collection input"]?.["f1"]).toBeInstanceOf(InputCollectionTerminal);
+        expect(terminals["list:paired_or_unpaired collection input"]?.["f1"]).toBeInstanceOf(InputCollectionTerminal);
         expect(terminals["filter_failed"]?.["input"]).toBeInstanceOf(InputCollectionTerminal);
         expect(terminals["filter_failed"]?.["output"]).toBeInstanceOf(OutputCollectionTerminal);
     });
@@ -209,6 +213,193 @@ 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 list:paired_or_unpaired data -> list:paired_or_unpaired connection", () => {
+        const collectionOut = terminals["list:paired_or_unpaired input"]!["output"] as OutputCollectionTerminal;
+        const dataIn = terminals["list: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);
+    });
+    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 -> paired connection", () => {
+        const collectionOut = terminals["list:paired input"]!["output"] as OutputCollectionTerminal;
+        const dataIn = terminals["paired 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);
+    });
+    it("accepts list:paired -> paired_or_unpaired connection", () => {
+        const collectionOut = terminals["list: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).toEqual({ collectionType: "list", isCollection: true, rank: 1 });
+        expect(dataIn.canAccept(collectionOut).canAccept).toBe(false);
+    });
+    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 list:list:paired -> paired_or_unpaired connection", () => {
+        const collectionOut = terminals["list:list: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).toEqual({ collectionType: "list:list", isCollection: true, rank: 2 });
+        expect(dataIn.canAccept(collectionOut).canAccept).toBe(false);
+    });
+    it("accepts list:list:paired -> list:paired_or_unpaired connection", () => {
+        const collectionOut = terminals["list:list:paired input"]!["output"] as OutputCollectionTerminal;
+        const dataIn = terminals["list:paired_or_unpaired collection input"]!["f1"] as InputCollectionTerminal;
+        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);
+    });
+    it("accepts list:list -> paired_or_unpaired connection", () => {
+        const collectionOut = terminals["list:list input"]!["output"] as OutputCollectionTerminal;
+        const dataIn = terminals["paired_or_unpaired collection input"]!["f1"] as InputCollectionTerminal;
+        expect(dataIn.mapOver).toBe(NULL_COLLECTION_TYPE_DESCRIPTION);
+        expect(dataIn.canAccept(collectionOut).canAccept).toBe(true);
+        dataIn.connect(collectionOut);
+        expect(dataIn.mapOver).toEqual({ collectionType: "list:list", isCollection: true, rank: 2 });
+        expect(dataIn.canAccept(collectionOut).canAccept).toBe(false);
+    });
+    it("accepts list:list -> list:paired_or_unpaired connection", () => {
+        const collectionOut = terminals["list:list input"]!["output"] as OutputCollectionTerminal;
+        const dataIn = terminals["list:paired_or_unpaired collection input"]!["f1"] as InputCollectionTerminal;
+        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);
+    });
+    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("accepts paired -> paired connection", () => {
+        const collectionOut = terminals["paired input"]!["output"] as OutputCollectionTerminal;
+        const dataIn = terminals["paired 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);
+    });
+    it("accepts list -> list connection", () => {
+        const collectionOut = terminals["list input"]!["output"] as OutputCollectionTerminal;
+        const dataIn = terminals["list collection input"]!["input1"] 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);
+    });
+    it("accepts list:paired -> list:paired connection", () => {
+        const collectionOut = terminals["list:paired input"]!["output"] as OutputCollectionTerminal;
+        const dataIn = terminals["list:paired collection input"]!["input1"] as InputCollectionTerminal;
+        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);
+    });
+    it("rejects paired:paired -> list:paired connection", () => {
+        const collectionOut = terminals["paired:paired input"]!["output"] as OutputCollectionTerminal;
+        const dataIn = terminals["list:paired collection input"]!["input1"] as InputCollectionTerminal;
+        expect(dataIn.mapOver).toBe(NULL_COLLECTION_TYPE_DESCRIPTION);
+        expect(dataIn.canAccept(collectionOut).canAccept).toBe(false);
+    });
+    it("rejects paired:paired -> list:paired_or_unpaired connection", () => {
+        const collectionOut = terminals["paired:paired input"]!["output"] as OutputCollectionTerminal;
+        const dataIn = terminals["list:paired_or_unpaired collection input"]!["f1"] as InputCollectionTerminal;
+        expect(dataIn.mapOver).toBe(NULL_COLLECTION_TYPE_DESCRIPTION);
+        expect(dataIn.canAccept(collectionOut).canAccept).toBe(false);
+    });
+    it("rejects paired_or_unpaired -> paired connection", () => {
+        const collectionOut = terminals["paired_or_unpaired input"]!["output"] as OutputCollectionTerminal;
+        const dataIn = terminals["paired collection input"]!["f1"] as InputTerminal;
+        expect(dataIn.mapOver).toBe(NULL_COLLECTION_TYPE_DESCRIPTION);
+        expect(dataIn.canAccept(collectionOut).canAccept).toBe(false);
+        expect(dataIn.canAccept(collectionOut).reason).toBe(
+            "Cannot attach optionally paired outputs to inputs requiring pairing, consider using the 'Split Paired and Unpaired' to extract just the pairs out from this output."
+        );
+    });
+    it("rejects list:paired_or_unpaired -> paired connection", () => {
+        const collectionOut = terminals["list:paired_or_unpaired input"]!["output"] as OutputCollectionTerminal;
+        const dataIn = terminals["paired collection input"]!["f1"] as InputTerminal;
+        expect(dataIn.mapOver).toBe(NULL_COLLECTION_TYPE_DESCRIPTION);
+        expect(dataIn.canAccept(collectionOut).canAccept).toBe(false);
+        expect(dataIn.canAccept(collectionOut).reason).toBe(
+            "Cannot attach optionally paired outputs to inputs requiring pairing, consider using the 'Split Paired and Unpaired' to extract just the pairs out from this output."
+        );
+    });
+    it("rejects list:paired_or_unpaired -> list connection", () => {
+        const collectionOut = terminals["list:paired_or_unpaired input"]!["output"] as OutputCollectionTerminal;
+        const dataIn = terminals["list collection input"]!["input1"] as InputTerminal;
+        expect(dataIn.mapOver).toBe(NULL_COLLECTION_TYPE_DESCRIPTION);
+        expect(dataIn.canAccept(collectionOut).canAccept).toBe(false);
+    });
     it("treats multi data input as list input", () => {
         const collectionOut = terminals["list input"]!["output"] as OutputCollectionTerminal;
         const multiDataIn = terminals["multi data"]!["f1"] as InputTerminal;
@@ -269,6 +460,30 @@ describe("canAccept", () => {
             "Cannot attach paired inputs to multiple data parameters, only lists may be treated this way."
         );
     });
+    it("rejects paired_or_unpaired input on multi-data input", () => {
+        const multiDataIn = terminals["multi data"]!["f1"] as InputTerminal;
+        const pairedOut = terminals["paired_or_unpaired input"]!["output"] as OutputCollectionTerminal;
+        expect(multiDataIn.canAccept(pairedOut).canAccept).toBe(false);
+        expect(multiDataIn.canAccept(pairedOut).reason).toBe(
+            "Cannot attach paired inputs to multiple data parameters, only lists may be treated this way."
+        );
+    });
+    it("rejects list:paired input on multi-data input", () => {
+        const multiDataIn = terminals["multi data"]!["f1"] as InputTerminal;
+        const pairedOut = terminals["list:paired input"]!["output"] as OutputCollectionTerminal;
+        expect(multiDataIn.canAccept(pairedOut).canAccept).toBe(false);
+        expect(multiDataIn.canAccept(pairedOut).reason).toBe(
+            "Cannot attach paired inputs to multiple data parameters, only lists may be treated this way."
+        );
+    });
+    it("rejects list:paired_or_unpaired input on multi-data input", () => {
+        const multiDataIn = terminals["multi data"]!["f1"] as InputTerminal;
+        const pairedOut = terminals["list:paired_or_unpaired input"]!["output"] as OutputCollectionTerminal;
+        expect(multiDataIn.canAccept(pairedOut).canAccept).toBe(false);
+        expect(multiDataIn.canAccept(pairedOut).reason).toBe(
+            "Cannot attach paired inputs to multiple data parameters, only lists may be treated this way."
+        );
+    });
     it("rejects collections on multi data inputs if non-collection already connected", () => {
         const multiDataIn = terminals["multi data"]!["f1"] as InputTerminal;
         const dataOut = terminals["data input"]!["output"] as OutputTerminal;
@@ -466,12 +681,18 @@ describe("canAccept", () => {
         dataIn.disconnect(filterFailedOutput);
         expect(stepStore.stepMapOver[filterFailedOutput.stepId]?.isCollection).toBe(true);
     });
-    it("rejects connecting incompatible connection types", () => {
+    it("rejects connecting paired -> list", () => {
         const pairedOut = terminals["paired input"]!["output"] as OutputCollectionTerminal;
         const collectionIn = terminals["list collection input"]!["input1"] as InputCollectionTerminal;
         expect(collectionIn.canAccept(pairedOut).canAccept).toBe(false);
         expect(collectionIn.canAccept(pairedOut).reason).toBe("Incompatible collection type(s) for attachment.");
     });
+    it("rejects connecting list -> paired", () => {
+        const pairedOut = terminals["list input"]!["output"] as OutputCollectionTerminal;
+        const collectionIn = terminals["paired collection input"]!["f1"] as InputCollectionTerminal;
+        expect(collectionIn.canAccept(pairedOut).canAccept).toBe(false);
+        expect(collectionIn.canAccept(pairedOut).reason).toBe("Incompatible collection type(s) for attachment.");
+    });
     it("accepts a collection input if other input has a map over collection type", () => {
         const collectionOut = terminals["list input"]!["output"] as OutputCollectionTerminal;
         const listListOut = terminals["list:list input"]!["output"] as OutputCollectionTerminal;
diff --git a/client/src/components/Workflow/Editor/modules/terminals.ts b/client/src/components/Workflow/Editor/modules/terminals.ts
index 8221133278df..d4086713a610 100644
--- a/client/src/components/Workflow/Editor/modules/terminals.ts
+++ b/client/src/components/Workflow/Editor/modules/terminals.ts
@@ -651,7 +651,17 @@ export class InputCollectionTerminal extends BaseInputTerminal {
                     );
                 }
             } else {
-                return new ConnectionAcceptable(false, "Incompatible collection type(s) for attachment.");
+                let reason = "Incompatible collection type(s) for attachment.";
+                if (this.collectionTypes.length == 1) {
+                    if (
+                        otherCollectionType.collectionType?.endsWith("paired_or_unpaired") &&
+                        this.collectionTypes[0]?.collectionType?.endsWith("paired")
+                    ) {
+                        reason =
+                            "Cannot attach optionally paired outputs to inputs requiring pairing, consider using the 'Split Paired and Unpaired' to extract just the pairs out from this output.";
+                    }
+                }
+                return new ConnectionAcceptable(false, reason);
             }
         } else {
             return new ConnectionAcceptable(false, "Cannot attach a data output to a collection input.");
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..4a036ec5e856 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,357 @@
       "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
+    }
+  },
+  "24": {
+    "id": 24,
+    "type": "tool",
+    "label": "list:paired_or_unpaired collection input",
+    "content_id": "collection_list_paired_or_unpaired",
+    "name": "collection_list_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": [
+          "list: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
+    }
+  },
+  "25": {
+    "id": 25,
+    "type": "tool",
+    "label": "paired collection input",
+    "content_id": "collection_paired_test",
+    "name": "collection_paired_test",
+    "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"
+        ],
+        "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
+    }
+  },
+  "26": {
+    "id": 26,
+    "type": "data_collection_input",
+    "label": "list:list:paired input",
+    "content_id": null,
+    "name": "Input dataset collection",
+    "tool_state": {
+      "collection_type": "\"list:list:paired\"",
+      "optional": "\"false\"",
+      "tag": "\"\"",
+      "__page__": null,
+      "__rerun_remap_job_id__": null
+    },
+    "errors": null,
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "output",
+        "extensions": [
+          "input"
+        ],
+        "collection": true,
+        "collection_type": "list:list:paired",
+        "optional": false
+      }
+    ],
+    "annotation": "",
+    "post_job_actions": {},
+    "workflow_outputs": [],
+    "input_connections": {},
+    "position": {
+      "left": 12.8729248046875,
+      "top": 501.7839660644531
+    }
+  },
+  "27": {
+    "id": 27,
+    "type": "tool",
+    "label": "list:paired collection input",
+    "content_id": "collection_creates_list_of_pairs",
+    "name": "collection_creates_list_of_pairs",
+    "tool_state": {
+      "input1": "{\"__class__\": \"RuntimeValue\"}",
+      "__page__": null,
+      "__rerun_remap_job_id__": null
+    },
+    "errors": null,
+    "inputs": [
+      {
+        "name": "input1",
+        "label": "input1",
+        "multiple": false,
+        "input_type": "dataset_collection",
+        "collection_types": [
+          "list:paired"
+        ],
+        "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
+    }    
+  },
+  "28": {
+    "id": 28,
+    "type": "data_collection_input",
+    "label": "paired:paired input",
+    "content_id": null,
+    "name": "Input dataset collection",
+    "tool_state": {
+      "collection_type": "\"paired:paired\"",
+      "optional": "\"false\"",
+      "tag": "\"\"",
+      "__page__": null,
+      "__rerun_remap_job_id__": null
+    },
+    "errors": null,
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "output",
+        "extensions": [
+          "input"
+        ],
+        "collection": true,
+        "collection_type": "paired:paired",
+        "optional": false
+      }
+    ],
+    "annotation": "",
+    "post_job_actions": {},
+    "workflow_outputs": [],
+    "input_connections": {},
+    "position": {
+      "left": 12.8729248046875,
+      "top": 501.7839660644531
+    }
   }
 }
diff --git a/client/src/entry/analysis/router.js b/client/src/entry/analysis/router.js
index 8d90ac29cb0a..1da3e853b418 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: parseBool(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/doc/source/conf.py b/doc/source/conf.py
index 57f71026b150..19434e39c89e 100644
--- a/doc/source/conf.py
+++ b/doc/source/conf.py
@@ -40,13 +40,14 @@
 
 # Add any Sphinx extension module names here, as strings. They can be extensions
 # coming with Sphinx (named 'sphinx.ext.*') or your custom ones.
-extensions = ["myst_parser", "sphinx.ext.intersphinx"]
+extensions = ["myst_parser", "sphinx.ext.intersphinx", "sphinx.ext.mathjax"]
 if not SKIP_SOURCE:
     # TODO: Add https://pypi.org/project/sphinx-autodoc-typehints
     extensions += ["sphinx.ext.doctest", "sphinx.ext.todo", "sphinx.ext.coverage", "sphinx.ext.autodoc"]
     if not SKIP_VIEW_CODE:
         extensions.append("sphinx.ext.viewcode")
 myst_enable_extensions = [
+    "dollarmath",
     "attrs_block",
     "deflist",
     "substitution",
diff --git a/doc/source/dev/collection_semantics.md b/doc/source/dev/collection_semantics.md
new file mode 100644
index 000000000000..10a6828da512
--- /dev/null
+++ b/doc/source/dev/collection_semantics.md
@@ -0,0 +1,762 @@
+# Collection Semantics
+
+This document describes the semantics around working with Galaxy dataset collections.
+In particular it describes how they operate within Galaxy tools and workflows.
+
+:::{admonition} You Probably Don't Need to Read This
+:class: caution
+
+Any significantly sophisticated workflow language will have ways to collect data
+into arrays or vectors or dictionaries and apply operations across this data (mapping)
+or reduce the dimensionality of this data (reductions). Typically, this explicitly
+annotated with map functions or for loops. Galaxy however is designed to be a point
+and click interface for connecting steps and running tools. It is important that steps
+just connect and just do the most natural thing - and this is what Galaxy does.
+This document just provides a mathematical formalism to that "what should just
+intuitively work" that can be used to document test cases and help with implementation.
+This is reference documentation not user documentation, Galaxy should just work.
+:::
+
+## Mapping
+
+If a tool consumes a simple dataset parameter and produces a simple dataset parameter,
+then any collection type may be "mapped over" the data input to that tool. The result of
+that is the tool being applied to each element of the collection and "implicit collections"
+being created from the outputs that are produced from those operations. Those implicit
+collections have the same element identifiers in the same order as the input collection that is
+mapped over. Each element of the implicit collections correspond to their own job and
+Galaxy very naturally and intuitively parallelizes jobs without extra work from the user
+and without any knowledge of the tool.
+
+
+(BASIC_MAPPING_PAIRED)=
+(BASIC_MAPPING_PAIRED_OR_UNPAIRED_PAIRED)=
+(BASIC_MAPPING_PAIRED_OR_UNPAIRED_UNPAIRED)=
+(BASIC_MAPPING_LIST)=
+<details><summary>Examples</summary>
+
+:::{admonition} Example: `BASIC_MAPPING_PAIRED` 
+:class: note
+
+Assuming,
+
+* $ d_f $, $ d_r $ are datasets
+* $ tool \text{ is } (i: \text{ dataset }) \Rightarrow \{ o: \text{ dataset } \} $
+* $ C $ is $ \text{CollectionInstance<}paired,\left\{ \text{ forward }=d_f, \text{ reverse }=d_r \right\}\text{>} $
+
+
+then
+
+$$tool(i=\text{mapOver}(C)) \mapsto \left\{o: collection<paired, \left\{\text{forward}=tool(i=d_f)[o], \text{reverse}=tool(i=d_r)[o]\right\}> \right\}$$
+
+:::
+
+
+
+:::{admonition} Example: `BASIC_MAPPING_PAIRED_OR_UNPAIRED_PAIRED` 
+:class: note
+
+Assuming,
+
+* $ d_f $, $ d_r $ are datasets
+* $ tool \text{ is } (i: \text{ dataset }) \Rightarrow \{ o: \text{ dataset } \} $
+* $ C $ is $ \text{CollectionInstance<}paired\_or\_unpaired,\left\{ \text{ forward }=d_f, \text{ reverse }=d_r \right\}\text{>} $
+
+
+then
+
+$$tool(i=\text{mapOver}(C)) \mapsto \left\{o: collection<paired\_or\_unpaired,\left\{\text{forward}=tool(i=d_f)[o], \text{reverse}=tool(i=d_r)[o]\right\}>\right\}$$
+
+:::
+
+
+
+:::{admonition} Example: `BASIC_MAPPING_PAIRED_OR_UNPAIRED_UNPAIRED` 
+:class: note
+
+Assuming,
+
+* $ d_u $ is a dataset
+* $ tool \text{ is } (i: \text{ dataset }) \Rightarrow \{ o: \text{ dataset } \} $
+* $ C $ is $ \text{CollectionInstance<}paired\_or\_unpaired,\left\{ \text{ unpaired }=d_u \right\}\text{>} $
+
+
+then
+
+$$tool(i=\text{mapOver}(C)) \mapsto \left\{o: collection<paired\_or\_unpaired,\left\{unpaired=tool(i=d_u)[o]\right\}>\right\}$$
+
+:::
+
+
+
+:::{admonition} Example: `BASIC_MAPPING_LIST` 
+:class: note
+
+Assuming,
+
+* $ d_1,...,d_n $ are datasets
+* $ tool \text{ is } (i: \text{ dataset }) \Rightarrow \{ o: \text{ dataset } \} $
+* $ C $ is $ \text{CollectionInstance<}list,\left\{ \text{ i1 }=d_1, ..., \text{ in }=d_n \right\}\text{>} $
+
+
+then
+
+$$tool(i=\text{mapOver}(C)) \mapsto \left\{o: collection<\text{list},\left\{i1=tool(i=d_1)[o],...,in=tool(i=d_n)[o]]\right\}>\right\}$$
+
+:::
+
+
+
+</details><br>
+
+
+
+The above description of mapping over inputs works naturally and as expected for
+nested collections.
+
+
+(NESTED_LIST_MAPPING)=
+(BASIC_MAPPING_LIST_PAIRED_OR_UNPAIRED)=
+<details><summary>Examples</summary>
+
+:::{admonition} Example: `NESTED_LIST_MAPPING` 
+:class: note
+
+Assuming,
+
+* $ d_1,...,d_n $ are datasets
+* $ tool \text{ is } (i: \text{ dataset }) \Rightarrow \{ o: \text{ dataset } \} $
+* $ C $ is $ \text{CollectionInstance<}list:list,\left\{ \text{ o1 }=\left\{ \text{ inner }=d_1 \right\}, ..., \text{ on }=\left\{ \text{ inner }=d_n \right\} \right\}\text{>} $
+
+
+then
+
+$$tool(i=\text{mapOver}(C)) \mapsto \left\{o: collection<\text{list}:\text{list},\left\{o1=\left\{inner=tool(i=d_1)[o]\right\}\right\},...,\left\{on=\left\{inner=tool(i=d_n)[o]\right\}\right\}>\right\}$$
+
+:::
+
+
+
+:::{admonition} Example: `BASIC_MAPPING_LIST_PAIRED_OR_UNPAIRED` 
+:class: note
+
+Assuming,
+
+* $ d_f $, $ d_r $ are datasets
+* $ tool \text{ is } (i: \text{ dataset }) \Rightarrow \{ o: \text{ dataset } \} $
+* $ C $ is $ \text{CollectionInstance<}list:paired\_or\_unpaired,\left\{ \text{ el1 }=\left\{ \text{ forward }=d_f, \text{ reverse }=d_r \right\} \right\}\text{>} $
+
+
+then
+
+$$tool(i=\text{mapOver}(C)) \mapsto \left\{o: collection<\text{list}:paired\_or\_unpaired,\left\{el1=\left\{\text{forward}=tool(i=d_f)[o],\text{reverse}=tool(i=d_r)[o]\right\}\right\}>\right\}$$
+
+:::
+
+
+
+</details><br>
+
+
+
+
+For tools with multiple data inputs, the tool can be executed with individual
+datasets for the non-mapped over input and each tool execution will just be executed
+with that dataset. The dataset not mapped over serves as the input for each execution.
+
+
+(BASIC_MAPPING_INCLUDING_SINGLE_DATASET)=
+<details><summary>Examples</summary>
+
+:::{admonition} Example: `BASIC_MAPPING_INCLUDING_SINGLE_DATASET` 
+:class: note
+
+Assuming,
+
+* $ d_1,...,d_n $, $ d_o $ are datasets
+* $ tool \text{ is } (i: \text{ dataset }, i2: \text{ dataset }) \Rightarrow \{ o: \text{ dataset } \} $
+* $ C $ is $ \text{CollectionInstance<}list,\left\{ \text{ i1 }=d_1, ..., \text{ in }=d_n \right\}\text{>} $
+
+
+then
+
+$$tool(i=\text{mapOver}(C),i2=d_o) \mapsto \left\{o: collection<\text{list},\left\{i1=tool(i=d_1, i2=d_o)[o],...,in=tool(i=d_n, i2=d_o)[o]\right\}>\right\}$$
+
+:::
+
+
+
+</details><br>
+
+
+
+If a tool consumes two input datasets and produces one output dataset, you can map two
+collections with identical structure (same element identifiers in the same order) over
+the respective inputs and the result is an implicit collection with the same structure
+as the inputs and where each output in the implicit collection corresponds to the tool
+being executed with the two inputs corresponding to that position in the input
+collections.
+
+The default behavior here is the collections are linked and the act of mapping over
+inputs to the tool are sort of a flat map or a dot product. No extra dimensionality
+in the resulting collections.
+
+From a user perspective this means if you start with a collection and apply a bunch
+of map over operations on tools - the results will all continue to match and work together
+very naturally - again without extra work by the user and without extra knowledge
+by the tool author.
+
+
+(BASIC_MAPPING_TWO_INPUTS_WITH_IDENTICAL_STRUCTURE)=
+<details><summary>Examples</summary>
+
+:::{admonition} Example: `BASIC_MAPPING_TWO_INPUTS_WITH_IDENTICAL_STRUCTURE` 
+:class: note
+
+Assuming,
+
+* $ d1_1,...,d1_n $, $ d2_1,...,d2_n $ are datasets
+* $ tool \text{ is } (i: \text{ dataset }, i2: \text{ dataset }) \Rightarrow \{ o: \text{ dataset } \} $
+* $ C1 $ is $ \text{CollectionInstance<}list,\left\{ \text{ i1 }=d1_1, ..., \text{ in }=d1_n \right\}\text{>} $
+* $ C2 $ is $ \text{CollectionInstance<}list,\left\{ \text{ i1 }=d2_1, ..., \text{ in }=d2_n \right\}\text{>} $
+
+
+then
+
+$$tool(i=\text{mapOver}(C1), i2=\text{mapOver}(C2)) \mapsto \left\{o: collection<\text{list},\left\{i1=tool(i=d1_1, i2=d2_1)[o],...,in=tool(i=d1_n, i2=d2_n)[o]]\right\}>\right\}$$
+
+:::
+
+
+
+</details><br>
+
+
+
+## Reduction
+
+Not all tool executions result in implicit collections and mapping
+over inputs. Tool inputs of ``type`` ``data_collection`` can consume
+collections directly and do not necessarily result in mapping over.
+
+Tools that consume collections and output datasets effectively
+reduce the dimension of the Galaxy data structure. When used at runtime
+this is often referred to a "reduction" in the code.
+
+
+(COLLECTION_INPUT_PAIRED)=
+(COLLECTION_INPUT_LIST)=
+(COLLECTION_INPUT_PAIRED_OR_UNPAIRED)=
+(COLLECTION_INPUT_LIST_PAIRED_OR_UNPAIRED)=
+<details><summary>Examples</summary>
+
+:::{admonition} Example: `COLLECTION_INPUT_PAIRED` 
+:class: note
+
+Assuming,
+
+* $ d_f $, $ d_r $ are datasets
+* $ tool \text{ is } (i: \text{ collection<paired> }) \Rightarrow \{ o: \text{ dataset } \} $
+* $ C $ is $ \text{CollectionInstance<}paired,\left\{ \text{ forward }=d_f, \text{ reverse }=d_r \right\}\text{>} $
+
+
+then
+
+$$tool(i=C) \rightarrow \left\{o: dataset\right\}$$
+
+:::
+
+
+
+:::{admonition} Example: `COLLECTION_INPUT_LIST` 
+:class: note
+
+Assuming,
+
+* $ d1,...,dn $ are datasets
+* $ tool \text{ is } (i: \text{ collection<list> }) \Rightarrow \{ o: \text{ dataset } \} $
+* $ C $ is $ \text{CollectionInstance<}list,\left\{ \text{ el1 }=d_1, ..., \text{ eln }=d_n \right\}\text{>} $
+
+
+then
+
+$$tool(i=C) \rightarrow \left\{o: dataset\right\}$$
+
+:::
+
+
+
+:::{admonition} Example: `COLLECTION_INPUT_PAIRED_OR_UNPAIRED` 
+:class: note
+
+Assuming,
+
+* $ d_f $, $ d_r $ are datasets
+* $ tool \text{ is } (i: \text{ collection<paired_or_unpaired> }) \Rightarrow \{ o: \text{ dataset } \} $
+* $ C $ is $ \text{CollectionInstance<}paired\_or\_unpaired,\left\{ \text{ forward }=d_f, \text{ reverse }=d_r \right\}\text{>} $
+
+
+then
+
+$$tool(i=C) \rightarrow \left\{o: dataset\right\}$$
+
+:::
+
+
+
+:::{admonition} Example: `COLLECTION_INPUT_LIST_PAIRED_OR_UNPAIRED` 
+:class: note
+
+Assuming,
+
+* $ d_f $, $ d_r $ are datasets
+* $ tool \text{ is } (i: \text{ collection<list:paired_or_unpaired> }) \Rightarrow \{ o: \text{ dataset } \} $
+* $ C $ is $ \text{CollectionInstance<}list:paired\_or\_unpaired,\left\{ \text{ el1 }=\left\{ \text{ forward }=d_f, \text{ reverse }=d_r \right\} \right\}\text{>} $
+
+
+then
+
+$$tool(i=C) \rightarrow \left\{o: dataset\right\}$$
+
+:::
+
+
+
+</details><br>
+
+
+
+For nested collections where each rank is a ``list`` or a ``paired`` collection,
+then collection inputs must match every part of the collection type input definition.
+
+
+(COLLECTION_INPUT_LIST_NOT_CONSUMES_PAIRS)=
+(COLLECTION_INPUT_PAIRED_NOT_CONSUMES_LIST)=
+<details><summary>Examples</summary>
+
+:::{admonition} Example: `COLLECTION_INPUT_LIST_NOT_CONSUMES_PAIRS` 
+:class: note
+
+Assuming,
+
+* $ d_f $, $ d_r $ are datasets
+* $ tool \text{ is } (i: \text{ collection<list> }) \Rightarrow \{ o: \text{ dataset } \} $
+* $ C $ is $ \text{CollectionInstance<}paired,\left\{ \text{ forward }=d_f, \text{ reverse }=d_r \right\}\text{>} $
+
+
+then
+
+$$tool(i=C)\text{ is invalid}$$
+
+:::
+
+
+
+:::{admonition} Example: `COLLECTION_INPUT_PAIRED_NOT_CONSUMES_LIST` 
+:class: note
+
+Assuming,
+
+* $ d_1,...,d_n $ are datasets
+* $ tool \text{ is } (i: \text{ collection<paired> }) \Rightarrow \{ o: \text{ dataset } \} $
+* $ C $ is $ \text{CollectionInstance<}list,\left\{ \text{ i1 }=d_1, ..., \text{ in }=d_n \right\}\text{>} $
+
+
+then
+
+$$tool(i=C) is invalid$$
+
+:::
+
+
+
+</details><br>
+
+
+
+In addition to explicit collection inputs, tool inputs of ``type`` ``data``
+where ``multiple="true"`` can consume lists directly. This is likewise a
+"reduction" and does not result in implicit collection creation.
+
+
+(LIST_REDUCTION)=
+<details><summary>Examples</summary>
+
+:::{admonition} Example: `LIST_REDUCTION` 
+:class: note
+
+Assuming,
+
+* $ d_1,...,d_n $ are datasets
+* $ tool \text{ is } (i: \text{ dataset<multiple=true> }) \Rightarrow \{ o: \text{ dataset } \} $
+* $ C $ is $ \text{CollectionInstance<}list,\left\{ \text{ i1 }=d_1, ..., \text{ in }=d_n \right\}\text{>} $
+
+
+then
+
+$$tool(i=C) == tool(i=[d1,...,dn])$$
+
+:::
+
+
+
+</details><br>
+
+
+
+Paired collections cannot be reduced this way. ``paired`` is not meant
+to represent a list/array/vector data structure - it is more like a tuple.
+
+
+(PAIRED_REDUCTION_INVALID)=
+(PAIRED_OR_UNPAIRED_REDUCTION_INVALID)=
+<details><summary>Examples</summary>
+
+:::{admonition} Example: `PAIRED_REDUCTION_INVALID` 
+:class: note
+
+Assuming,
+
+* $ d_f $, $ d_r $ are datasets
+* $ tool \text{ is } (i: \text{ dataset<multiple=true> }) \Rightarrow \{ o: \text{ dataset } \} $
+* $ C $ is $ \text{CollectionInstance<}paired,\left\{ \text{ forward }=d_f, reverse=d_r \right\}\text{>} $
+
+
+then
+
+$$tool(i=C) is invalid$$
+
+:::
+
+
+
+:::{admonition} Example: `PAIRED_OR_UNPAIRED_REDUCTION_INVALID` 
+:class: note
+
+Assuming,
+
+* $ d_f $, $ d_r $ are datasets
+* $ tool \text{ is } (i: \text{ dataset<multiple=true> }) \Rightarrow \{ o: \text{ dataset } \} $
+* $ C $ is $ \text{CollectionInstance<}paired\_or\_unpaired,\left\{ forward=f, reverse=r \right\}\text{>} $
+
+
+then
+
+$$tool(i=C) is invalid$$
+
+:::
+
+
+
+</details><br>
+
+
+
+## Sub-collection Mapping
+
+![](https://planemo.readthedocs.io/en/master/_images/subcollection_mapping_identifiers.svg)
+
+
+(MAPPING_LIST_PAIRED_OVER_PAIRED)=
+<details><summary>Examples</summary>
+
+:::{admonition} Example: `MAPPING_LIST_PAIRED_OVER_PAIRED` 
+:class: note
+
+Assuming,
+
+* $ d_f $, $ d_r $ are datasets
+* $ tool \text{ is } (i: \text{ collection<paired> }) \Rightarrow \{ o: \text{ dataset } \} $
+* $ C $ is $ \text{CollectionInstance<}list:paired,\left\{ \text{ el1 }=\left\{ \text{ forward }=d_f, \text{ reverse }=d_r \right\} \right\}\text{>} $
+* $ C\_PAIRED $ is $ \text{CollectionInstance<}paired,\left\{ \text{ forward }=d_f, \text{ reverse }=d_r \right\}\text{>} $
+
+
+then
+
+$$tool(i=\text{mapOver}(C, 'paired')) \mapsto \left\{o: collection<\text{list},\left\{el1=tool(i=C\_PAIRED)[o]\right\}>\right\}$$
+
+:::
+
+
+
+</details><br>
+
+
+
+The natural extension of multiple data input parameters consuming list collections as describe
+above when discussing reductions is that nested lists of lists (``list:list``) can be mapped
+over a multiple data input parameter. Each nested list will be reduced by this operation but the
+results will be mapped over. The result will be a list with the same structure as the outer list
+of the input collection.
+
+
+(NESTED_LIST_REDUCTION)=
+<details><summary>Examples</summary>
+
+:::{admonition} Example: `NESTED_LIST_REDUCTION` 
+:class: note
+
+Assuming,
+
+* $ d_1,...,d_n $ are datasets
+* $ tool \text{ is } (i: \text{ dataset<multiple=true> }) \Rightarrow \{ o: \text{ dataset } \} $
+* $ C $ is $ \text{CollectionInstance<}list:list,\left\{ \text{ o1 }=\left\{ \text{ inner }=d1 \right\}, ..., \text{ on }=\left\{ \text{ inner }=dn \right\} \right\}\text{>} $
+
+
+then
+
+$$tool(i=\text{mapOver}(C, '\text{list}')) \mapsto \left\{o: collection<\text{list},\left\{o1=tool(i=[d1])[o]\right\},...,on=tool(i=[dn])[o]\right\}>\right\}$$
+
+:::
+
+
+
+</details><br>
+
+
+
+Just as a paired collection won't be reduced by a multiple data input, any sort of nested
+collection ending in a paired collection cannot be mapped over such an input. So a multiple
+data input parameter cannot be mapped over by a list of pairs (``list:paired``) for instance.
+
+
+(LIST_PAIRED_REDUCTION_INVALID)=
+(LIST_PAIRED_OR_UNPAIRED_REDUCTION_INVALID)=
+<details><summary>Examples</summary>
+
+:::{admonition} Example: `LIST_PAIRED_REDUCTION_INVALID` 
+:class: note
+
+Assuming,
+
+* $ d_f $, $ d_r $ are datasets
+* $ tool \text{ is } (i: \text{ dataset<multiple=true> }) \Rightarrow \{ o: \text{ dataset } \} $
+* $ C $ is $ \text{CollectionInstance<}list:paired,\left\{ \text{ forward }=d_f, \text{ reverse }=d_r \right\}\text{>} $
+
+
+then
+
+$$tool(i=\text{mapOver}(C, 'paired')) is invalid$$
+
+:::
+
+
+
+:::{admonition} Example: `LIST_PAIRED_OR_UNPAIRED_REDUCTION_INVALID` 
+:class: note
+
+Assuming,
+
+* $ d_f $, $ d_r $ are datasets
+* $ tool \text{ is } (i: \text{ dataset<multiple=true> }) \Rightarrow \{ o: \text{ dataset } \} $
+* $ C $ is $ \text{CollectionInstance<}list:paired\_or\_unpaired,\left\{ \text{ forward }=d_f, \text{ reverse }=d_r \right\}\text{>} $
+
+
+then
+
+$$tool(i=\text{mapOver}(C, 'paired\_or\_unpaired')) is invalid$$
+
+:::
+
+
+
+</details><br>
+
+
+
+## paired_or_unpaired Collections
+
+The collection type ``paired_or_unpaired`` is meant to serve as a stand-in for
+an entity that can be either a single dataset or what is effectively a ``paired``
+dataset collection. These collections either have one element with identifier
+``unpaired`` or two elements with identifiers ``forward`` and ``reverse``.
+
+Tools can declare a data_collection input with collection type ``paired_or_unpaired``
+and that input will consume either an explicit ``paired_or_unpaired`` collection
+normally or can consume a ``paired`` input.
+
+
+(PAIRED_OR_UNPAIRED_CONSUMES_PAIRED)=
+<details><summary>Examples</summary>
+
+:::{admonition} Example: `PAIRED_OR_UNPAIRED_CONSUMES_PAIRED` 
+:class: note
+
+Assuming,
+
+* $ d_f $, $ d_r $ are datasets
+* $ tool \text{ is } (i: \text{ collection<paired_or_unpaired> }) \Rightarrow \{ o: \text{ dataset } \} $
+* $ C $ is $ \text{CollectionInstance<}paired,\left\{ \text{ forward }=d_f, \text{ reverse }=d_r \right\}\text{>} $
+* $ C_AS_MIXED = CollectionInstance<paired\_or\_unpaired,\left\{\text{forward}=f, \text{reverse}=r\right\}> $
+
+
+then
+
+$$tool(i=C) == tool(i=C_AS_MIXED)$$
+
+:::
+
+
+
+</details><br>
+
+
+
+
+This inverse of this doesn't work intentionally. In some ways a ``paired`` collection
+acts as a ``paired_or_unpaired`` collection but a ``paired_or_unpaired`` is not a paired
+collection. This makes a lot of sense in terms of tools - a tool consuming a ``paired``
+dataset expects to find both a ``forward`` and ``reverse`` element but these may not exist
+in ``paired_or_unpaired`` collection.
+
+
+(PAIRED_OR_UNPAIRED_NOT_CONSUMED_BY_PAIRED)=
+<details><summary>Examples</summary>
+
+:::{admonition} Example: `PAIRED_OR_UNPAIRED_NOT_CONSUMED_BY_PAIRED` 
+:class: note
+
+Assuming,
+
+* $ d_f $, $ d_r $ are datasets
+* $ tool \text{ is } (i: \text{ collection<paired> }) \Rightarrow \{ o: \text{ dataset } \} $
+* $ C $ is $ \text{CollectionInstance<}paired\_or\_unpaired,\left\{ forward=d_f, \text{ reverse }=d_r \right\}\text{>} $
+
+
+then
+
+$$tool(i=C) is invalid$$
+
+:::
+
+
+
+</details><br>
+
+
+
+
+The same logic holds for mapping, lists of paired datasets (``list:paired``) can be mapped over these
+``paired_or_unpaired`` inputs and mixed lists of pairs (``list:paired_or_unpaired``) cannot
+be mapped over a ``paired`` input. Following the same logic, ``list:paired_or_unpaired`` cannot
+be mapped over a ``list`` input or multiple data input.
+
+
+(MAPPING_LIST_PAIRED_OVER_PAIRED_OR_UNPAIRED)=
+(PAIRED_OR_UNPAIRED_NOT_CONSUMED_BY_PAIRED_WHEN_MAPPING)=
+(PAIRED_OR_UNPAIRED_NOT_CONSUMED_BY_LIST_WHEN_MAPPING)=
+<details><summary>Examples</summary>
+
+:::{admonition} Example: `MAPPING_LIST_PAIRED_OVER_PAIRED_OR_UNPAIRED` 
+:class: note
+
+Assuming,
+
+* $ d_f $, $ d_r $ are datasets
+* $ tool \text{ is } (i: \text{ collection<paired_or_unpaired> }) \Rightarrow \{ o: \text{ dataset } \} $
+* $ C $ is $ \text{CollectionInstance<}list:paired,\left\{ \text{ el }=\left\{ \text{ forward }=d_f, \text{ reverse }=d_r \right\} \right\}\text{>} $
+* $ C_AS_MIXED $ is $ \text{CollectionInstance<}list:paired\_or\_unpaired,\left\{ \text{ el }=\left\{ \text{ forward }=d_f, \text{ reverse }=d_r \right\} \right\}\text{>} $
+
+
+then
+
+$$tool(i=\text{mapOver}(C)) == tool(i=\text{mapOver}(C_AS_MIXED))$$
+
+:::
+
+
+
+:::{admonition} Example: `PAIRED_OR_UNPAIRED_NOT_CONSUMED_BY_PAIRED_WHEN_MAPPING` 
+:class: note
+
+Assuming,
+
+* $ d_f $, $ d_r $ are datasets
+* $ tool \text{ is } (i: \text{ collection<paired> }) \Rightarrow \{ o: \text{ dataset } \} $
+* $ C $ is $ \text{CollectionInstance<}list:paired\_or\_unpaired,\left\{ \text{ el }=\left\{ \text{ forward }=f, \text{ reverse }=r \right\} \right\}\text{>} $
+
+
+then
+
+$$tool(i=\text{mapOver}(C)) is invalid$$
+
+:::
+
+
+
+:::{admonition} Example: `PAIRED_OR_UNPAIRED_NOT_CONSUMED_BY_LIST_WHEN_MAPPING` 
+:class: note
+
+Assuming,
+
+* $ d_f $, $ d_r $ are datasets
+* $ tool \text{ is } (i: \text{ collection<list> }) \Rightarrow \{ o: \text{ dataset } \} $
+* $ C $ is $ \text{CollectionInstance<}list:paired\_or\_unpaired,\left\{ \text{ el }=\left\{ \text{ forward }=f, \text{ reverse }=r \right\} \right\}\text{>} $
+
+
+then
+
+$$tool(i=\text{mapOver}(C)) is invalid$$
+
+:::
+
+
+
+</details><br>
+
+
+
+This logic extends naturally into higher dimensional collections. A ``list:list:paired``
+can be mapped over either a ``paired_or_unpaired`` input to produce a nested list (``list:list``)
+or a ``list:paired_or_unpaired`` input to produce a flat list (``list``).
+
+
+
+In order for ``paired_or_unpaired`` collections to also act as a single dataset,
+a flat list can be mapped over a such an input with a special sub collection mapping
+type of 'single_datasets'.
+
+
+(MAPPING_LIST_OVER_PAIRED_OR_UNPAIRED)=
+<details><summary>Examples</summary>
+
+:::{admonition} Example: `MAPPING_LIST_OVER_PAIRED_OR_UNPAIRED` 
+:class: note
+
+Assuming,
+
+* $ d_1,...,d_n $ are datasets
+* $ tool \text{ is } (i: \text{ collection<paired_or_unpaired> }) \Rightarrow \{ o: \text{ dataset } \} $
+* $ C $ is $ \text{CollectionInstance<}list,\left\{ \text{ i1 }=d_1, ..., \text{ in }=d_n \right\}\text{>} $
+* $ C_AS_UNPAIRED_i = CollectionInstance<paired\_or\_unpaired,\left\{unpaired=di\right\}> for i from 1...n $
+
+
+then
+
+$$tool(i=\text{mapOver}(C, 'single_datasets')) \mapsto \left\{o: collection<\text{list},\left\{i1=tool(i=C_AS_UNPAIRED_1)[o],...,in=tool(i=C_AS_UNPAIRED_n)[o]]\right\}>\right\}$$
+
+:::
+
+
+
+</details><br>
+
+
+
+This treatment of lists without pairing extends to nested structures naturally.
+For instance, a list of list of datasets (``list:list``) can be mapped over a
+``paired_or_unpaired`` input to produce a nested list of lists (``list:list``)
+with a structure matching the input. Likewise, the nested list can be mapped over
+a ``list:paired_or_unpaired`` input to produce a flat list with the same structure
+as the outer list of the input.
+
+
+Due only implementation time, the special casing of allowing paired_or_unpaired
+act as both datasets and paired collections only works when it is the deepest
+collection type. So while list:paired can be consumed by a list:paired_or_unpaired
+input, a paired:list cannot be consumed by a paired_or_unpaired:list input though
+it should be able to for consistency. We have focused our time on data structures
+more likely to be used in actual Galaxy analyses given current and guessed future
+usage.
+
+
diff --git a/doc/source/dev/index.rst b/doc/source/dev/index.rst
index 21a2760c24b4..23e212d0a632 100644
--- a/doc/source/dev/index.rst
+++ b/doc/source/dev/index.rst
@@ -15,6 +15,7 @@ A multi-hour long video playlist covering these slides can be found at
   api_guidelines
   database_session_management
   build_a_job_runner
+  collection_semantics
   finding_and_improving_slow_code
   data_managers
   data_source
diff --git a/lib/galaxy/model/__init__.py b/lib/galaxy/model/__init__.py
index 7ad5bf088ab6..8214c0347037 100644
--- a/lib/galaxy/model/__init__.py
+++ b/lib/galaxy/model/__init__.py
@@ -1774,8 +1774,8 @@ def set_params(self, params):
     def add_parameter(self, name, value):
         self.parameters.append(JobParameter(name, value))
 
-    def add_input_dataset(self, name, dataset=None, dataset_id=None):
-        assoc = JobToInputDatasetAssociation(name, dataset)
+    def add_input_dataset(self, name, dataset=None, dataset_id=None, adapter_json=None):
+        assoc = JobToInputDatasetAssociation(name, dataset, adapter_json)
         if dataset is None and dataset_id is not None:
             assoc.dataset_id = dataset_id
         add_object_to_object_session(self, assoc)
@@ -1790,12 +1790,14 @@ def add_output_dataset(self, name, dataset):
         add_object_to_object_session(self, joda)
         self.output_datasets.append(joda)
 
-    def add_input_dataset_collection(self, name, dataset_collection):
-        self.input_dataset_collections.append(JobToInputDatasetCollectionAssociation(name, dataset_collection))
+    def add_input_dataset_collection(self, name, dataset_collection, adapter_json=None):
+        self.input_dataset_collections.append(
+            JobToInputDatasetCollectionAssociation(name, dataset_collection, adapter_json)
+        )
 
-    def add_input_dataset_collection_element(self, name, dataset_collection_element):
+    def add_input_dataset_collection_element(self, name, dataset_collection_element, adapter_json=None):
         self.input_dataset_collection_elements.append(
-            JobToInputDatasetCollectionElementAssociation(name, dataset_collection_element)
+            JobToInputDatasetCollectionElementAssociation(name, dataset_collection_element, adapter_json)
         )
 
     def add_output_dataset_collection(self, name, dataset_collection_instance):
@@ -2418,11 +2420,13 @@ class JobToInputDatasetAssociation(Base, RepresentById):
     dataset_id: Mapped[int] = mapped_column(ForeignKey("history_dataset_association.id"), index=True, nullable=True)
     dataset_version: Mapped[Optional[int]]
     name: Mapped[str] = mapped_column(String(255), nullable=True)
+    adapter: Mapped[Dict[str, Any]] = mapped_column(JSONType)
     dataset: Mapped["HistoryDatasetAssociation"] = relationship(lazy="joined", back_populates="dependent_jobs")
     job: Mapped["Job"] = relationship(back_populates="input_datasets")
 
-    def __init__(self, name, dataset):
+    def __init__(self, name, dataset, adapter_json=None):
         self.name = name
+        self.adapter = adapter_json
         add_object_to_object_session(self, dataset)
         self.dataset = dataset
         self.dataset_version = 0  # We start with version 0 and update once the job is ready
@@ -2459,12 +2463,14 @@ class JobToInputDatasetCollectionAssociation(Base, RepresentById):
         ForeignKey("history_dataset_collection_association.id"), index=True, nullable=True
     )
     name: Mapped[str] = mapped_column(String(255), nullable=True)
+    adapter: Mapped[Dict[str, Any]] = mapped_column(JSONType)
     dataset_collection: Mapped["HistoryDatasetCollectionAssociation"] = relationship(lazy="joined")
     job: Mapped["Job"] = relationship(back_populates="input_dataset_collections")
 
-    def __init__(self, name, dataset_collection):
+    def __init__(self, name, dataset_collection, adapter_json=None):
         self.name = name
         self.dataset_collection = dataset_collection
+        self.adapter = adapter_json
 
 
 class JobToInputDatasetCollectionElementAssociation(Base, RepresentById):
@@ -2476,12 +2482,14 @@ class JobToInputDatasetCollectionElementAssociation(Base, RepresentById):
         ForeignKey("dataset_collection_element.id"), index=True, nullable=True
     )
     name: Mapped[str] = mapped_column(Unicode(255), nullable=True)
+    adapter: Mapped[Dict[str, Any]] = mapped_column(JSONType)
     dataset_collection_element: Mapped["DatasetCollectionElement"] = relationship(lazy="joined")
     job: Mapped["Job"] = relationship(back_populates="input_dataset_collection_elements")
 
-    def __init__(self, name, dataset_collection_element):
+    def __init__(self, name, dataset_collection_element, adapter_json=None):
         self.name = name
         self.dataset_collection_element = dataset_collection_element
+        self.adapter = adapter_json
 
 
 # Many jobs may map to one HistoryDatasetCollection using these for a given
diff --git a/lib/galaxy/model/dataset_collections/adapters.py b/lib/galaxy/model/dataset_collections/adapters.py
new file mode 100644
index 000000000000..fcc39ecfb81f
--- /dev/null
+++ b/lib/galaxy/model/dataset_collections/adapters.py
@@ -0,0 +1,262 @@
+from typing import (
+    List,
+    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):
+    _collection_type: str
+    _elements: List["TransientCollectionAdapterDatasetInstanceElement"]
+
+    def __init__(self, elements: List["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..0c93e746b41a 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,43 @@ 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
+
+        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 6b741aff06ea..2b7155a2026a 100644
--- a/lib/galaxy/model/dataset_collections/types/collection_semantics.yml
+++ b/lib/galaxy/model/dataset_collections/types/collection_semantics.yml
@@ -1,9 +1,25 @@
 - doc: |
     # Collection Semantics
 
-    This document describes the semantics around working with Galaxy Dataset Collections.
+    This document describes the semantics around working with Galaxy dataset collections.
     In particular it describes how they operate within Galaxy tools and workflows.
 
+    :::{admonition} You Probably Don't Need to Read This
+    :class: caution
+
+    Any significantly sophisticated workflow language will have ways to collect data
+    into arrays or vectors or dictionaries and apply operations across this data (mapping)
+    or reduce the dimensionality of this data (reductions). Typically, this explicitly
+    annotated with map functions or for loops. Galaxy however is designed to be a point
+    and click interface for connecting steps and running tools. It is important that steps
+    just connect and just do the most natural thing - and this is what Galaxy does.
+    This document just provides a mathematical formalism to that "what should just
+    intuitively work" that can be used to document test cases and help with implementation.
+    This is reference documentation not user documentation, Galaxy should just work.
+    :::
+
+    ## Mapping
+
     If a tool consumes a simple dataset parameter and produces a simple dataset parameter,
     then any collection type may be "mapped over" the data input to that tool. The result of
     that is the tool being applied to each element of the collection and "implicit collections"
@@ -16,25 +32,58 @@
 - example:
     label: BASIC_MAPPING_PAIRED
     assumptions:
-    - "f, r are datasets"
-    - "tool = (i: dataset) => {o: dataset}"
-    - "C = CollectionInstance<paired,{forward=f, reverse=r}>"
-    then:
-    - "tool(i=map_over(C)) ~> {o: collection<paired,{forward=tool(i=f)[o], reverse=tool(i=r)[o]}>}"
+    - datasets: [d_f, d_r]
+    - tool:
+        in: {i: dataset}
+        out: {o: dataset}
+    - collections:
+        C: [paired, {forward: d_f, reverse: d_r}]
+    then: "tool(i=mapOver(C)) ~> {o: collection<paired, {forward=tool(i=d_f)[o], reverse=tool(i=d_r)[o]}> }"
+    tests:
+        tool_runtime: "test_tool_execute.py::test_map_over_collection"
+        wf_editor: "accepts paired data -> data connection"
+
+- example:
+    label: BASIC_MAPPING_PAIRED_OR_UNPAIRED_PAIRED
+    assumptions:
+    - datasets: [d_f, d_r]
+    - tool:
+        in: {i: dataset}
+        out: {o: dataset}
+    - collections:
+        C: [paired_or_unpaired, {forward: d_f, reverse: d_r}]
+    then: "tool(i=mapOver(C)) ~> {o: collection<paired_or_unpaired,{forward=tool(i=d_f)[o], reverse=tool(i=d_r)[o]}>}"
+    tests:
+        tool_runtime: test_map_over_data_with_paired_or_unpaired_unpaired
+        workflow_editor: "accepts paired_or_unpaired data -> data connection"
+
+- example:
+    label: BASIC_MAPPING_PAIRED_OR_UNPAIRED_UNPAIRED
+    assumptions:
+    - datasets: [d_u]
+    - tool:
+        in: {i: dataset}
+        out: {o: dataset}
+    - collections:
+        C: [paired_or_unpaired, {unpaired: d_u}]
+    then: "tool(i=mapOver(C)) ~> {o: collection<paired_or_unpaired,{unpaired=tool(i=d_u)[o]}>}"
     tests:
-    - tool_runtime: "test_tool_execute.py::test_map_over_collection"
+        tool_runtime: test_map_over_data_with_paired_or_unpaired_paired
+        workflow_editor: "accepts paired_or_unpaired data -> data connection"
 
 - example:
     label: BASIC_MAPPING_LIST
     assumptions:
-    - "d1,...,dn are 'dataset's"
-    - "tool = (i: dataset) => {o: dataset}"
-    - "C = CollectionInstance<list,{i1=d1, ..., in=dn}>"
-    then:
-    - "tool(i=map_over(C)) ~> {o: collection<list,[i1=tool(i=d1)[o],...,in=tool(i=dn)[o]]]}"
+    - datasets: ["d_1,...,d_n"]
+    - tool:
+        in: {i: dataset}
+        out: {o: dataset}
+    - collections:
+        C: [list, {i1: "d_1", ..., in: "d_n"}]
+    then: "tool(i=mapOver(C)) ~> {o: collection<list,{i1=tool(i=d_1)[o],...,in=tool(i=d_n)[o]]}>}"
     tests:
-    - tool_runtime: "test_tool_execute::test_map_over_list_collection"
-    - wf_editor: "accepts collection data -> data connection"
+        tool_runtime: "test_tool_execute::test_map_over_list_collection"
+        workflow_editor: "accepts collection data -> data connection"
 
 - doc: |
     The above description of mapping over inputs works naturally and as expected for
@@ -42,9 +91,31 @@
 
 - example:
     label: NESTED_LIST_MAPPING
+    assumptions:
+    - datasets: ["d_1,...,d_n"]
+    - tool:
+        in: {i: dataset}
+        out: {o: dataset}
+    - collections:
+        C: ["list:list", {o1: {inner: d_1}, ..., "on": {inner: d_n}}]
+    then: "tool(i=mapOver(C)) ~> {o: collection<list:list,{o1={inner=tool(i=d_1)[o]}},...,{on={inner=tool(i=d_n)[o]}}>}"
+    tests:
+        tool_runtime: test_map_over_nested_collections
+        workflow_editor: "accepts list:list data -> data connection"
+
+- example:
+    label: BASIC_MAPPING_LIST_PAIRED_OR_UNPAIRED
+    assumptions:
+    - datasets: [d_f, d_r]
+    - tool:
+        in: {i: dataset}
+        out: {o: dataset}
+    - collections:
+        C: ["list:paired_or_unpaired", {el1: {forward: d_f, reverse: d_r}}]
+    then: "tool(i=mapOver(C)) ~> {o: collection<list:paired_or_unpaired,{el1={forward=tool(i=d_f)[o],reverse=tool(i=d_r)[o]}}>}"
     tests:
-    - tool_runtime: test_map_over_nested_collections
-    - wf_editor: "accepts list:list data -> data connection"
+        tool_runtime: "test_tool_execute::test_map_over_data_with_list_paired_or_unpaired"
+        workflow_editor: "accepts list:paired_or_unpaired data -> data connection"
 
 - doc: |
 
@@ -55,12 +126,13 @@
 - example:
     label: BASIC_MAPPING_INCLUDING_SINGLE_DATASET
     assumptions:
-    - "d1,...,dn are 'dataset's"
-    - "dother is a dataset"
-    - "tool = (i: dataset, i2: dataset) => {o: dataset}"
-    - "C = CollectionInstance<list,{i1=d1, ..., in=dn}>"
-    then:
-    - "tool(i=map_over(C),i2=dother) ~> {o: collection<list,{i1=tool(i=d1, i2=dother)[o],...,in=tool(i=dn, i2=dother)[o]]}>}"
+    - datasets: ["d_1,...,d_n", "d_o"]
+    - tool:
+        in: {i: dataset, i2: dataset}
+        out: {o: dataset}
+    - collections:
+        C: ["list", {i1: d_1, ..., in: d_n}]
+    then: "tool(i=mapOver(C),i2=d_o) ~> {o: collection<list,{i1=tool(i=d_1, i2=d_o)[o],...,in=tool(i=d_n, i2=d_o)[o]}>}"
 
 - doc: |
     If a tool consumes two input datasets and produces one output dataset, you can map two
@@ -79,21 +151,22 @@
     very naturally - again without extra work by the user and without extra knowledge
     by the tool author.
 
-
 - example:
     label: BASIC_MAPPING_TWO_INPUTS_WITH_IDENTICAL_STRUCTURE
     assumptions:
-    - "d11,...,d1n are 'dataset's"
-    - "d22,...,d2n are 'dataset's"
-    - "tool = (i: dataset, i2: dataset) => {o: dataset}"
-    - "C1 = CollectionInstance<list,[{i1=d1, ..., in=dn}]>"
-    - "C2 = CollectionInstance<list,[{i1=d1, ..., in=dn}]>"
-    then:
-    - "tool(i=map_over(C1), i2=map_over(C2)) ~> {o: collection<list,[i1=tool(i=d11, i2=d21)[o],...,in=tool(i=d1n, i2=d2n)[o]]]}"
+    - datasets: ["d1_1,...,d1_n", "d2_1,...,d2_n"]
+    - tool:
+        in: {i: dataset, i2: dataset}
+        out: {o: dataset}
+    - collections:
+        C1: ["list", {i1: d1_1, ..., in: d1_n}]
+        C2: ["list", {i1: d2_1, ..., in: d2_n}]
+    then: "tool(i=mapOver(C1), i2=mapOver(C2)) ~> {o: collection<list,{i1=tool(i=d1_1, i2=d2_1)[o],...,in=tool(i=d1_n, i2=d2_n)[o]]}>}"
     tests:
-    - tool_runtime: test_tools.py::test_map_over_two_collections
+        tool_runtime: test_tools.py::test_map_over_two_collections
 
-- doc: |
+- doc: "## Reduction"
+- doc: | 
     Not all tool executions result in implicit collections and mapping
     over inputs. Tool inputs of ``type`` ``data_collection`` can consume
     collections directly and do not necessarily result in mapping over.
@@ -105,41 +178,371 @@
 - example:
     label: COLLECTION_INPUT_PAIRED
     assumptions:
-    - "r, f are datasets"
-    - "tool = (i: collection<paired>) => {o: dataset}"
-    - "C = CollectionInstance<paired,[{forward=f, reverse=r}]>"
-    then:
-    - "tool(i=C) -> {o: dataset}"
+    - datasets: ["d_f", "d_r"]
+    - tool:
+        in: {i: "collection<paired>"}
+        out: {o: dataset}
+    - collections:
+        C: [paired, {forward: d_f, reverse: d_r}]
+    then: "tool(i=C) -> {o: dataset}"
+    tests:
+        tool_runtime: framework tests for collection_paired_test.xml
+        workflow_editor: "accepts paired -> paired connection"
+
+- example:
+    label: COLLECTION_INPUT_LIST
+    assumptions:
+    - datasets: ["d1,...,dn"]
+    - tool:
+        in: {i: "collection<list>"}
+        out: {o: dataset}
+    - collections:
+        C: [list, {el1: d_1, ..., eln: d_n}]
+    then: "tool(i=C) -> {o: dataset}"
+    tests:
+        workflow_editor: "accepts list -> list connection"
+
+- example:
+    label: COLLECTION_INPUT_PAIRED_OR_UNPAIRED
+    assumptions:
+    - datasets: [d_f, d_r]
+    - tool:
+        in: {i: "collection<paired_or_unpaired>"}
+        out: {o: dataset}
+    - collections:
+        C: [paired_or_unpaired, {forward: d_f, reverse: d_r}]
+    then: "tool(i=C) -> {o: dataset}"
+    tests:
+        tool_runtime: collection_paired_or_unpaired tool framework tests
+        workflow_editor: "accepts paired_or_unpaired data -> paired_or_unpaired connection"
+
+- example:
+    label: COLLECTION_INPUT_LIST_PAIRED_OR_UNPAIRED
+    assumptions:
+    - datasets: [d_f, d_r]
+    - tool:
+        in: {i: "collection<list:paired_or_unpaired>"}
+        out: {o: dataset}
+    - collections:
+        C: ["list:paired_or_unpaired", {el1: {forward: d_f, reverse: d_r}}]
+    then: "tool(i=C) -> {o: dataset}"
+    tests:
+        tool_runtime: collection_list_paired_or_unpaired tool framework tests
+        workflow_editor: "accepts list:paired_or_unpaired data -> list:paired_or_unpaired connection"
+
+- doc: |
+    For nested collections where each rank is a ``list`` or a ``paired`` collection,
+    then collection inputs must match every part of the collection type input definition.
+
+- example:
+    label: COLLECTION_INPUT_LIST_NOT_CONSUMES_PAIRS
+    assumptions:
+    - datasets: [d_f, d_r]
+    - tool:
+        in: {i: "collection<list>"} 
+        out: {o: dataset}
+    - collections:
+        C: [paired, {forward: d_f, reverse: d_r}]
+    then: "tool(i=C)"
+    is_valid: false
+    tests:
+        workflow_editor: "rejects connecting paired -> list"
+
+- example:
+    label: COLLECTION_INPUT_PAIRED_NOT_CONSUMES_LIST
+    assumptions:
+    - datasets: ["d_1,...,d_n"]
+    - tool:
+        in: {i: "collection<paired>"} 
+        out: {o: dataset}
+    - collections:
+        C: [list, {i1: d_1, ..., in: d_n}]
+    then: "tool(i=C)"
+    is_valid: false
+    tests:
+        workflow_editor: "rejects connecting list -> paired"
+
+- example:
+    label: COLLECTION_INPUT_LIST_PAIRED_NOT_CONSUMES_PAIRED_PAIRED
     tests:
-    -  tool_runtime: framework tests for collection_paired_test.xml
+        workflow_editor: "rejects paired:paired -> list:paired connection"
+
+- example:
+    label: COLLECTION_INPUT_LIST_PAIRED_OR_NOT_PAIRED_NOT_CONSUMES_PAIRED_PAIRED
+    tests:
+        workflow_editor: "rejects paired:paired -> list:paired_or_unpaired connection"
 
 - doc: |
     In addition to explicit collection inputs, tool inputs of ``type`` ``data``
     where ``multiple="true"`` can consume lists directly. This is likewise a
-    "reduction".
+    "reduction" and does not result in implicit collection creation.
 
 - example:
     label: LIST_REDUCTION
     assumptions:
-    - "d1,...,dn are 'dataset's"
-    - "tool = (i: dataset<multiple=true>) => {o: dataset}"
-    - "C = CollectionInstance<list,[{i1=d1, ..., in=dn}]>"
-    then:
-    - "tool(i=C) == tool(i=[d1,...,dn])"
+    - datasets: ["d_1,...,d_n"]
+    - tool: 
+        in: {i: "dataset<multiple=true>"}
+        out: {o: dataset}
+    - collections:
+        C: [list, {i1: d_1, ..., in: d_n}]
+    then: "tool(i=C) == tool(i=[d_1,...,d_n])"
+    tests:
+        tool_runtime: test_tools.py::test_reduce_collections
+        workflow_editor: "treats multi data input as list input"
+
+- doc: |
+    Paired collections cannot be reduced this way. ``paired`` is not meant
+    to represent a list/array/vector data structure - it is more like a tuple.
+
+- example:
+    label: PAIRED_REDUCTION_INVALID
+    assumptions:
+    - datasets: [d_f, d_r]
+    - tool: 
+        in: {i: "dataset<multiple=true>"}
+        out: {o: dataset}
+    - collections:
+        C: [paired, {forward: d_f, reverse: d_r}]
+    then: "tool(i=C)"
+    is_valid: false
+    tests:
+        workflow_editor: "rejects paired input on multi-data input"
+
+- example:
+    label: PAIRED_OR_UNPAIRED_REDUCTION_INVALID
+    assumptions:
+    - datasets: [d_f, d_r]
+    - tool: 
+        in: {i: "dataset<multiple=true>"}
+        out: {o: dataset}
+    - collections:
+        C: [paired_or_unpaired,{forward=d_f, reverse=d_r}]
+    then: "tool(i=C)"
+    is_valid: false
+    tests:
+        workflow_editor: "rejects paired_or_unpaired input on multi-data input"
+
+- doc: "## Sub-collection Mapping"
+- doc: |
+    ![](https://planemo.readthedocs.io/en/master/_images/subcollection_mapping_identifiers.svg)
+
+- example:
+    label: MAPPING_LIST_PAIRED_OVER_PAIRED
+    assumptions:
+    - datasets: [d_f, d_r]
+    - tool:
+        in: {i: "collection<paired>"}
+        out: {o: dataset}
+    - collections:
+        C: ["list:paired", {el1: {forward: d_f, reverse: d_r}}]
+        "C\\_PAIRED": [paired, {forward: d_f,reverse: d_r}]
+    then: "tool(i=mapOver(C, 'paired')) ~> {o: collection<list, {el1: tool(i=C\\_PAIRED)[o]}>}"
     tests:
-    - tool_runtime: test_tools.py::test_reduce_collections
-    - wf_editor: "treats multi data input as list input"
+        tool_runtime: "test_tools.py::test_subcollection_mapping"
+        workflow_editor: "accepts list:paired -> paired connection"
 
 - doc: |
-    Paired collections can not be reduced this way. ``paired`` is not meant
-    to represent a list/array/vector data structure it is more like a tuple.
+    The natural extension of multiple data input parameters consuming list collections as describe
+    above when discussing reductions is that nested lists of lists (``list:list``) can be mapped
+    over a multiple data input parameter. Each nested list will be reduced by this operation but the
+    results will be mapped over. The result will be a list with the same structure as the outer list
+    of the input collection.
 
 - example:
+    label: NESTED_LIST_REDUCTION
     assumptions:
-    - "r, f are datasets"
-    - "tool = (i: dataset<multiple=true>) => {o: dataset}"
-    - "C = CollectionInstance<paired,[{forward=f, reverse=r}]>"
-    then:
-    - "tool(i=C) is invalid"
+    - datasets: ["d_1,...,d_n"]
+    - tool:
+        in: {i: "dataset<multiple=true>"}
+        out: {o: dataset}
+    - collections:
+        C: ["list:list", {o1: {inner: d_1}, ..., "on": {inner: d_n}}]
+    then: "tool(i=mapOver(C, 'list')) ~> {o: collection<list,{o1: tool(i=[d_1])[o]},...,on: tool(i=[d_n])[o]}>}"
     tests:
-    - wf_editor: "rejects paired input on multi-data input"
+        workflow_editor: "maps list:list over multi data input"
+
+- doc: |
+    Just as a paired collection won't be reduced by a multiple data input, any sort of nested
+    collection ending in a paired collection cannot be mapped over such an input. So a multiple
+    data input parameter cannot be mapped over by a list of pairs (``list:paired``) for instance.
+
+- example:
+    label: LIST_PAIRED_REDUCTION_INVALID
+    assumptions:
+    - datasets: [d_f, d_r]
+    - tool: 
+        in: {i: "dataset<multiple=true>"}
+        out: {o: dataset}
+    - collections:
+        C: [list:paired, {forward: d_f, reverse: d_r}]
+    then: "tool(i=mapOver(C, 'paired'))"
+    is_valid: false
+    tests:
+        workflow_editor: "rejects list:paired input on multi-data input"
+
+- example:
+    label: LIST_PAIRED_OR_UNPAIRED_REDUCTION_INVALID
+    assumptions:
+    - datasets: [d_f, d_r]
+    - tool: 
+        in: {i: "dataset<multiple=true>"}
+        out: {o: dataset}
+    - collections:
+        C: ["list:paired_or_unpaired", {forward: d_f, reverse: d_r}]
+    then: "tool(i=mapOver(C, 'paired_or_unpaired'))"
+    is_valid: false
+    tests:
+        workflow_editor: "rejects list:paired_or_unpaired input on multi-data input"
+
+- doc: "## paired_or_unpaired Collections"
+- doc: |
+    The collection type ``paired_or_unpaired`` is meant to serve as a stand-in for
+    an entity that can be either a single dataset or what is effectively a ``paired``
+    dataset collection. These collections either have one element with identifier
+    ``unpaired`` or two elements with identifiers ``forward`` and ``reverse``.
+
+    Tools can declare a data_collection input with collection type ``paired_or_unpaired``
+    and that input will consume either an explicit ``paired_or_unpaired`` collection
+    normally or can consume a ``paired`` input.
+
+- example:
+    label: PAIRED_OR_UNPAIRED_CONSUMES_PAIRED
+    assumptions:
+    - datasets: [d_f, d_r]
+    - tool:
+        in: {i: "collection<paired_or_unpaired>"}
+        out: {o: dataset}
+    - collections:
+        C: [paired, {forward: d_f, reverse: d_r}]
+    - "C_AS_MIXED = CollectionInstance<paired_or_unpaired, {forward: d_f, reverse: d_r}>"
+    then: "tool(i=C) == tool(i=C_AS_MIXED)"
+    tests:
+        tool_runtime: collection_paired_or_unpaired tool framework test (third)
+        workflow_editor: "accepts paired -> paired_or_unpaired connection"
+
+- doc: |
+
+    This inverse of this doesn't work intentionally. In some ways a ``paired`` collection
+    acts as a ``paired_or_unpaired`` collection but a ``paired_or_unpaired`` is not a paired
+    collection. This makes a lot of sense in terms of tools - a tool consuming a ``paired``
+    dataset expects to find both a ``forward`` and ``reverse`` element but these may not exist
+    in ``paired_or_unpaired`` collection.
+
+- example:
+    label: PAIRED_OR_UNPAIRED_NOT_CONSUMED_BY_PAIRED
+    assumptions:
+    - datasets: [d_f, d_r]
+    - tool:
+        in: {i: "collection<paired>"}
+        out: {o: dataset}
+    - collections:
+        C: [paired_or_unpaired, {forward=d_f, reverse: d_r}]
+    then: "tool(i=C) is invalid"
+    tests:
+        workflow_editor: "rejects paired_or_unpaired -> paired connection"
+
+- doc: |
+
+    The same logic holds for mapping, lists of paired datasets (``list:paired``) can be mapped over these
+    ``paired_or_unpaired`` inputs and mixed lists of pairs (``list:paired_or_unpaired``) cannot
+    be mapped over a ``paired`` input. Following the same logic, ``list:paired_or_unpaired`` cannot
+    be mapped over a ``list`` input or multiple data input.
+
+- example:
+    label: MAPPING_LIST_PAIRED_OVER_PAIRED_OR_UNPAIRED
+    assumptions:
+    - datasets: [d_f, d_r]
+    - tool:
+        in: {i: "collection<paired_or_unpaired>"}
+        out: {o: dataset}
+    - collections:
+        C: ["list:paired", {el: {forward: d_f, reverse: d_r}}]
+        C_AS_MIXED: ["list:paired_or_unpaired", {el: {forward: d_f, reverse: d_r}}]
+    then: "tool(i=mapOver(C)) == tool(i=mapOver(C_AS_MIXED))"
+    tests:
+        workflow_editor: "accepts list:paired -> paired_or_unpaired connection"
+
+- example:
+    label: PAIRED_OR_UNPAIRED_NOT_CONSUMED_BY_PAIRED_WHEN_MAPPING
+    assumptions:
+    - datasets: [d_f, d_r]
+    - tool:
+        in: {i: "collection<paired>"}
+        out: {o: dataset}
+    - collections:
+        C: [list:paired_or_unpaired, {el: {forward: f, reverse: r}}]
+    then: "tool(i=mapOver(C)) is invalid"
+    tests:
+        workflow_editor: "rejects list:paired_or_unpaired -> paired connection"
+
+- example:
+    label: PAIRED_OR_UNPAIRED_NOT_CONSUMED_BY_LIST_WHEN_MAPPING
+    assumptions:
+    - datasets: [d_f, d_r]
+    - tool:
+        in: {i: "collection<list>"}
+        out: {o: dataset}
+    - collections:
+        C: [list:paired_or_unpaired, {el: {forward: f, reverse: r}}]
+    then: "tool(i=mapOver(C)) is invalid"
+    tests:
+        workflow_editor: "rejects list:paired_or_unpaired -> list connection"
+
+- doc: |
+    This logic extends naturally into higher dimensional collections. A ``list:list:paired``
+    can be mapped over either a ``paired_or_unpaired`` input to produce a nested list (``list:list``)
+    or a ``list:paired_or_unpaired`` input to produce a flat list (``list``).
+
+- example:
+    label: MAPPING_LIST_LIST_PAIRED_OVER_PAIRED_OR_UNPAIRED
+    tests:
+        workflow_editor: "accepts list:list:paired -> paired_or_unpaired connection"
+
+- doc: |
+
+    In order for ``paired_or_unpaired`` collections to also act as a single dataset,
+    a flat list can be mapped over a such an input with a special sub collection mapping
+    type of 'single_datasets'.
+
+- example:
+    label: MAPPING_LIST_OVER_PAIRED_OR_UNPAIRED
+    assumptions:
+    - datasets: ["d_1,...,d_n"]
+    - tool:
+        in: {i: "collection<paired_or_unpaired>"}
+        out: {o: dataset}
+    - collections:
+        C: [list, {i1: d_1, ..., in: d_n}]
+    - "C_AS_UNPAIRED_i = CollectionInstance<paired_or_unpaired,{unpaired=di}> for i from 1...n"
+    then: "tool(i=mapOver(C, 'single_datasets')) ~> {o: collection<list,{i1=tool(i=C_AS_UNPAIRED_1)[o],...,in=tool(i=C_AS_UNPAIRED_n)[o]]}>}"
+    tests:
+        tool_runtime: test_map_over_paired_or_unpaired_with_list
+        workflow_editor: "accepts list -> paired_or_unpaired connection"
+
+- doc: |
+    This treatment of lists without pairing extends to nested structures naturally.
+    For instance, a list of list of datasets (``list:list``) can be mapped over a
+    ``paired_or_unpaired`` input to produce a nested list of lists (``list:list``)
+    with a structure matching the input. Likewise, the nested list can be mapped over
+    a ``list:paired_or_unpaired`` input to produce a flat list with the same structure
+    as the outer list of the input.
+
+- example:
+    label: MAPPING_LIST_LIST_OVER_PAIRED_OR_UNPAIRED
+    tests:
+        workflow_editor: "accepts list:list -> paired_or_unpaired connection"
+
+- example:
+    label: MAPPING_LIST_LIST_OVER_LIST_PAIRED_OR_UNPAIRED
+    tests:
+        workflow_editor: "accepts list:list -> list:paired_or_unpaired connection"
+
+- doc: |
+    Due only implementation time, the special casing of allowing paired_or_unpaired
+    act as both datasets and paired collections only works when it is the deepest
+    collection type. So while list:paired can be consumed by a list:paired_or_unpaired
+    input, a paired:list cannot be consumed by a paired_or_unpaired:list input though
+    it should be able to for consistency. We have focused our time on data structures
+    more likely to be used in actual Galaxy analyses given current and guessed future
+    usage.
diff --git a/lib/galaxy/model/dataset_collections/types/paired.py b/lib/galaxy/model/dataset_collections/types/paired.py
index e774ab67aace..c75b9a8cc3c1 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 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/model/dataset_collections/types/semantics.py b/lib/galaxy/model/dataset_collections/types/semantics.py
new file mode 100644
index 000000000000..b2b5930d1716
--- /dev/null
+++ b/lib/galaxy/model/dataset_collections/types/semantics.py
@@ -0,0 +1,208 @@
+#!/usr/bin/env python
+
+# how to use this function...
+# PYTHONPATH=lib python lib/galaxy/model/dataset_collections/types/semantics.py
+import argparse
+import os
+from io import StringIO
+from typing import (
+    Any,
+    Dict,
+    List,
+    NamedTuple,
+    Optional,
+    Tuple,
+    Union,
+)
+
+import yaml
+from pydantic import (
+    BaseModel,
+    Field,
+    RootModel,
+)
+
+from galaxy.util import galaxy_directory
+from galaxy.util.resources import resource_string
+
+DESCRIPTION = """This script parses the collection_semantics.yml file and creates Markdown documentation from it.
+"""
+
+
+class DocEntry(BaseModel):
+    doc: str
+
+
+class ExampleTests(BaseModel):
+    tool_runtime: Optional[str] = None
+    workflow_editor: Optional[str] = None
+
+
+class DatasetsDeclaration(BaseModel):
+    datasets: List[str]
+
+    def as_latex(self) -> str:
+        return ", ".join([f"$ {d} $" for d in self.datasets])
+
+
+class ToolDefinition(BaseModel):
+    inputs: Dict[str, str] = Field(alias="in")
+    outputs: Dict[str, str] = Field(alias="out")
+
+    def as_latex(self) -> str:
+        inputs = ", ".join([f"{k}: \\text{{ {v} }}" for (k, v) in self.inputs.items()])
+        outputs = ", ".join([f"{k}: \\text{{ {v} }}" for (k, v) in self.outputs.items()])
+        return f"tool \\text{{ is }} ({inputs}) \\Rightarrow \\{{ {outputs} \\}}"
+
+
+class ToolDeclaration(BaseModel):
+    tool: ToolDefinition
+
+    def as_latex(self) -> str:
+        return self.tool.as_latex()
+
+
+def elements_to_latex(elements: Dict[str, Any]):
+    elements_as_strings = []
+    for identifier, value in elements.items():
+        if value is None:
+            elements_as_strings.append(identifier)
+        else:
+            if isinstance(value, dict):
+                value_str = elements_to_latex(value)
+            else:
+                value_str = str(value)
+            elements_as_strings.append(f"\\text{{ {identifier} }}={value_str}")
+    unwrapped_elements = ", ".join(elements_as_strings)
+    return f"\\left\\{{ {unwrapped_elements} \\right\\}}"
+
+
+class CollectionDefinition(NamedTuple):
+    collection_type: str
+    elements: Dict[str, Any]
+
+    def as_latex(self) -> str:
+        collection_type = self.collection_type.replace("_", "\\_")
+        return f"\\text{{CollectionInstance<}}{collection_type},{elements_to_latex(self.elements)}\\text{{>}}"
+
+
+class CollectionDeclarations(BaseModel):
+    collections: Dict[str, CollectionDefinition]
+
+
+Expression = Union[str, DatasetsDeclaration, ToolDeclaration, CollectionDeclarations]
+
+
+class Example(BaseModel):
+    label: str
+    assumptions: Optional[List[Expression]] = None
+    then: Optional[str] = None
+    is_valid: bool = True
+    tests: Optional[ExampleTests] = None
+
+
+class ExampleEntry(BaseModel):
+    example: Example
+
+
+YAMLRootModel = RootModel[List[Union[DocEntry, ExampleEntry]]]
+
+
+WORDS_TO_TEXTIFY = ["list", "forward", "reverse", "mapOver"]
+
+
+def expression_to_latex(expression: str, wrap: bool = True):
+    expression = expression.replace("->", "\\rightarrow")
+    expression = expression.replace("~>", "\\mapsto")
+    expression = expression.replace("{", "\\left\\{")
+    expression = expression.replace("}", "\\right\\}")
+    expression = expression.replace("paired_or_unpaired", "paired\\_or\\_unpaired")
+    for word in WORDS_TO_TEXTIFY:
+        expression = expression.replace(word, "\\text{" + word + "}")
+    if wrap:
+        return f"$ {expression} $"
+    else:
+        return f"{expression}"
+
+
+def collect_docs_with_examples(root: YAMLRootModel) -> List[Tuple[DocEntry, List[ExampleEntry]]]:
+    docs_with_examples = []
+
+    current_doc: Optional[DocEntry] = None
+    current_examples: List[ExampleEntry] = []
+    for entry in root.root:
+        if isinstance(entry, DocEntry):
+            if current_doc:
+                docs_with_examples.append((current_doc, current_examples))
+            current_examples = []
+            current_doc = entry
+        if isinstance(entry, ExampleEntry):
+            if entry.example.then:
+                current_examples.append(entry)
+
+    docs_with_examples.append((current_doc, current_examples))
+    return docs_with_examples
+
+
+def main():
+    semantics_yaml = yaml.safe_load(
+        resource_string("galaxy.model.dataset_collections.types", "collection_semantics.yml")
+    )
+
+    # Parse the YAML and extract doc elements
+    root_model = YAMLRootModel.model_validate(semantics_yaml)
+
+    docs_with_examples = collect_docs_with_examples(root_model)
+    markdown_content = StringIO()
+    for doc_with_examples in docs_with_examples:
+        doc_entry, examples = doc_with_examples
+        markdown_content.write(doc_entry.doc)
+        if len(examples):
+            markdown_content.write("\n\n")
+            for example_entry in examples:
+                markdown_content.write(f"({example_entry.example.label})=\n")
+            markdown_content.write("<details><summary>Examples</summary>")
+            for example_entry in examples:
+
+                example = example_entry.example
+                markdown_content.write("\n\n")
+                markdown_content.write(f":::{{admonition}} Example: `{example.label}` \n")
+                markdown_content.write(":class: note\n\n")
+                if example.assumptions:
+                    markdown_content.write("Assuming,")
+                    markdown_content.write("\n\n")
+                    for assumption in example.assumptions:
+                        if isinstance(assumption, DatasetsDeclaration):
+                            markdown_content.write(f"* {assumption.as_latex()}")
+                            if len(assumption.datasets) == 1 and "..." not in assumption.datasets[0]:
+                                markdown_content.write(" is a dataset\n")
+                            else:
+                                markdown_content.write(" are datasets\n")
+                        elif isinstance(assumption, ToolDeclaration):
+                            markdown_content.write(f"* $ {assumption.as_latex()} $\n")
+                        elif isinstance(assumption, CollectionDeclarations):
+                            for name, collection in assumption.collections.items():
+                                markdown_content.write(f"* $ {name} $ is $ {collection.as_latex()} $\n")
+                        else:
+                            markdown_content.write(f"* {expression_to_latex(assumption)}\n")
+                if example.then:
+                    validity_str = ""
+                    if not example.is_valid:
+                        validity_str = "\\text{ is invalid}"
+                    markdown_content.write(f"\n\nthen\n\n$${expression_to_latex(example.then, wrap=False)}{validity_str}$$\n\n")
+                markdown_content.write(":::\n\n")
+            markdown_content.write("\n\n</details><br>\n\n")
+        markdown_content.write("\n\n")
+
+    # Extract and concatenate doc elements
+    with open(os.path.join(galaxy_directory(), "doc/source/dev/collection_semantics.md"), "w") as f:
+        f.write(markdown_content.getvalue())
+
+
+def arg_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(description=DESCRIPTION)
+    return parser
+
+
+if __name__ == "__main__":
+    main()
diff --git a/lib/galaxy/schema/schema.py b/lib/galaxy/schema/schema.py
index 5c2d0513a3c1..1c346516dd68 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 1feae64168f2..9ece0a6c4281 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..d75ef1c4f668 100644
--- a/lib/galaxy/tools/actions/__init__.py
+++ b/lib/galaxy/tools/actions/__init__.py
@@ -17,6 +17,7 @@
 )
 
 from packaging.version import Version
+from pydantic import BaseModel
 
 from galaxy import model
 from galaxy.exceptions import (
@@ -34,6 +35,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 +267,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 +941,24 @@ 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):
+                    adapter = cast(CollectionAdapter, dataset_collection)
+                    # we are recording the adapter json in the database for tracking but it isn't
+                    # actually used in the code and we don't track the adapter json for like list
+                    # of datasets -> collection adaption because it isn't clear where to track that
+                    # (see elif isinstance(adapting, list) branch below).
+                    adapter_model = cast(BaseModel, adapter.to_adapter_model())
+                    adapting = adapter.adapting
+                    if isinstance(adapting, model.DatasetCollectionElement):
+                        job.add_input_dataset_collection_element(name, adapting, adapter_json=adapter_model.model_dump())
+                    elif isinstance(adapting, model.HistoryDatasetAssociation):
+                        job.add_input_dataset(name, dataset=adapting, adapter_json=adapter_model.model_dump())
+                    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..5f8339f2ccd8 100644
--- a/lib/galaxy_test/api/test_tool_execute.py
+++ b/lib/galaxy_test/api/test_tool_execute.py
@@ -380,6 +380,136 @@ 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_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_paired_or_unpaired_paired(target_history: TargetHistory, required_tool: RequiredTool):
+    hdca = target_history.with_paired_or_unpaired_pair()
+    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("paired_or_unpaired")
+    output_collection.assert_has_dataset_element("forward").with_contents_stripped("123")
+    output_collection.assert_has_dataset_element("reverse").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..06a71dbcbfe7 100644
--- a/lib/galaxy_test/base/populators.py
+++ b/lib/galaxy_test/base/populators.py
@@ -3077,6 +3077,37 @@ 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_paired_or_unpaired_pair_in_history(self, history_id: str, wait: bool = False, **kwds):
+        contents = [("forward", "123"), ("reverse", "456")]
+        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 +3615,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 +3968,23 @@ 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_paired_or_unpaired_pair(self) -> "HasSrcDict":
+        return self._fetch_response(
+            self._dataset_collection_populator.create_paired_or_unpaired_pair_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 +4002,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..93c7fd4a8c7d 100644
--- a/test/unit/data/dataset_collections/test_matching.py
+++ b/test/unit/data/dataset_collections/test_matching.py
@@ -48,6 +48,19 @@ def test_valid_collection_subcollection_matching():
     assert_can_match((nested_list, "paired"), flat_list)
 
 
+# can pass a paired input to a paired_or_unpaired input but not vice versa
+def test_paired_can_act_as_paired_or_unpaired():
+    paired = pair_instance()
+    optional_paired = paired_or_unpaired_pair_instance()
+    assert_can_match(optional_paired, paired)
+
+
+def test_paired_or_unpaired_cannot_act_as_paired():
+    paired = pair_instance()
+    optional_paired = paired_or_unpaired_pair_instance()
+    assert_cannot_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 +127,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..abea57c5bcde 100644
--- a/test/unit/data/dataset_collections/test_type_descriptions.py
+++ b/test/unit/data/dataset_collections/test_type_descriptions.py
@@ -1,18 +1,43 @@
 from galaxy.model.dataset_collections.type_description import CollectionTypeDescriptionFactory
 
+factory = CollectionTypeDescriptionFactory(None)
+
+
+def c_t(collection_type: str):
+    return factory.for_collection_type(collection_type)
+
 
 def test_simple_descriptions():
-    factory = CollectionTypeDescriptionFactory(None)
-    nested_type_description = factory.for_collection_type("list:paired")
-    paired_type_description = factory.for_collection_type("paired")
+    nested_type_description = c_t("list:paired")
+    paired_type_description = c_t("paired")
     assert not nested_type_description.has_subcollections_of_type("list")
     assert not nested_type_description.has_subcollections_of_type("list:paired")
     assert nested_type_description.has_subcollections_of_type("paired")
     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 = c_t("list")
+    assert list_type_description.has_subcollections_of_type("paired_or_unpaired")
+    paired_type_description = c_t("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")