diff --git a/client/package.json b/client/package.json
index de12b9f71852..86720d29ca7d 100644
--- a/client/package.json
+++ b/client/package.json
@@ -45,6 +45,8 @@
     "@types/jest": "^29.5.12",
     "@vueuse/core": "^10.5.0",
     "@vueuse/math": "^10.9.0",
+    "ag-grid-community": "^30",
+    "ag-grid-vue": "^30",
     "assert": "^2.1.0",
     "axios": "^1.6.2",
     "babel-runtime": "^6.26.0",
@@ -106,11 +108,13 @@
     "vega-embed": "^6.26.0",
     "vega-lite": "^5.21.0",
     "vue": "^2.7.14",
+    "vue-class-component": "^7.2.6",
     "vue-echarts": "^7.0.3",
     "vue-infinite-scroll": "^2.0.2",
     "vue-multiselect": "^2.1.7",
     "vue-observe-visibility": "^1.0.0",
     "vue-prismjs": "^1.2.0",
+    "vue-property-decorator": "^9.1.2",
     "vue-router": "^3.6.5",
     "vue-rx": "^6.2.0",
     "vue-virtual-scroll-list": "^2.3.5",
diff --git a/client/src/api/datasetCollections.ts b/client/src/api/datasetCollections.ts
index f659ec4982c4..08c53058deff 100644
--- a/client/src/api/datasetCollections.ts
+++ b/client/src/api/datasetCollections.ts
@@ -1,4 +1,12 @@
-import { type CollectionEntry, type DCESummary, GalaxyApi, type HDCADetailed, type HDCASummary, isHDCA } from "@/api";
+import {
+    type CollectionEntry,
+    type components,
+    type DCESummary,
+    GalaxyApi,
+    type HDCADetailed,
+    type HDCASummary,
+    isHDCA,
+} from "@/api";
 import { rethrowSimple } from "@/utils/simple-error";
 
 const DEFAULT_LIMIT = 50;
@@ -76,3 +84,44 @@ export async function fetchElementsFromCollection(params: {
         limit: params.limit ?? DEFAULT_LIMIT,
     });
 }
+
+export type CollectionElementIdentifiers = components["schemas"]["CollectionElementIdentifier"][];
+export type CreateNewCollectionPayload = components["schemas"]["CreateNewCollectionPayload"];
+
+export type NewCollectionOptions = {
+    name: string;
+    element_identifiers: CollectionElementIdentifiers;
+    collection_type: string;
+    history_id: string;
+    copy_elements?: boolean;
+    hide_source_items?: boolean;
+};
+
+export function createCollectionPayload(options: NewCollectionOptions): CreateNewCollectionPayload {
+    return {
+        name: options.name,
+        history_id: options.history_id,
+        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 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,
+    });
+
+    if (error) {
+        rethrowSimple(error);
+    }
+    return data;
+}
diff --git a/client/src/api/datasets.ts b/client/src/api/datasets.ts
index 6b8f0606537c..fb4809c8487a 100644
--- a/client/src/api/datasets.ts
+++ b/client/src/api/datasets.ts
@@ -67,6 +67,7 @@ export async function copyDataset(
             // TODO: Investigate. These should be optional, but the API requires explicit null values?
             type,
             copy_elements: null,
+            fields: null,
             hide_source_items: null,
             instance_type: null,
         },
diff --git a/client/src/api/index.ts b/client/src/api/index.ts
index 6f9ce9d0213d..0d98015f5098 100644
--- a/client/src/api/index.ts
+++ b/client/src/api/index.ts
@@ -306,6 +306,9 @@ export type DatasetTransform = {
  */
 export type MessageException = components["schemas"]["MessageExceptionModel"];
 
+export type FieldDict = components["schemas"]["FieldDict"];
+export type FieldType = FieldDict["type"];
+
 export type StoreExportPayload = components["schemas"]["StoreExportPayload"];
 export type ModelStoreFormat = components["schemas"]["ModelStoreFormat"];
 export type ObjectExportTaskResponse = components["schemas"]["ObjectExportTaskResponse"];
diff --git a/client/src/api/schema/schema.ts b/client/src/api/schema/schema.ts
index 143894d20b33..1b74e3d0de61 100644
--- a/client/src/api/schema/schema.ts
+++ b/client/src/api/schema/schema.ts
@@ -6948,6 +6948,12 @@ export interface components {
              * @description List of elements that should be in the new collection.
              */
             element_identifiers?: components["schemas"]["CollectionElementIdentifier"][] | null;
+            /**
+             * Fields
+             * @description List of fields to create for this collection. Set to 'auto' to guess fields from identifiers.
+             * @default []
+             */
+            fields: string | components["schemas"]["FieldDict"][] | null;
             /**
              * Folder Id
              * @description The ID of the library folder that will contain the collection. Required if `instance_type=library`.
@@ -7140,6 +7146,12 @@ export interface components {
              * @description List of elements that should be in the new collection.
              */
             element_identifiers?: components["schemas"]["CollectionElementIdentifier"][] | null;
+            /**
+             * Fields
+             * @description List of fields to create for this collection. Set to 'auto' to guess fields from identifiers.
+             * @default []
+             */
+            fields: string | components["schemas"]["FieldDict"][] | null;
             /**
              * Folder Id
              * @description The ID of the library folder that will contain the collection. Required if `instance_type=library`.
@@ -9082,6 +9094,17 @@ export interface components {
             /** Hash Value */
             hash_value: string;
         };
+        /** FieldDict */
+        FieldDict: {
+            /** Format */
+            format?: string | null;
+            /** Name */
+            name: string;
+            /** Type */
+            type:
+                | ("File" | "null" | "boolean" | "int" | "float" | "string")
+                | ("File" | "null" | "boolean" | "int" | "float" | "string")[];
+        };
         /** FileDataElement */
         FileDataElement: {
             /** Md5 */
diff --git a/client/src/components/Collections/BuildFileSetWizard.vue b/client/src/components/Collections/BuildFileSetWizard.vue
new file mode 100644
index 000000000000..c74a53202c37
--- /dev/null
+++ b/client/src/components/Collections/BuildFileSetWizard.vue
@@ -0,0 +1,220 @@
+<script setup lang="ts">
+import { BCardGroup } from "bootstrap-vue";
+import { computed, ref } from "vue";
+
+import { getGalaxyInstance } from "@/app";
+import { attemptCreate, type CollectionCreatorComponent } from "@/components/Collections/common/useCollectionCreator";
+import { rawToTable } from "@/components/Collections/tables";
+import { useWizard } from "@/components/Common/Wizard/useWizard";
+import { useToolRouting } from "@/composables/route";
+
+import { type RemoteFile, type RulesCreatingWhat, type RulesSourceFrom } from "./wizard/types";
+import { useFileSetSources } from "./wizard/useFileSetSources";
+
+import CreatingWhat from "./wizard/CreatingWhat.vue";
+import PasteData from "./wizard/PasteData.vue";
+import SelectDataset from "./wizard/SelectDataset.vue";
+import SelectFolder from "./wizard/SelectFolder.vue";
+import SourceFromCollection from "./wizard/SourceFromCollection.vue";
+import SourceFromDatasetAsTable from "./wizard/SourceFromDatasetAsTable.vue";
+import SourceFromPastedData from "./wizard/SourceFromPastedData.vue";
+import SourceFromRemoteFiles from "./wizard/SourceFromRemoteFiles.vue";
+import GenericWizard from "@/components/Common/Wizard/GenericWizard.vue";
+import RuleCollectionBuilder from "@/components/RuleCollectionBuilder.vue";
+
+const isBusy = ref<boolean>(false);
+const { pasteData, tabularDatasetContents, uris, setRemoteFilesFolder, onFtp, setDatasetContents, setPasteTable } =
+    useFileSetSources(isBusy);
+
+interface Props {
+    fileSourcesConfigured: boolean;
+    ftpUploadSite?: string;
+    mode: "uploadModal" | "standalone";
+}
+
+const props = defineProps<Props>();
+
+const ruleState = ref(false);
+const creatingWhat = ref<RulesCreatingWhat>("datasets");
+const creatingWhatTitle = computed(() => {
+    return creatingWhat.value == "datasets" ? "Datasets" : "Collections";
+});
+const sourceInstructions = computed(() => {
+    return `${creatingWhatTitle.value} can be created from a set or files, URIs, or existing datasets.`;
+});
+const collectionCreator = ref<CollectionCreatorComponent | undefined>();
+
+const sourceFrom = ref<RulesSourceFrom>("remote_files");
+
+const { routeToTool } = useToolRouting();
+
+const wizard = useWizard({
+    "select-what": {
+        label: "What is being created?",
+        instructions: computed(() => {
+            return `Are you creating datasets or collections?`;
+        }),
+        isValid: () => true,
+        isSkippable: () => false,
+    },
+    "select-source": {
+        label: "Select source",
+        instructions: sourceInstructions,
+        isValid: () => true,
+        isSkippable: () => false,
+    },
+    "select-remote-files-folder": {
+        label: "Select folder",
+        instructions: "Select folder of files to import.",
+        isValid: () => sourceFrom.value === "remote_files" && Boolean(uris.value.length > 0),
+        isSkippable: () => sourceFrom.value !== "remote_files",
+    },
+    "paste-data": {
+        label: "Paste data",
+        instructions: "Paste data (or drop file) containing URIs and optional extra metadata.",
+        isValid: () => sourceFrom.value === "pasted_table" && pasteData.value.length > 0,
+        isSkippable: () => sourceFrom.value !== "pasted_table",
+    },
+    "select-dataset": {
+        label: "Select dataset",
+        instructions: "Select tabular dataset to load URIs and metadata from.",
+        isValid: () => sourceFrom.value === "dataset_as_table" && tabularDatasetContents.value.length > 0,
+        isSkippable: () => sourceFrom.value !== "dataset_as_table",
+    },
+    "rule-builder": {
+        label: "Specify Rules",
+        instructions: "Use this form to describe rules for importing",
+        isValid: () => ruleState.value,
+        isSkippable: () => props.mode == "uploadModal",
+        width: "100%",
+    },
+});
+
+const importButtonLabel = computed(() => {
+    if (sourceFrom.value == "collection") {
+        return "Transform";
+    } else {
+        return "Import";
+    }
+});
+
+const emit = defineEmits(["dismiss", "created"]);
+type SelectionType = "raw" | "remote_files";
+type ElementsType = RemoteFile[] | string[][];
+
+// it would be nice to have a real type from the rule builder but
+// it is older code. This is really outlining what this component can
+// produce and not what the rule builder can consume which is a wide
+// superset of this.
+interface Entry {
+    dataType: RulesCreatingWhat;
+    ftpUploadSite?: string;
+    elements?: ElementsType | undefined;
+    content?: string;
+    selectionType: SelectionType;
+}
+
+const ruleBuilderModalEntryProps = computed(() => {
+    let elements: ElementsType | undefined = undefined;
+    let selectionType: SelectionType = "raw";
+    if (sourceFrom.value == "remote_files") {
+        elements = uris.value;
+        selectionType = "remote_files";
+    } else if (sourceFrom.value == "pasted_table") {
+        elements = pasteData.value;
+    } else if (sourceFrom.value == "dataset_as_table") {
+        elements = tabularDatasetContents.value;
+    }
+    const entry: Entry = {
+        dataType: creatingWhat.value,
+        ftpUploadSite: props.ftpUploadSite,
+        selectionType: selectionType,
+        elements: elements,
+    };
+    return entry;
+});
+
+const ruleBuilderElements = computed(() => {
+    const builderProps = ruleBuilderModalEntryProps.value;
+    let elements;
+    if (builderProps.elements) {
+        elements = builderProps.elements;
+    } else {
+        elements = rawToTable(builderProps.content || "");
+    }
+    return elements;
+});
+
+function launchRuleBuilder() {
+    const Galaxy = getGalaxyInstance();
+    const entry = ruleBuilderModalEntryProps.value;
+    Galaxy.currHistoryPanel.buildCollectionFromRules(entry, null, true);
+}
+
+function submit() {
+    if (sourceFrom.value == "collection") {
+        routeToTool("__APPLY_RULES__");
+    } else if (props.mode == "standalone") {
+        attemptCreate(collectionCreator);
+    } else {
+        launchRuleBuilder();
+    }
+    emit("dismiss");
+}
+
+function setCreatingWhat(what: RulesCreatingWhat) {
+    creatingWhat.value = what;
+}
+
+function setSourceForm(newValue: RulesSourceFrom) {
+    sourceFrom.value = newValue;
+}
+
+function onRuleState(newRuleState: boolean) {
+    ruleState.value = newRuleState;
+}
+
+function onRuleCreate() {
+    // axios response data for job currently sent, not really used but wanted to document what is available.
+    emit("created");
+}
+</script>
+
+<template>
+    <GenericWizard :use="wizard" :submit-button-label="importButtonLabel" @submit="submit">
+        <div v-if="wizard.isCurrent('select-what')">
+            <CreatingWhat :creating-what="creatingWhat" @onChange="setCreatingWhat" />
+        </div>
+        <div v-else-if="wizard.isCurrent('select-source')">
+            <BCardGroup deck>
+                <SourceFromRemoteFiles :selected="sourceFrom === 'remote_files'" @select="setSourceForm" />
+                <SourceFromPastedData :selected="sourceFrom === 'pasted_table'" @select="setSourceForm" />
+                <SourceFromDatasetAsTable :selected="sourceFrom === 'dataset_as_table'" @select="setSourceForm" />
+                <SourceFromCollection
+                    v-if="creatingWhat == 'collections'"
+                    :selected="sourceFrom === 'collection'"
+                    @select="setSourceForm" />
+            </BCardGroup>
+        </div>
+        <div v-else-if="wizard.isCurrent('paste-data')">
+            <PasteData @onChange="setPasteTable" />
+        </div>
+        <div v-else-if="wizard.isCurrent('select-remote-files-folder')">
+            <SelectFolder :ftp-upload-site="ftpUploadSite" @onChange="setRemoteFilesFolder" @onFtp="onFtp" />
+        </div>
+        <div v-else-if="wizard.isCurrent('select-dataset')">
+            <SelectDataset @onChange="setDatasetContents" />
+        </div>
+        <div v-else-if="wizard.isCurrent('rule-builder')" style="width: 100%">
+            <RuleCollectionBuilder
+                ref="collectionCreator"
+                grid-implementation="ag"
+                :import-type="creatingWhat"
+                :elements-type="ruleBuilderModalEntryProps.selectionType"
+                :initial-elements="ruleBuilderElements"
+                mode="wizard"
+                @onCreate="onRuleCreate"
+                @validInput="onRuleState" />
+        </div>
+    </GenericWizard>
+</template>
diff --git a/client/src/components/Collections/CollectionCreatorModal.vue b/client/src/components/Collections/CollectionCreatorModal.vue
index 8db25d243c6d..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"
-            @clicked-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"
-            @clicked-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 d33f98927d83..cb8377eda4fd 100644
--- a/client/src/components/Collections/ListCollectionCreator.vue
+++ b/client/src/components/Collections/ListCollectionCreator.vue
@@ -9,12 +9,14 @@ 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 STATES from "@/mvc/dataset/states";
-import { useDatatypesMapperStore } from "@/stores/datatypesMapperStore";
 import localize from "@/utils/localization";
 
+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";
 import DatasetCollectionElementView from "@/components/Collections/ListDatasetCollectionElementView.vue";
@@ -27,13 +29,16 @@ interface Props {
     defaultHideSourceItems?: boolean;
     fromSelection?: boolean;
     extensions?: string[];
+    mode: Mode;
 }
 
 const props = defineProps<Props>();
 
 const emit = defineEmits<{
-    (e: "clicked-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");
@@ -41,9 +46,10 @@ const duplicateNames = ref<string[]>([]);
 const invalidElements = ref<string[]>([]);
 const workingElements = ref<HDASummary[]>([]);
 const selectedDatasetElements = ref<string[]>([]);
-const hideSourceItems = ref(props.defaultHideSourceItems || false);
 const atLeastOneElement = ref(true);
 
+const { updateIdentifierIfUnchanged } = useUpdateIdentifiersForRemoveExtensions(props);
+
 const atLeastOneDatasetIsSelected = computed(() => {
     return selectedDatasetElements.value.length > 0;
 });
@@ -72,12 +78,16 @@ const allElementsAreInvalid = computed(() => {
 /** If not `fromSelection`, the list of elements that will become the collection */
 const inListElements = ref<HDASummary[]>([]);
 
-// variables for datatype mapping and then filtering
-const datatypesMapperStore = useDatatypesMapperStore();
-const datatypesMapper = computed(() => datatypesMapperStore.datatypesMapper);
-
-/** Are we filtering by datatype? */
-const filterExtensions = computed(() => !!datatypesMapper.value && !!props.extensions?.length);
+const {
+    removeExtensions,
+    hideSourceItems,
+    onUpdateHideSourceItems,
+    isElementInvalid,
+    collectionName,
+    onUpdateCollectionName,
+    onCollectionCreate,
+    showButtonsForModal,
+} = useCollectionCreator(props, emit);
 
 // ----------------------------------------------------------------------- process raw list
 /** set up main data */
@@ -95,12 +105,22 @@ function _elementsSetUp() {
     // reverse the order of the elements to emulate what we have in the history panel
     workingElements.value.reverse();
 
+    if (removeExtensions.value) {
+        workingElements.value.forEach((el) => {
+            if (el.name) {
+                el.name = stripExtension(el.name);
+            }
+        });
+    } else {
+        //
+    }
+
     // for inListElements, reset their values (in order) to datasets from workingElements
     const inListElementsPrev = inListElements.value;
     inListElements.value = [];
     inListElementsPrev.forEach((prevElem) => {
         const element = workingElements.value.find((e) => e.id === prevElem.id);
-        const problem = _isElementInvalid(prevElem);
+        const problem = isElementInvalid(prevElem);
 
         if (element) {
             inListElements.value.push(element);
@@ -134,7 +154,7 @@ function _elementsSetUp() {
 // /** separate working list into valid and invalid elements for this collection */
 function _validateElements() {
     workingElements.value = workingElements.value.filter((element) => {
-        var problem = _isElementInvalid(element);
+        var problem = isElementInvalid(element);
 
         if (problem) {
             invalidElements.value.push(element.name + "  " + problem);
@@ -146,31 +166,13 @@ function _validateElements() {
     return workingElements.value;
 }
 
-/** describe what is wrong with a particular element if anything */
-function _isElementInvalid(element: HistoryItemSummary): string | null {
-    if (element.history_content_type === "dataset_collection") {
-        return localize("is a collection, this is not allowed");
-    }
-
-    var validState = element.state === STATES.OK || STATES.NOT_READY_STATES.includes(element.state as string);
-
-    if (!validState) {
-        return localize("has errored, is paused, or is not accessible");
-    }
-
-    if (element.deleted || element.purged) {
-        return localize("has been deleted or purged");
-    }
-
-    // is the element's extension not a subtype of any of the required extensions?
-    if (
-        filterExtensions.value &&
-        element.extension &&
-        !datatypesMapper.value?.isSubTypeOfAny(element.extension, props.extensions!)
-    ) {
-        return localize(`has an invalid extension: ${element.extension}`);
-    }
-    return null;
+function removeExtensionsToggle() {
+    removeExtensions.value = !removeExtensions.value;
+    const removeExtensionsValue = removeExtensions.value;
+    workingElements.value.forEach((el) => {
+        updateIdentifierIfUnchanged(el, removeExtensionsValue);
+    });
+    _mangleDuplicateNames();
 }
 
 // /** mangle duplicate names using a mac-like '(counter)' addition to any duplicates */
@@ -231,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;
@@ -247,10 +249,18 @@ async function clickedCreate(collectionName: string) {
     }
 
     if (state.value !== "error" && (atLeastOneElement.value || confirmed)) {
-        emit("clicked-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 } = {};
@@ -291,10 +301,6 @@ function compareNames(a: HDASummary, b: HDASummary) {
     return 0;
 }
 
-function onUpdateHideSourceItems(newHideSourceItems: boolean) {
-    hideSourceItems.value = newHideSourceItems;
-}
-
 watch(
     () => props.initialElements,
     () => {
@@ -304,21 +310,11 @@ watch(
     { immediate: true }
 );
 
-watch(
-    () => datatypesMapper.value,
-    async (mapper) => {
-        if (props.extensions?.length && !mapper) {
-            await datatypesMapperStore.createMapper();
-        }
-    },
-    { immediate: true }
-);
-
 function addUploadedFiles(files: HDASummary[]) {
     const returnedElements = props.fromSelection ? workingElements : inListElements;
     files.forEach((f) => {
         const file = props.fromSelection ? f : workingElements.value.find((e) => e.id === f.id);
-        const problem = _isElementInvalid(f);
+        const problem = isElementInvalid(f);
         if (file && !returnedElements.value.find((e) => e.id === file.id)) {
             returnedElements.value.push(file);
         } else if (problem) {
@@ -344,24 +340,6 @@ function renameElement(element: any, name: string) {
         element.name = name;
     }
 }
-
-//TODO: issue #9497
-// const removeExtensions = ref(true);
-// removeExtensionsToggle: function () {
-//     this.removeExtensions = !this.removeExtensions;
-//     if (this.removeExtensions == true) {
-//         this.removeExtensionsFn();
-//     }
-// },
-// removeExtensionsFn: function () {
-//     workingElements.value.forEach((e) => {
-//         var lastDotIndex = e.lastIndexOf(".");
-//         if (lastDotIndex > 0) {
-//             var extension = e.slice(lastDotIndex, e.length);
-//             e = e.replace(extension, "");
-//         }
-//     });
-// },
 </script>
 
 <template>
@@ -411,14 +389,21 @@ function renameElement(element: any, name: string) {
                 :oncancel="() => emit('on-cancel')"
                 :history-id="props.historyId"
                 :hide-source-items="hideSourceItems"
+                render-extensions-toggle
+                :extensions-toggle="removeExtensions"
                 :extensions="extensions"
                 collection-type="list"
                 :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"
                 @on-update-datatype-toggle="changeDatatypeFilter"
                 @onUpdateHideSourceItems="onUpdateHideSourceItems"
-                @clicked-create="clickedCreate">
+                @remove-extensions-toggle="removeExtensionsToggle"
+                @clicked-create="attemptCreate">
                 <template v-slot:help-content>
                     <p>
                         {{
@@ -437,8 +422,8 @@ function renameElement(element: any, name: string) {
 
                     <ul>
                         <li v-if="!fromSelection">
-                            Move datsets from the "Unselected" column to the "Selected" column below to compose the list
-                            in the intended order and with the intended datasets.
+                            Move datasets from the "Unselected" column to the "Selected" column below to compose the
+                            list in the intended order and with the intended datasets.
                         </li>
                         <li v-if="!fromSelection">
                             The filter textbox can be used to rapidly find the datasets of interest by name.
diff --git a/client/src/components/Collections/ListDatasetCollectionElementView.vue b/client/src/components/Collections/ListDatasetCollectionElementView.vue
index 537b3e40f6cb..47dc9327f7f4 100644
--- a/client/src/components/Collections/ListDatasetCollectionElementView.vue
+++ b/client/src/components/Collections/ListDatasetCollectionElementView.vue
@@ -32,6 +32,13 @@ watch(elementName, () => {
 function clickDiscard() {
     emit("element-is-discarded", props.element);
 }
+
+watch(
+    () => props.element.name,
+    () => {
+        elementName.value = props.element.name || "...";
+    }
+);
 </script>
 
 <template>
diff --git a/client/src/components/Collections/ListWizard.vue b/client/src/components/Collections/ListWizard.vue
new file mode 100644
index 000000000000..2f493c06ee22
--- /dev/null
+++ b/client/src/components/Collections/ListWizard.vue
@@ -0,0 +1,277 @@
+<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 {
+    attemptCreate,
+    type CollectionCreatorComponent,
+    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 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";
+const collectionCreator = ref<CollectionCreatorComponent>();
+const { selectedItems } = storeToRefs(store);
+
+const countPaired = ref(-1);
+const countUnpaired = ref(-1);
+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) {
+        whichBuilder.value = "list:paired";
+        inferredBuilder.value = "list:paired";
+    } else {
+        whichBuilder.value = "list";
+        inferredBuilder.value = "list";
+    }
+
+    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");
+    }
+}
+
+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({
+    "which-builder": {
+        label: "What are you building?",
+        instructions: computed(() => {
+            return `Choose a list builder to match your selected data and the kind of list you'd like to build.`;
+        }),
+        isValid: () => true,
+        isSkippable: () => false,
+    },
+    "auto-pairing": {
+        label: "Auto Pairing",
+        instructions: computed(() => {
+            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(s).";
+        }),
+        isValid: () => ruleState.value,
+        isSkippable: () => whichBuilder.value !== "rules",
+    },
+});
+
+const collectionTypeForPairedOrUnpairedBuilder = computed(
+    () => whichBuilder.value as SupportedPairedOrPairedBuilderCollectionTypes
+);
+
+const buildButtonLabel = computed(() => {
+    return "Build";
+});
+
+const pairedListType = computed(() => {
+    return whichBuilder.value == "list:paired_or_unpaired" ? "list:paired_or_unpaired" : "list:paired";
+});
+
+async function submit() {
+    if (collectionCreator.value) {
+        attemptCreate(collectionCreator);
+    }
+}
+
+async function onCreate(payload: CreateNewCollectionPayload) {
+    try {
+        await createHistoryDatasetCollectionInstanceFull(payload);
+        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 onFilters(forwardFilter: string, reverseFilter: string) {
+    currentForwardFilter.value = forwardFilter;
+    currentReverseFilter.value = reverseFilter;
+}
+
+function goToAutoPairing() {
+    wizard.goTo("auto-pairing");
+}
+
+const ruleState = ref(false);
+
+function onRuleState(newRuleState: boolean) {
+    ruleState.value = newRuleState;
+}
+</script>
+
+<template>
+    <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 :initial-advanced="initialAdvanced" :value="whichBuilder" @onChange="setWhichBuilder" />
+            </div>
+            <div v-else-if="wizard.isCurrent('list-builder')" class="collection-creator-bounded-help">
+                <ListCollectionCreator
+                    ref="collectionCreator"
+                    :history-id="currentHistoryId"
+                    :initial-elements="selectedItems || []"
+                    :default-hide-source-items="true"
+                    :from-selection="true"
+                    :show-upload="false"
+                    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')">
+                <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"
+                    @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"
+                    @onAttemptCreate="ruleOnAttemptCreate"
+                    @validInput="onRuleState" />
+            </div>
+        </GenericWizard>
+    </div>
+</template>
diff --git a/client/src/components/Collections/ListWizard/WhichBuilder.vue b/client/src/components/Collections/ListWizard/WhichBuilder.vue
new file mode 100644
index 000000000000..733140ae577a
--- /dev/null
+++ b/client/src/components/Collections/ListWizard/WhichBuilder.vue
@@ -0,0 +1,116 @@
+<script setup lang="ts">
+import { BButton, BCard, BCardGroup, BCardTitle } from "bootstrap-vue";
+import { ref } from "vue";
+
+import { borderVariant } from "@/components/Common/Wizard/utils";
+
+import { type WhichListBuilder } from "./types";
+
+interface Props {
+    value: WhichListBuilder;
+    initialAdvanced: boolean;
+}
+
+const emit = defineEmits(["onChange"]);
+
+const props = defineProps<Props>();
+
+const advanced = ref(props.initialAdvanced);
+
+function toggleAdvanced() {
+    advanced.value = !advanced.value;
+}
+</script>
+
+<template>
+    <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>
+            <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
new file mode 100644
index 000000000000..429f92f6c40a
--- /dev/null
+++ b/client/src/components/Collections/ListWizard/types.ts
@@ -0,0 +1,7 @@
+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 c00c2c0f9b1e..8933d0340552 100644
--- a/client/src/components/Collections/PairCollectionCreator.vue
+++ b/client/src/components/Collections/PairCollectionCreator.vue
@@ -5,12 +5,12 @@ 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 STATES from "@/mvc/dataset/states";
-import { useDatatypesMapperStore } from "@/stores/datatypesMapperStore";
 import localize from "@/utils/localization";
 
-import type { DatasetPair } from "../History/adapters/buildCollectionModal";
+import { type Mode, useCollectionCreator } from "./common/useCollectionCreator";
+import { guessNameForPair } from "./pairing";
 
 import DatasetCollectionElementView from "./ListDatasetCollectionElementView.vue";
 import CollectionCreator from "@/components/Collections/common/CollectionCreator.vue";
@@ -28,17 +28,17 @@ interface Props {
     defaultHideSourceItems?: boolean;
     fromSelection?: boolean;
     extensions?: string[];
+    mode: Mode;
 }
 
 const props = defineProps<Props>();
 
 const emit = defineEmits<{
-    (event: "clicked-create", selectedPair: DatasetPair, collectionName: string, hideSourceItems: boolean): void;
+    (event: "on-create", options: CreateNewCollectionPayload): void;
     (event: "on-cancel"): void;
 }>();
 
 const state = ref("build");
-const removeExtensions = ref(true);
 const initialSuggestedName = ref("");
 const invalidElements = ref<string[]>([]);
 const workingElements = ref<HDASummary[]>([]);
@@ -55,7 +55,6 @@ const noElementsSelected = computed(() => {
 const exactlyTwoValidElements = computed(() => {
     return pairElements.value.forward && pairElements.value.reverse;
 });
-const hideSourceItems = ref(props.defaultHideSourceItems || false);
 const pairElements = computed<SelectedDatasetPair>(() => {
     if (props.fromSelection) {
         return {
@@ -67,12 +66,15 @@ const pairElements = computed<SelectedDatasetPair>(() => {
     }
 });
 
-// variables for datatype mapping and then filtering
-const datatypesMapperStore = useDatatypesMapperStore();
-const datatypesMapper = computed(() => datatypesMapperStore.datatypesMapper);
-
-/** Are we filtering by datatype? */
-const filterExtensions = computed(() => !!datatypesMapper.value && !!props.extensions?.length);
+const {
+    removeExtensions,
+    hideSourceItems,
+    onUpdateHideSourceItems,
+    isElementInvalid,
+    onCollectionCreate,
+    showButtonsForModal,
+    onUpdateCollectionName,
+} = useCollectionCreator(props);
 
 watch(
     () => props.initialElements,
@@ -118,7 +120,7 @@ function _elementsSetUp() {
         const element = workingElements.value.find(
             (e) => e.id === inListElementsPrev[key as keyof SelectedDatasetPair]?.id
         );
-        const problem = _isElementInvalid(prevElem);
+        const problem = isElementInvalid(prevElem);
         if (element) {
             inListElements.value[key as keyof SelectedDatasetPair] = element;
         } else if (problem) {
@@ -153,7 +155,7 @@ function _ensureElementIds() {
 // /** separate working list into valid and invalid elements for this collection */
 function _validateElements() {
     workingElements.value = workingElements.value.filter((element) => {
-        var problem = _isElementInvalid(element);
+        var problem = isElementInvalid(element);
 
         if (problem) {
             invalidElements.value.push(element.name + "  " + problem);
@@ -165,33 +167,6 @@ function _validateElements() {
     return workingElements.value;
 }
 
-/** describe what is wrong with a particular element if anything */
-function _isElementInvalid(element: HistoryItemSummary) {
-    if (element.history_content_type === "dataset_collection") {
-        return localize("is a collection, this is not allowed");
-    }
-
-    var validState = element.state === STATES.OK || STATES.NOT_READY_STATES.includes(element.state as string);
-
-    if (!validState) {
-        return localize("has errored, is paused, or is not accessible");
-    }
-
-    if (element.deleted || element.purged) {
-        return localize("has been deleted or purged");
-    }
-
-    // is the element's extension not a subtype of any of the required extensions?
-    if (
-        filterExtensions.value &&
-        element.extension &&
-        !datatypesMapper.value?.isSubTypeOfAny(element.extension, props.extensions!)
-    ) {
-        return localize(`has an invalid extension: ${element.extension}`);
-    }
-    return null;
-}
-
 function getPairElement(key: string) {
     return pairElements.value[key as "forward" | "reverse"];
 }
@@ -232,7 +207,7 @@ function addUploadedFiles(files: HDASummary[]) {
 
     // Check for validity of uploads
     files.forEach((file) => {
-        const problem = _isElementInvalid(file);
+        const problem = isElementInvalid(file);
         if (problem) {
             const invalidMsg = `${file.hid}: ${file.name} ${problem} and ${NOT_VALID_ELEMENT_MSG}`;
             invalidElements.value.push(invalidMsg);
@@ -241,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("clicked-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);
     }
 }
 
@@ -264,76 +240,7 @@ function removeExtensionsToggle() {
 
 function _guessNameForPair(fwd: HDASummary, rev: HDASummary, removeExtensions: boolean) {
     removeExtensions = removeExtensions ? removeExtensions : removeExtensions;
-
-    var fwdName = fwd.name ?? "";
-    var revName = rev.name ?? "";
-    var lcs = _naiveStartingAndEndingLCS(fwdName, revName);
-
-    /** remove url prefix if files were uploaded by url */
-    var lastDotIndex = lcs.lastIndexOf(".");
-    var lastSlashIndex = lcs.lastIndexOf("/");
-    var extension = lcs.slice(lastDotIndex, lcs.length);
-
-    if (lastSlashIndex > 0) {
-        var urlprefix = lcs.slice(0, lastSlashIndex + 1);
-
-        lcs = lcs.replace(urlprefix, "");
-        fwdName = fwdName.replace(extension, "");
-        revName = revName.replace(extension, "");
-    }
-
-    if (removeExtensions) {
-        if (lastDotIndex > 0) {
-            lcs = lcs.replace(extension, "");
-            fwdName = fwdName.replace(extension, "");
-            revName = revName.replace(extension, "");
-        }
-    }
-
-    return lcs || `${fwdName} & ${revName}`;
-}
-
-function onUpdateHideSourceItems(newHideSourceItems: boolean) {
-    hideSourceItems.value = newHideSourceItems;
-}
-
-function _naiveStartingAndEndingLCS(s1: string, s2: string) {
-    var i = 0;
-    var j = 0;
-    var fwdLCS = "";
-    var revLCS = "";
-
-    while (i < s1.length && i < s2.length) {
-        if (s1[i] !== s2[i]) {
-            break;
-        }
-
-        fwdLCS += s1[i];
-        i += 1;
-    }
-
-    if (i === s1.length) {
-        return s1;
-    }
-
-    if (i === s2.length) {
-        return s2;
-    }
-
-    i = s1.length - 1;
-    j = s2.length - 1;
-
-    while (i >= 0 && j >= 0) {
-        if (s1[i] !== s2[j]) {
-            break;
-        }
-
-        revLCS = [s1[i], revLCS].join("");
-        i -= 1;
-        j -= 1;
-    }
-
-    return fwdLCS + revLCS;
+    return guessNameForPair(fwd, rev, "", "", removeExtensions);
 }
 </script>
 
@@ -377,9 +284,11 @@ function _naiveStartingAndEndingLCS(s1: string, s2: string) {
                 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/PairedListCollectionCreator.vue b/client/src/components/Collections/PairedListCollectionCreator.vue
index 1f831e66a79c..7974dd0ffe20 100644
--- a/client/src/components/Collections/PairedListCollectionCreator.vue
+++ b/client/src/components/Collections/PairedListCollectionCreator.vue
@@ -16,12 +16,24 @@ import type { HDASummary, HistoryItemSummary } from "@/api";
 import { useConfirmDialog } from "@/composables/confirmDialog";
 import { Toast } from "@/composables/toast";
 import STATES from "@/mvc/dataset/states";
-import { useDatatypesMapperStore } from "@/stores/datatypesMapperStore";
-// import levenshteinDistance from '@/utils/levenshtein';
 import localize from "@/utils/localization";
 import { naturalSort } from "@/utils/naturalSort";
 
 import type { DatasetPair } from "../History/adapters/buildCollectionModal";
+import { useExtensionFiltering } from "./common/useExtensionFilter";
+import {
+    COMMON_FILTERS,
+    type CommonFiltersType,
+    createPair,
+    DEFAULT_FILTER,
+    guessInitialFilterType,
+    guessNameForPair,
+    type MatchingFunction,
+    matchOnlyIfExact,
+    matchOnPercentOfStartingAndEndingLCS,
+    splitElementsByFilter,
+    statelessAutoPairFnBuilder,
+} from "./pairing";
 
 import Heading from "../Common/Heading.vue";
 import PairedElementView from "./PairedElementView.vue";
@@ -29,12 +41,6 @@ import UnpairedDatasetElementView from "./UnpairedDatasetElementView.vue";
 import CollectionCreator from "@/components/Collections/common/CollectionCreator.vue";
 
 const NOT_VALID_ELEMENT_MSG: string = localize("is not a valid element for this collection");
-const COMMON_FILTERS = {
-    illumina: ["_1", "_2"],
-    Rs: ["_R1", "_R2"],
-    dot12s: [".1.fastq", ".2.fastq"],
-};
-const DEFAULT_FILTER: keyof typeof COMMON_FILTERS = "illumina";
 const MATCH_PERCENTAGE = 0.99;
 
 // Titles and help text
@@ -57,7 +63,7 @@ interface Props {
 const props = defineProps<Props>();
 
 const emit = defineEmits<{
-    (e: "clicked-create", workingElements: DatasetPair[], collectionName: string, hideSourceItems: boolean): void;
+    (e: "on-create", workingElements: DatasetPair[], collectionName: string, hideSourceItems: boolean): void;
     (e: "on-cancel"): void;
 }>();
 
@@ -183,12 +189,7 @@ const noUnpairedElementsDisplayed = computed(() => {
     return numOfUnpairedForwardElements.value + numOfUnpairedReverseElements.value === 0;
 });
 
-// variables for datatype mapping and then filtering
-const datatypesMapperStore = useDatatypesMapperStore();
-const datatypesMapper = computed(() => datatypesMapperStore.datatypesMapper);
-
-/** Are we filtering by datatype? */
-const filterExtensions = computed(() => !!datatypesMapper.value && !!props.extensions?.length);
+const { hasInvalidExtension } = useExtensionFiltering(props);
 
 function removeExtensionsToggle() {
     removeExtensions.value = !removeExtensions.value;
@@ -234,45 +235,15 @@ function _elementsSetUp() {
 }
 
 function initialFiltersSet() {
-    let illumina = 0;
-    let dot12s = 0;
-    let Rs = 0;
-    //should we limit the forEach? What if there are 1000s of elements?
-    props.initialElements.forEach((element) => {
-        if (element.name?.includes(".1.fastq") || element.name?.includes(".2.fastq")) {
-            dot12s++;
-        } else if (element.name?.includes("_R1") || element.name?.includes("_R2")) {
-            Rs++;
-        } else if (element.name?.includes("_1") || element.name?.includes("_2")) {
-            illumina++;
-        }
-    });
-    // if we cannot filter don't set an initial filter and hide all the data
-    if (illumina == 0 && dot12s == 0 && Rs == 0) {
+    const filterType = guessInitialFilterType(props.initialElements);
+    if (filterType == null) {
         forwardFilter.value = "";
         reverseFilter.value = "";
-    } else if (illumina > dot12s && illumina > Rs) {
-        changeFilters("illumina");
-    } else if (dot12s > illumina && dot12s > Rs) {
-        changeFilters("dot12s");
-    } else if (Rs > illumina && Rs > dot12s) {
-        changeFilters("Rs");
     } else {
-        changeFilters("illumina");
+        changeFilters(filterType);
     }
 }
 
-// TODO: Don't know if this is really necessary
-// function _ensureElementIds() {
-//     workingElements.value.forEach((element) => {
-//         if (!Object.prototype.hasOwnProperty.call(element, "id")) {
-//             console.warn("Element missing id", element);
-//         }
-//     });
-
-//     return workingElements.value;
-// }
-
 function _validateElements() {
     workingElements.value = workingElements.value.filter((element) => {
         var problem = _isElementInvalid(element);
@@ -299,11 +270,7 @@ function _isElementInvalid(element: HistoryItemSummary) {
     }
 
     // is the element's extension not a subtype of any of the required extensions?
-    if (
-        filterExtensions.value &&
-        element.extension &&
-        !datatypesMapper.value?.isSubTypeOfAny(element.extension, props.extensions!)
-    ) {
+    if (hasInvalidExtension(element)) {
         return localize(`has an invalid extension: ${element.extension}`);
     }
     return null;
@@ -378,45 +345,13 @@ function removePairFromUnpaired(fwd: HDASummary, rev: HDASummary) {
  * (will guess if not given)
  */
 function _createPair(fwd: HDASummary, rev: HDASummary, name?: string) {
-    // ensure existance and don't pair something with itself
-    if (!(fwd && rev) || fwd === rev) {
-        throw new Error(`Bad pairing: ${[JSON.stringify(fwd), JSON.stringify(rev)]}`);
-    }
     name = name || _guessNameForPair(fwd, rev);
-    return { forward: fwd, name: name, reverse: rev };
+    return createPair(fwd, rev, name);
 }
 
-/** Try to find a good pair name for the given fwd and rev datasets */
 function _guessNameForPair(fwd: HDASummary, rev: HDASummary, willRemoveExtensions?: boolean) {
     willRemoveExtensions = willRemoveExtensions ? willRemoveExtensions : removeExtensions.value;
-    let fwdName = fwd.name;
-    let revName = rev.name;
-    const fwdNameFilter = fwdName?.replace(new RegExp(forwardFilter.value || ""), "");
-    const revNameFilter = revName?.replace(new RegExp(reverseFilter.value || ""), "");
-    if (!fwdNameFilter || !revNameFilter || !fwdName || !revName) {
-        return `${fwdName} & ${revName}`;
-    }
-    let lcs = _naiveStartingAndEndingLCS(fwdNameFilter, revNameFilter);
-    // remove url prefix if files were uploaded by url
-    const lastSlashIndex = lcs.lastIndexOf("/");
-    if (lastSlashIndex > 0) {
-        const urlprefix = lcs.slice(0, lastSlashIndex + 1);
-        lcs = lcs.replace(urlprefix, "");
-    }
-
-    if (willRemoveExtensions) {
-        const lastDotIndex = lcs.lastIndexOf(".");
-        if (lastDotIndex > 0) {
-            const extension = lcs.slice(lastDotIndex, lcs.length);
-            lcs = lcs.replace(extension, "");
-            fwdName = fwdName.replace(extension, "");
-            revName = revName.replace(extension, "");
-        }
-    }
-    if (lcs.endsWith(".") || lcs.endsWith("_")) {
-        lcs = lcs.substring(0, lcs.length - 1);
-    }
-    return lcs || `${fwdName} & ${revName}`;
+    return guessNameForPair(fwd, rev, forwardFilter.value, reverseFilter.value, willRemoveExtensions);
 }
 
 function clickAutopair() {
@@ -440,16 +375,7 @@ function clickClearFilters() {
 }
 
 function splitByFilter() {
-    const filters = [new RegExp(forwardFilter.value), new RegExp(reverseFilter.value)];
-    const split: [HDASummary[], HDASummary[]] = [[], []];
-    workingElements.value.forEach((e) => {
-        filters.forEach((filter, i) => {
-            if (e.name && filter.test(e.name)) {
-                split[i]?.push(e);
-            }
-        });
-    });
-    return split;
+    return splitElementsByFilter(workingElements.value, forwardFilter.value, reverseFilter.value);
 }
 // ===========================================================================
 
@@ -457,55 +383,15 @@ function splitByFilter() {
 /** Autopair by exact match */
 function autoPairSimple(params: { listA: HDASummary[]; listB: HDASummary[] }) {
     return autoPairFnBuilder({
-        match: (params) => {
-            params = params || {};
-            if (params.matchTo === params.possible) {
-                return {
-                    index: params.index,
-                    score: 1.0,
-                };
-            }
-            return params.bestMatch;
-        },
+        match: matchOnlyIfExact, // will only issue 1.0 scores if exact
         scoreThreshold: 0.6,
     })(params);
 }
 
-// TODO: Currently unused?
-/** Autopair by levenstein distance */
-// function autoPairLevenshtein(params: { listA: HDASummary[]; listB: HDASummary[] }) {
-//     return autoPairFnBuilder({
-//         match: (params) => {
-//             params = params || {};
-//             const distance = levenshteinDistance(params.matchTo, params.possible);
-//             const score = 1.0 - distance / Math.max(params.matchTo.length, params.possible.length);
-//             if (score > params.bestMatch.score) {
-//                 return {
-//                     index: params.index,
-//                     score: score,
-//                 };
-//             }
-//             return params.bestMatch;
-//         },
-//         scoreThreshold: MATCH_PERCENTAGE,
-//     })(params);
-// }
-
 /** Autopair by longest common substrings scoring */
 function autoPairLCS(params: { listA: HDASummary[]; listB: HDASummary[] }) {
     return autoPairFnBuilder({
-        match: (params) => {
-            params = params || {};
-            const match = _naiveStartingAndEndingLCS(params.matchTo, params.possible).length;
-            const score = match / Math.max(params.matchTo.length, params.possible.length);
-            if (score > params.bestMatch.score) {
-                return {
-                    index: params.index,
-                    score: score,
-                };
-            }
-            return params.bestMatch;
-        },
+        match: matchOnPercentOfStartingAndEndingLCS,
         scoreThreshold: MATCH_PERCENTAGE,
     })(params);
 }
@@ -599,128 +485,25 @@ function unpairAll() {
 // ===========================================================================
 
 /** Returns an autopair function that uses the provided options.match function */
-function autoPairFnBuilder(options: {
-    match: (params: {
-        matchTo: string;
-        possible: string;
-        index: number;
-        bestMatch: { score: number; index: number };
-    }) => { score: number; index: number };
-    createPair?: (params: {
-        listA: HDASummary[];
-        indexA: number;
-        listB: HDASummary[];
-        indexB: number;
-    }) => DatasetPair | undefined;
-    preprocessMatch?: (params: {
-        matchTo: HDASummary;
-        possible: HDASummary;
-        index: number;
-        bestMatch: { score: number; index: number };
-    }) => { matchTo: string; possible: string; index: number; bestMatch: { score: number; index: number } };
-    scoreThreshold?: number;
-}) {
-    options = options || {};
-    options.createPair =
-        options.createPair ||
-        function _defaultCreatePair(params) {
-            params = params || {};
-            const a = params.listA.splice(params.indexA, 1)[0];
-            const b = params.listB.splice(params.indexB, 1)[0];
-            if (!a || !b) {
-                return undefined;
-            }
-            const aInBIndex = params.listB.indexOf(a);
-            const bInAIndex = params.listA.indexOf(b);
-            if (aInBIndex !== -1) {
-                params.listB.splice(aInBIndex, 1);
-            }
-            if (bInAIndex !== -1) {
-                params.listA.splice(bInAIndex, 1);
-            }
-            // return _pair(a, b, { silent: true });
-            return _pair(a, b);
-        };
-    // compile these here outside of the loop
-    let _regexps: RegExp[] = [];
-    function getRegExps() {
-        if (!_regexps.length) {
-            _regexps = [new RegExp(forwardFilter.value), new RegExp(reverseFilter.value)];
-        }
-        return _regexps;
-    }
-    // mangle params as needed
-    options.preprocessMatch =
-        options.preprocessMatch ||
-        function _defaultPreprocessMatch(params) {
-            const regexps = getRegExps();
-            return Object.assign(params, {
-                matchTo: params.matchTo.name?.replace(regexps[0] || "", ""),
-                possible: params.possible.name?.replace(regexps[1] || "", ""),
-                index: params.index,
-                bestMatch: params.bestMatch,
-            });
-        };
-
+function autoPairFnBuilder(options: { match: MatchingFunction; scoreThreshold?: number }) {
     return function _strategy(params: { listA: HDASummary[]; listB: HDASummary[] }) {
-        params = params || {};
-        const listA = params.listA;
-        const listB = params.listB;
-        let indexA = 0;
-        let indexB;
-
-        let bestMatch = {
-            score: 0.0,
-            index: -1,
-        };
-
-        const paired = [];
-        while (indexA < listA.length) {
-            const matchTo = listA[indexA];
-            bestMatch.score = 0.0;
-
-            if (!matchTo) {
-                continue;
-            }
-            for (indexB = 0; indexB < listB.length; indexB++) {
-                const possible = listB[indexB] as HDASummary;
-                if (listA[indexA] !== listB[indexB]) {
-                    bestMatch = options.match(
-                        options.preprocessMatch!({
-                            matchTo: matchTo,
-                            possible: possible,
-                            index: indexB,
-                            bestMatch: bestMatch,
-                        })
-                    );
-                    if (bestMatch.score === 1.0) {
-                        break;
-                    }
-                }
-            }
-            const scoreThreshold = options.scoreThreshold ? options.scoreThreshold : MATCH_PERCENTAGE;
-            if (bestMatch.score >= scoreThreshold) {
-                const createdPair = options.createPair!({
-                    listA: listA,
-                    indexA: indexA,
-                    listB: listB,
-                    indexB: bestMatch.index,
-                });
-                if (createdPair) {
-                    paired.push(createdPair);
-                }
-            } else {
-                indexA += 1;
-            }
-            if (!listA.length || !listB.length) {
-                return paired;
-            }
-        }
+        const scoreThreshold = options.scoreThreshold ? options.scoreThreshold : MATCH_PERCENTAGE;
+        const pairs = statelessAutoPairFnBuilder<HDASummary>(
+            options.match,
+            scoreThreshold,
+            forwardFilter.value,
+            reverseFilter.value,
+            removeExtensions.value
+        )(params);
+        const paired: DatasetPair[] = [];
+        pairs.forEach((pair: { forward: HDASummary; reverse: HDASummary; name: string }) => {
+            paired.push(_pair(pair.forward, pair.reverse, { name: pair.name }));
+        });
         return paired;
     };
 }
 
-function changeFilters(filter: keyof typeof COMMON_FILTERS) {
+function changeFilters(filter: CommonFiltersType) {
     forwardFilter.value = COMMON_FILTERS[filter][0] as string;
     reverseFilter.value = COMMON_FILTERS[filter][1] as string;
 }
@@ -756,7 +539,7 @@ async function clickedCreate(collectionName: string) {
     }
 
     if (state.value == "build" && (atLeastOnePair.value || confirmed)) {
-        emit("clicked-create", generatedPairs.value, collectionName, hideSourceItems.value);
+        emit("on-create", generatedPairs.value, collectionName, hideSourceItems.value);
     }
 }
 
@@ -773,44 +556,6 @@ function checkForDuplicates() {
     });
     state.value = valid ? "build" : "duplicates";
 }
-
-// TODO: Where is this being used?
-// function stripExtension(name: string) {
-//     return name.includes(".") ? name.substring(0, name.lastIndexOf(".")) : name;
-// }
-
-/** Return the concat'd longest common prefix and suffix from two strings */
-function _naiveStartingAndEndingLCS(s1: string, s2: string) {
-    var fwdLCS = "";
-    var revLCS = "";
-    var i = 0;
-    var j = 0;
-    while (i < s1.length && i < s2.length) {
-        if (s1[i] !== s2[i]) {
-            break;
-        }
-        fwdLCS += s1[i];
-        i += 1;
-    }
-    if (i === s1.length) {
-        return s1;
-    }
-    if (i === s2.length) {
-        return s2;
-    }
-
-    i = s1.length - 1;
-    j = s2.length - 1;
-    while (i >= 0 && j >= 0) {
-        if (s1[i] !== s2[j]) {
-            break;
-        }
-        revLCS = [s1[i], revLCS].join("");
-        i -= 1;
-        j -= 1;
-    }
-    return fwdLCS + revLCS;
-}
 </script>
 
 <template>
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/RuleBasedCollectionCreatorModal.js b/client/src/components/Collections/RuleBasedCollectionCreatorModal.js
index 353f3e312c7c..ab88bbea5dcf 100644
--- a/client/src/components/Collections/RuleBasedCollectionCreatorModal.js
+++ b/client/src/components/Collections/RuleBasedCollectionCreatorModal.js
@@ -1,6 +1,8 @@
 import _l from "utils/localization";
 import Vue from "vue";
 
+import { rawToTable } from "@/components/Collections/tables";
+
 import { collectionCreatorModalSetup } from "./common/modal";
 
 function ruleBasedCollectionCreatorModal(elements, elementsType, importType, options) {
@@ -58,22 +60,7 @@ function createCollectionViaRules(selection, defaultHideSourceItems = true) {
         importType = selection.dataType || "collections";
         elements = selection.elements;
     } else {
-        const hasNonWhitespaceChars = RegExp(/[^\s]/);
-        // Have pasted data, data from a history dataset, or FTP list.
-        const lines = selection.content
-            .split(/[\n\r]/)
-            .filter((line) => line.length > 0 && hasNonWhitespaceChars.exec(line));
-        // Really poor tabular parser - we should get a library for this or expose options? I'm not
-        // sure.
-        let hasTabs = false;
-        if (lines.length > 0) {
-            const firstLine = lines[0];
-            if (firstLine.indexOf("\t") >= 0) {
-                hasTabs = true;
-            }
-        }
-        const regex = hasTabs ? /\t/ : /\s+/;
-        elements = lines.map((line) => line.split(regex));
+        elements = rawToTable(selection.content);
         elementsType = selection.selectionType;
         importType = selection.dataType || "collections";
     }
diff --git a/client/src/components/Collections/RulesStandalone.vue b/client/src/components/Collections/RulesStandalone.vue
new file mode 100644
index 000000000000..fa06e7a4f158
--- /dev/null
+++ b/client/src/components/Collections/RulesStandalone.vue
@@ -0,0 +1,35 @@
+<script setup lang="ts">
+import { BAlert, BContainer, BRow } from "bootstrap-vue";
+import { ref } from "vue";
+
+import { useConfig } from "@/composables/config";
+
+import BuildFileSetWizard from "./BuildFileSetWizard.vue";
+import LoadingSpan from "@/components/LoadingSpan.vue";
+
+const { config, isConfigLoaded } = useConfig();
+
+const created = ref(false);
+
+function onCreated() {
+    created.value = true;
+}
+</script>
+
+<template>
+    <BContainer>
+        <LoadingSpan v-if="!isConfigLoaded" />
+        <BRow v-else-if="created">
+            <BAlert show variant="success" style="width: 100%">
+                Data imported and should be available in your history.
+            </BAlert>
+        </BRow>
+        <div v-else>
+            <BuildFileSetWizard
+                mode="standalone"
+                :file-sources-configured="config.file_sources_configured"
+                :ftp-upload-site="config.ftp_upload_site"
+                @created="onCreated" />
+        </div>
+    </BContainer>
+</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 6947a1d592fb..24b0249db950 100644
--- a/client/src/components/Collections/common/CollectionCreator.vue
+++ b/client/src/components/Collections/common/CollectionCreator.vue
@@ -6,8 +6,7 @@ import { storeToRefs } from "pinia";
 import { computed, ref, watch } from "vue";
 
 import type { HDASummary } from "@/api";
-import type { CompositeFileInfo } from "@/api/datatypes";
-import { AUTO_EXTENSION, getUploadDatatypes } from "@/components/Upload/utils";
+import { useUploadDatatypes } from "@/components/Upload/useUploadDatatypes";
 import { useConfig } from "@/composables/config";
 import { useUserStore } from "@/stores/userStore";
 import localize from "@/utils/localization";
@@ -27,19 +26,11 @@ const Tabs = {
     upload: 1,
 };
 
-type ExtensionDetails = {
-    id: string;
-    text: string;
-    description: string | null;
-    description_url: string | null;
-    composite_files?: CompositeFileInfo[] | null;
-    upload_warning?: string | null;
-};
-
 interface Props {
     oncancel: () => void;
     historyId: string;
     hideSourceItems: boolean;
+    name?: string;
     suggestedName?: string;
     renderExtensionsToggle?: boolean;
     extensions?: string[];
@@ -47,6 +38,9 @@ interface Props {
     noItems?: boolean;
     collectionType?: string;
     showUpload: boolean;
+    showButtons?: boolean;
+    collectionName: string;
+    mode: "wizard" | "modal";
 }
 
 const props = withDefaults(defineProps<Props>(), {
@@ -54,9 +48,12 @@ const props = withDefaults(defineProps<Props>(), {
     extensions: undefined,
     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;
@@ -65,13 +62,13 @@ const emit = defineEmits<{
 }>();
 
 const currentTab = ref(Tabs.create);
-const collectionName = ref(props.suggestedName);
 const localHideSourceItems = ref(props.hideSourceItems);
-const listExtensions = ref<ExtensionDetails[]>([]);
-const extensionsSet = ref(false);
+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
@@ -137,19 +134,26 @@ function removeExtensionsToggle() {
     emit("remove-extensions-toggle");
 }
 
-async function loadExtensions() {
-    listExtensions.value = await getUploadDatatypes(false, AUTO_EXTENSION);
-    extensionsSet.value = true;
-}
-
 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>
@@ -159,7 +163,7 @@ watch(
                 <CollectionCreatorNoItemsMessage @click-upload="currentTab = Tabs.upload" />
             </div>
             <div v-else>
-                <CollectionCreatorHelpHeader>
+                <CollectionCreatorHelpHeader :mode="mode">
                     <slot name="help-content"></slot>
                 </CollectionCreatorHelpHeader>
 
@@ -178,12 +182,14 @@ 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>
 
                     <CollectionCreatorFooterButtons
+                        v-if="showButtons"
                         :short-what-is-being-created="shortWhatIsBeingCreated"
                         :valid-input="validInput"
                         @clicked-cancel="cancelCreate"
@@ -197,7 +203,7 @@ watch(
                     <CollectionCreatorNoItemsMessage @click-upload="currentTab = Tabs.upload" />
                 </div>
                 <div v-else>
-                    <CollectionCreatorHelpHeader>
+                    <CollectionCreatorHelpHeader :mode="mode">
                         <slot name="help-content"></slot>
                     </CollectionCreatorHelpHeader>
 
@@ -215,12 +221,14 @@ 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>
 
                         <CollectionCreatorFooterButtons
+                            v-if="showButtons"
                             :short-what-is-being-created="shortWhatIsBeingCreated"
                             :valid-input="validInput"
                             @clicked-cancel="cancelCreate"
@@ -274,6 +282,17 @@ $fa-font-path: "../../../../node_modules/@fortawesome/fontawesome-free/webfonts/
 @import "~@fortawesome/fontawesome-free/scss/solid";
 @import "~@fortawesome/fontawesome-free/scss/fontawesome";
 @import "~@fortawesome/fontawesome-free/scss/brands";
+
+// Outside the modal - we need to set a max width on the help so ellipses display
+// doesn't cause it to grow without bound. Would greater appreciate a better workaround.
+.collection-creator-bounded-help {
+    .header {
+        .main-help {
+            max-width: 600px;
+        }
+    }
+}
+
 .collection-creator {
     height: 100%;
     overflow: hidden;
@@ -412,13 +431,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;
@@ -437,11 +460,13 @@ $fa-font-path: "../../../../node_modules/@fortawesome/fontawesome-free/webfonts/
                     list-style: circle;
                     margin-left: 16px;
                 }
+                /* This is not referenced anywhere I think.
                 .scss-help {
                     display: inline-block;
                     width: 100%;
                     text-align: right;
                 }
+                */
             }
             .more-help {
                 //display: inline-block;
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/mixin.js b/client/src/components/Collections/common/mixin.js
deleted file mode 100644
index e247100d05a1..000000000000
--- a/client/src/components/Collections/common/mixin.js
+++ /dev/null
@@ -1,73 +0,0 @@
-import CollectionCreator from "./CollectionCreator";
-
-export default {
-    components: {
-        CollectionCreator,
-    },
-    props: {
-        initialElements: {
-            required: true,
-            type: Array,
-        },
-        creationFn: {
-            type: Function,
-            required: true,
-        },
-        /** fn to call when the cancel button is clicked (scoped to this) - if falsy, no btn is displayed */
-        oncancel: {
-            type: Function,
-            required: true,
-        },
-        oncreate: {
-            type: Function,
-            required: true,
-        },
-        defaultHideSourceItems: {
-            type: Boolean,
-            required: false,
-            default: true,
-        },
-    },
-    data() {
-        return {
-            hideSourceItems: this.defaultHideSourceItems,
-        };
-    },
-    methods: {
-        onUpdateHideSourceItems(hideSourceItems) {
-            this.hideSourceItems = hideSourceItems;
-        },
-        /** return the concat'd longest common prefix and suffix from two strings */
-        _naiveStartingAndEndingLCS: function (s1, s2) {
-            var fwdLCS = "";
-            var revLCS = "";
-            var i = 0;
-            var j = 0;
-            while (i < s1.length && i < s2.length) {
-                if (s1[i] !== s2[i]) {
-                    break;
-                }
-                fwdLCS += s1[i];
-                i += 1;
-            }
-            if (i === s1.length) {
-                return s1;
-            }
-            if (i === s2.length) {
-                return s2;
-            }
-
-            i = s1.length - 1;
-            j = s2.length - 1;
-            while (i >= 0 && j >= 0) {
-                if (s1[i] !== s2[j]) {
-                    break;
-                }
-                revLCS = [s1[i], revLCS].join("");
-                i -= 1;
-                j -= 1;
-            }
-            return fwdLCS + revLCS;
-        },
-    },
-};
diff --git a/client/src/components/Collections/common/stripExtension.test.ts b/client/src/components/Collections/common/stripExtension.test.ts
new file mode 100644
index 000000000000..f9810be947e1
--- /dev/null
+++ b/client/src/components/Collections/common/stripExtension.test.ts
@@ -0,0 +1,38 @@
+import { stripExtension } from "./stripExtension";
+
+describe("stripExtension", () => {
+    test("strips single extensions", () => {
+        expect(stripExtension("sample.fastq")).toBe("sample");
+        expect(stripExtension("data.bam")).toBe("data");
+        expect(stripExtension("example.fasta")).toBe("example");
+        expect(stripExtension("sample.txt")).toBe("sample");
+    });
+
+    test("strips multi-part extensions with secondary extensions", () => {
+        expect(stripExtension("sample.fastq.gz")).toBe("sample");
+        expect(stripExtension("data.fasta.tgz")).toBe("data");
+        expect(stripExtension("example.bam.bz2")).toBe("example");
+    });
+
+    test("handles filenames with multiple dots", () => {
+        expect(stripExtension("my.sample.fastq.gz")).toBe("my.sample");
+        expect(stripExtension("test.data.vcf.gz")).toBe("test.data");
+        expect(stripExtension("dataset.v1.bam.bz2")).toBe("dataset.v1");
+    });
+
+    test("preserves filenames without dots", () => {
+        expect(stripExtension("no_extension")).toBe("no_extension");
+    });
+
+    test("tries to avoid significant metadata that might look like an extension", () => {
+        expect(stripExtension("mycondition1.mysample1234")).toBe("mycondition1.mysample1234");
+        expect(stripExtension("mycondition1.mysample1234.fastq")).toBe("mycondition1.mysample1234");
+        expect(stripExtension("mycondition1.mysample1234.fastq.gz")).toBe("mycondition1.mysample1234");
+    });
+
+    test("handles edge cases", () => {
+        expect(stripExtension(".fastq.gz")).toBe("");
+        expect(stripExtension("file..fastq.gz")).toBe("file.");
+        expect(stripExtension("file.fastq.extra.gz")).toBe("file.fastq");
+    });
+});
diff --git a/client/src/components/Collections/common/stripExtension.ts b/client/src/components/Collections/common/stripExtension.ts
new file mode 100644
index 000000000000..261b9c5280ee
--- /dev/null
+++ b/client/src/components/Collections/common/stripExtension.ts
@@ -0,0 +1,94 @@
+import { computed } from "vue";
+
+import type { HistoryItemSummary } from "@/api";
+
+export function stripExtension(filename_: string): string {
+    let filename = filename_;
+    let strippedSecondaryExtension = false;
+
+    const secondaryExtensions = [".gz", ".bz2", ".tgz", ".crai", ".bai"];
+    const hasSecondaryExtension = (name: string): string | null => {
+        for (const ext of secondaryExtensions) {
+            if (name.endsWith(ext)) {
+                return ext;
+            }
+        }
+        return null;
+    };
+
+    // Remove multi-part extensions
+    const secondaryExt = hasSecondaryExtension(filename);
+    if (secondaryExt) {
+        strippedSecondaryExtension = true;
+        // Strip secondary extension first
+        filename = filename.slice(0, -secondaryExt.length);
+    }
+
+    // Remove single extensions (anything after the last dot)
+    const lastDotIndex = filename.lastIndexOf(".");
+    const maxLengthOfExtension = strippedSecondaryExtension ? 7 : 10; // if we've already stripped some extension - be more conservative
+    if (lastDotIndex !== -1) {
+        const extensionLength = filename.length - lastDotIndex;
+        if (extensionLength < maxLengthOfExtension) {
+            filename = filename.slice(0, lastDotIndex);
+        }
+    }
+
+    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
new file mode 100644
index 000000000000..46bce28ff5bf
--- /dev/null
+++ b/client/src/components/Collections/common/useCollectionCreator.ts
@@ -0,0 +1,126 @@
+import { computed, type Ref, ref, unref, watch } from "vue";
+
+import { type HistoryItemSummary } from "@/api";
+import { type CollectionElementIdentifiers, type CreateNewCollectionPayload } from "@/api/datasetCollections";
+import type RuleCollectionBuilder from "@/components/RuleCollectionBuilder.vue";
+import STATES from "@/mvc/dataset/states";
+import localize from "@/utils/localization";
+
+import type ListCollectionCreator from "./ListCollectionCreator.vue";
+import type PairedOrUnpairedListCollectionCreator from "./PairedOrUnpairedListCollectionCreator.vue";
+import { useCollectionCreation } from "./useCollectionCreation";
+import { useExtensionFiltering } from "./useExtensionFilter";
+
+export type Mode = "modal" | "wizard";
+
+interface CommonCollectionBuilderProps {
+    extensions?: string[];
+    defaultHideSourceItems?: boolean;
+    mode: Mode;
+}
+
+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 type CollectionCreatorComponent =
+    | InstanceType<typeof ListCollectionCreator>
+    | InstanceType<typeof PairedOrUnpairedListCollectionCreator>
+    | InstanceType<typeof RuleCollectionBuilder>;
+
+export async function attemptCreate(creator: CollectionCreatorComponent | Ref<CollectionCreatorComponent | undefined>) {
+    const creatorValue: CollectionCreatorComponent | undefined = unref(creator);
+    // fight typing to workaround https://github.com/vuejs/core/issues/10077
+    interface HasAttemptCreate {
+        attemptCreate: () => Promise<void>;
+    }
+
+    if (creatorValue) {
+        (creatorValue as unknown as HasAttemptCreate).attemptCreate();
+    }
+}
+
+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;
+    }
+
+    /** describe what is wrong with a particular element if anything */
+    function isElementInvalid(element: HistoryItemSummary): string | null {
+        if (element.history_content_type === "dataset_collection") {
+            return localize("is a collection, this is not allowed");
+        }
+
+        const validState = element.state === STATES.OK || STATES.NOT_READY_STATES.includes(element.state as string);
+
+        if (!validState) {
+            return localize("has errored, is paused, or is not accessible");
+        }
+
+        if (element.deleted || element.purged) {
+            return localize("has been deleted or purged");
+        }
+
+        // is the element's extension not a subtype of any of the required extensions?
+        if (hasInvalidExtension(element)) {
+            return localize(`has an invalid extension: ${element.extension}`);
+        }
+        return null;
+    }
+
+    return {
+        collectionName,
+        removeExtensions,
+        hideSourceItems,
+        hasInvalidExtension,
+        onUpdateHideSourceItems,
+        onUpdateCollectionName,
+        isElementInvalid,
+        validInput,
+        onCollectionCreate,
+        showButtonsForModal,
+    };
+}
diff --git a/client/src/components/Collections/common/useExtensionFilter.ts b/client/src/components/Collections/common/useExtensionFilter.ts
new file mode 100644
index 000000000000..455616eda2eb
--- /dev/null
+++ b/client/src/components/Collections/common/useExtensionFilter.ts
@@ -0,0 +1,45 @@
+import { computed, toRef, watch } from "vue";
+
+import { useDatatypesMapperStore } from "@/stores/datatypesMapperStore";
+
+interface PropsWithOptionalExtensions {
+    extensions?: string[];
+}
+
+interface ElementHasExtension {
+    extension: string | null | undefined;
+}
+
+export function useExtensionFiltering(props: PropsWithOptionalExtensions) {
+    const extensions = toRef(props, "extensions");
+    // variables for datatype mapping and then filtering
+    const datatypesMapperStore = useDatatypesMapperStore();
+    const datatypesMapper = computed(() => datatypesMapperStore.datatypesMapper);
+    const filterExtensions = computed(() => !!datatypesMapper.value && !!extensions.value);
+
+    function hasInvalidExtension(element: ElementHasExtension) {
+        if (
+            filterExtensions.value &&
+            element.extension &&
+            !datatypesMapper.value?.isSubTypeOfAny(element.extension, props.extensions!)
+        ) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    watch(
+        () => datatypesMapper.value,
+        async (mapper) => {
+            if (extensions.value?.length && !mapper) {
+                await datatypesMapperStore.createMapper();
+            }
+        },
+        { immediate: true }
+    );
+
+    return {
+        hasInvalidExtension,
+    };
+}
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
new file mode 100644
index 000000000000..e6494a6e5468
--- /dev/null
+++ b/client/src/components/Collections/pairing.test.ts
@@ -0,0 +1,119 @@
+import {
+    autoDetectPairs,
+    autoPairWithCommonFilters,
+    guessInitialFilterType,
+    guessNameForPair,
+    splitIntoPairedAndUnpaired,
+} from "./pairing";
+
+function mockDataset(name: string) {
+    return { name };
+}
+
+const M1 = mockDataset("moo_1.fastq");
+const M2 = mockDataset("moo_2.fastq");
+
+const F1 = mockDataset("foo_1.fastq");
+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 = [
+            { name: "sample1_1.fastq" },
+            { name: "sample1_2.fastq" },
+            { name: "sample2_1.fastq" },
+            { name: "sample2_2.fastq" },
+        ];
+        expect(guessInitialFilterType(elements)).toBe("illumina");
+    });
+
+    test("should return 'null' when none of the filters work well", () => {
+        const elements = [{ name: "mydata123.fastq" }, { name: "mydata124.fastq" }, { name: "mydata125.fastq" }];
+        expect(guessInitialFilterType(elements)).toBe(null);
+    });
+});
+
+describe("guessNameForPair", () => {
+    test("it should use the LCS and work with _1/_2 filters", () => {
+        expect(guessNameForPair(mockDataset("moo_1.fastq"), mockDataset("moo_2.fastq"), "_1", "_2", true)).toEqual(
+            "moo"
+        );
+    });
+
+    test("it should use the LCS as a name and work with .1.fastq/.2.fastq filters", () => {
+        expect(
+            guessNameForPair(mockDataset("moo.1.fastq"), mockDataset("moo.2.fastq"), ".1.fastq", ".2.fastq", true)
+        ).toEqual("moo");
+    });
+
+    test("it should use the LCS as a name and part of that is cutting out mismatched junk", () => {
+        expect(
+            guessNameForPair(
+                mockDataset("moo_middledifferent_endssame.1.fastq"),
+                mockDataset("moo_yuck_endssame.2.fastq"),
+                ".1.fastq",
+                ".2.fastq",
+                true
+            )
+        ).toEqual("moo__endssame");
+    });
+
+    /* The way the filters and extension stripping are handled is less than ideal, this should work IMO for instance. -jmchilton
+    test("it should use the LCS as a name and part of that is cutting out mismatched junk", () => {
+        expect(guessNameForPair(mockDataset("moo.middledifferent.endssame.1.fastq"), mockDataset("moo.yuck.endssame.2.fastq"), ".1.fastq", ".2.fastq", true)).toEqual("moo.endssame");
+    });
+    */
+});
+
+describe("autoDetectPairs", () => {
+    test("is should be able to match exact matches after filter...", () => {
+        const paired = autoDetectPairs([M1], [M2], "_1", "_2", true);
+        expect(paired).toHaveLength(1);
+        const pair = paired[0];
+        expect(pair?.name).toBe("moo");
+    });
+
+    test("is should be able to match exact matches after filter out of order...", () => {
+        const paired = autoDetectPairs([B1, M1, F1], [F2, B2, M2], "_1", "_2", true);
+        expect(paired).toHaveLength(3);
+        const pairedNames = paired.map((p) => p.name);
+        expect(pairedNames).toContain("bar");
+        expect(pairedNames).toContain("moo");
+        expect(pairedNames).toContain("bar");
+    });
+});
+
+describe("autoPairWithCommonFilters", () => {
+    test("it should return an indication of the filter type used", () => {
+        const summary = autoPairWithCommonFilters([B1, M1, F1, F2, B2, M2], true);
+        expect(summary.filterType).toEqual("illumina");
+        expect(summary.pairs).toHaveLength(3);
+        expect(summary.unpaired).toHaveLength(0);
+    });
+
+    test("it should return unpaired datasets if some are not matched off", () => {
+        const summary = autoPairWithCommonFilters([B1, M1, F1, F2, B2], true);
+        expect(summary.filterType).toEqual("illumina");
+        expect(summary.pairs).toHaveLength(2);
+        expect(summary.unpaired).toHaveLength(1);
+        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
new file mode 100644
index 000000000000..fe35301f2bf2
--- /dev/null
+++ b/client/src/components/Collections/pairing.ts
@@ -0,0 +1,397 @@
+import type { GenericPair } from "@/components/History/adapters/buildCollectionModal";
+
+export const COMMON_FILTERS = {
+    illumina: ["_1", "_2"] as [string, string],
+    Rs: ["_R1", "_R2"] as [string, string],
+    dot12s: [".1.fastq", ".2.fastq"] as [string, string],
+};
+export type CommonFiltersType = keyof typeof COMMON_FILTERS;
+export const DEFAULT_FILTER: CommonFiltersType = "illumina";
+
+export interface HasName {
+    name: string | null;
+}
+
+export function guessInitialFilterType(elements: HasName[]): CommonFiltersType | null {
+    let illumina = 0;
+    let dot12s = 0;
+    let Rs = 0;
+
+    //should we limit the forEach? What if there are 1000s of elements?
+    elements.forEach((element) => {
+        if (element.name?.includes(".1.fastq") || element.name?.includes(".2.fastq")) {
+            dot12s++;
+        } else if (element.name?.includes("_R1") || element.name?.includes("_R2")) {
+            Rs++;
+        } else if (element.name?.includes("_1") || element.name?.includes("_2")) {
+            illumina++;
+        }
+    });
+    // if we cannot filter don't set an initial filter and hide all the data
+    if (illumina == 0 && dot12s == 0 && Rs == 0) {
+        return null;
+    } else if (illumina > dot12s && illumina > Rs) {
+        return "illumina";
+    } else if (dot12s > illumina && dot12s > Rs) {
+        return "dot12s";
+    } else if (Rs > illumina && Rs > dot12s) {
+        return "Rs";
+    } else {
+        return "illumina";
+    }
+}
+
+function _defaultName(fwd: HasName, rev: HasName): string {
+    return fwd.name + "_and_" + rev.name;
+}
+
+export function _guessNameForPair(
+    fwd: HasName,
+    rev: HasName,
+    forwardFilter: RegExp,
+    reverseFilter: RegExp,
+    willRemoveExtensions: boolean
+) {
+    let fwdName = fwd.name;
+    let revName = rev.name;
+    const fwdNameFilter = fwdName?.replace(forwardFilter, "");
+    const revNameFilter = revName?.replace(reverseFilter, "");
+    if (!fwdNameFilter || !revNameFilter || !fwdName || !revName) {
+        return _defaultName(fwd, rev);
+    }
+    let lcs = naiveStartingAndEndingLCS(fwdNameFilter, revNameFilter);
+    // remove url prefix if files were uploaded by url
+    const lastSlashIndex = lcs.lastIndexOf("/");
+    if (lastSlashIndex > 0) {
+        const urlprefix = lcs.slice(0, lastSlashIndex + 1);
+        lcs = lcs.replace(urlprefix, "");
+    }
+
+    if (willRemoveExtensions) {
+        const lastDotIndex = lcs.lastIndexOf(".");
+        if (lastDotIndex > 0) {
+            const extension = lcs.slice(lastDotIndex, lcs.length);
+            lcs = lcs.replace(extension, "");
+            fwdName = fwdName.replace(extension, "");
+            revName = revName.replace(extension, "");
+        }
+    }
+    if (lcs.endsWith(".") || lcs.endsWith("_")) {
+        lcs = lcs.substring(0, lcs.length - 1);
+    }
+    return lcs || _defaultName(fwd, rev);
+}
+
+export function guessNameForPair(
+    fwd: HasName,
+    rev: HasName,
+    forwardFilter: string,
+    reverseFilter: string,
+    willRemoveExtensions: boolean
+) {
+    return _guessNameForPair(
+        fwd,
+        rev,
+        new RegExp(forwardFilter || ""),
+        new RegExp(reverseFilter || ""),
+        willRemoveExtensions
+    );
+}
+
+/** Return the concat'd longest common prefix and suffix from two strings */
+export function naiveStartingAndEndingLCS(s1: string, s2: string) {
+    let fwdLCS = "";
+    let revLCS = "";
+    let i = 0;
+    let j = 0;
+    while (i < s1.length && i < s2.length) {
+        if (s1[i] !== s2[i]) {
+            break;
+        }
+        fwdLCS += s1[i];
+        i += 1;
+    }
+    if (i === s1.length) {
+        return s1;
+    }
+    if (i === s2.length) {
+        return s2;
+    }
+
+    i = s1.length - 1;
+    j = s2.length - 1;
+    while (i >= 0 && j >= 0) {
+        if (s1[i] !== s2[j]) {
+            break;
+        }
+        revLCS = [s1[i], revLCS].join("");
+        i -= 1;
+        j -= 1;
+    }
+    return fwdLCS + revLCS;
+}
+
+export function createPair<T extends HasName>(fwd: T, rev: T, name: string): { forward: T; reverse: T; name: string } {
+    // Ensure existence and don't pair something with itself
+    if (!(fwd && rev) || fwd === rev) {
+        throw new Error(`Bad pairing: ${[JSON.stringify(fwd), JSON.stringify(rev)]}`);
+    }
+    return { forward: fwd, reverse: rev, name: name };
+}
+
+/* This abstraction describes scoring function to attempt to auto match pairs with. */
+export type MatchingFunction = (params: {
+    matchTo: string;
+    possible: string;
+    index: number;
+    bestMatch: { score: number; index: number };
+}) => { score: number; index: number };
+
+export const matchOnlyIfExact: MatchingFunction = (params) => {
+    params = params || {};
+    if (params.matchTo === params.possible) {
+        return {
+            index: params.index,
+            score: 1.0,
+        };
+    }
+    return params.bestMatch;
+};
+
+export const matchOnPercentOfStartingAndEndingLCS: MatchingFunction = (params) => {
+    params = params || {};
+    const match = naiveStartingAndEndingLCS(params.matchTo, params.possible).length;
+    const score = match / Math.max(params.matchTo.length, params.possible.length);
+    if (score > params.bestMatch.score) {
+        return {
+            index: params.index,
+            score: score,
+        };
+    }
+    return params.bestMatch;
+};
+
+// take in a matching function and return a function that will take two lists
+// and yield all the pairs, the PairedListCollectionBuilder did stuff with state
+// deep in body of the function. This version just modifies the given lists and
+// returns pairs
+export function statelessAutoPairFnBuilder<T extends HasName>(
+    match: MatchingFunction,
+    scoreThreshold: number,
+    forwardFilter: string,
+    reverseFilter: string,
+    willRemoveExtensions: boolean
+) {
+    function splicePairOutOfSuppliedLists(params: {
+        listA: T[];
+        indexA: number;
+        listB: T[];
+        indexB: number;
+    }): { forward: T; reverse: T; name: string } | undefined {
+        const a = params.listA.splice(params.indexA, 1)[0] as T;
+        const b = params.listB.splice(params.indexB, 1)[0] as T;
+        if (!a || !b) {
+            return undefined;
+        }
+        const aInBIndex = params.listB.indexOf(a);
+        const bInAIndex = params.listA.indexOf(b);
+        if (aInBIndex !== -1) {
+            params.listB.splice(aInBIndex, 1);
+        }
+        if (bInAIndex !== -1) {
+            params.listA.splice(bInAIndex, 1);
+        }
+        const pairName = guessNameForPair(a, b, forwardFilter, reverseFilter, willRemoveExtensions);
+        return createPair(a, b, pairName);
+    }
+
+    // compile these here outside of the loop
+    const forwardRegExp = new RegExp(forwardFilter);
+    const reverseRegExp = new RegExp(reverseFilter);
+
+    function _preprocessMatch(params: {
+        matchTo: T;
+        possible: T;
+        index: number;
+        bestMatch: { score: number; index: number };
+    }) {
+        return Object.assign(params, {
+            matchTo: params.matchTo.name?.replace(forwardRegExp || "", ""),
+            possible: params.possible.name?.replace(reverseRegExp || "", ""),
+            index: params.index,
+            bestMatch: params.bestMatch,
+        });
+    }
+
+    return function _strategy(params: { listA: T[]; listB: T[] }) {
+        params = params || {};
+        const listA = params.listA;
+        const listB = params.listB;
+        let indexA = 0;
+        let indexB;
+
+        let bestMatch = {
+            score: 0.0,
+            index: -1,
+        };
+
+        const paired = [];
+        while (indexA < listA.length) {
+            const matchTo = listA[indexA];
+            bestMatch.score = 0.0;
+
+            if (!matchTo) {
+                continue;
+            }
+            for (indexB = 0; indexB < listB.length; indexB++) {
+                const possible = listB[indexB] as T;
+                if (listA[indexA] !== listB[indexB]) {
+                    bestMatch = match(
+                        _preprocessMatch({
+                            matchTo: matchTo,
+                            possible: possible,
+                            index: indexB,
+                            bestMatch: bestMatch,
+                        })
+                    );
+                    if (bestMatch.score === 1.0) {
+                        break;
+                    }
+                }
+            }
+            if (bestMatch.score >= scoreThreshold) {
+                const createdPair = splicePairOutOfSuppliedLists({
+                    listA: listA,
+                    indexA: indexA,
+                    listB: listB,
+                    indexB: bestMatch.index,
+                });
+                if (createdPair) {
+                    paired.push(createdPair);
+                }
+            } else {
+                indexA += 1;
+            }
+            if (!listA.length || !listB.length) {
+                return paired;
+            }
+        }
+        return paired;
+    };
+}
+
+export function splitElementsByFilter<T extends HasName>(elements: T[], forwardFilter: string, reverseFilter: string) {
+    const filters = [new RegExp(forwardFilter), new RegExp(reverseFilter)];
+    const split: [T[], T[]] = [[], []];
+    elements.forEach((e) => {
+        filters.forEach((filter, i) => {
+            if (e.name && filter.test(e.name)) {
+                split[i]?.push(e);
+            }
+        });
+    });
+    return split;
+}
+
+export function autoDetectPairs<T extends HasName>(
+    listA: T[],
+    listB: T[],
+    forwardFilter: string,
+    reverseFilter: string,
+    willRemoveExtensions: boolean
+) {
+    function autoPairSimple(params: { listA: T[]; listB: T[] }) {
+        return statelessAutoPairFnBuilder<T>(
+            matchOnlyIfExact, // will only issue 1.0 scores if exact
+            0.6,
+            forwardFilter,
+            reverseFilter,
+            willRemoveExtensions
+        )(params);
+    }
+
+    function autoPairLCS(params: { listA: T[]; listB: T[] }) {
+        return statelessAutoPairFnBuilder<T>(
+            matchOnPercentOfStartingAndEndingLCS,
+            0.99,
+            forwardFilter,
+            reverseFilter,
+            willRemoveExtensions
+        )(params);
+    }
+
+    const listACopy = listA.slice();
+    const listBCopy = listB.slice();
+
+    let paired: GenericPair<T>[] = [];
+    const simplePaired = autoPairSimple({
+        listA: listACopy,
+        listB: listBCopy,
+    });
+    paired = simplePaired ? simplePaired : paired;
+    for (const pair of paired) {
+        const indexA = listACopy.indexOf(pair.forward);
+        if (indexA !== -1) {
+            listACopy.splice(indexA, 1);
+        }
+        const indexB = listBCopy.indexOf(pair.reverse);
+        if (indexB !== -1) {
+            listBCopy.splice(indexB, 1);
+        }
+    }
+
+    const pairedStrategy = autoPairLCS({
+        listA: listACopy,
+        listB: listBCopy,
+    });
+    paired = pairedStrategy ? paired.concat(pairedStrategy) : paired;
+    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();
+    for (const pair of pairs) {
+        const indexF = unpaired.indexOf(pair.forward);
+        if (indexF !== -1) {
+            unpaired.splice(indexF, 1);
+        }
+        const indexR = unpaired.indexOf(pair.reverse);
+        if (indexR !== -1) {
+            unpaired.splice(indexR, 1);
+        }
+    }
+    return { pairs: pairs, unpaired: unpaired, forwardFilter, reverseFilter };
+}
+
+export function autoPairWithCommonFilters<T extends HasName>(elements: T[], willRemoveExtensions: boolean) {
+    const filterType = guessInitialFilterType(elements);
+    if (filterType) {
+        const [forwardFilter, reverseFilter] = COMMON_FILTERS[filterType];
+        const { pairs, unpaired } = splitIntoPairedAndUnpaired(
+            elements,
+            forwardFilter,
+            reverseFilter,
+            willRemoveExtensions
+        );
+        return { filterType, forwardFilter, reverseFilter, pairs, unpaired };
+    } else {
+        return { filterType, forwardFilter: undefined, reverseFilter: undefined, pairs: [], unpaired: elements };
+    }
+}
diff --git a/client/src/components/Collections/tables.ts b/client/src/components/Collections/tables.ts
new file mode 100644
index 000000000000..9752f232ba8d
--- /dev/null
+++ b/client/src/components/Collections/tables.ts
@@ -0,0 +1,61 @@
+import { computed, ref } from "vue";
+
+export function useTableSummary() {
+    const rawValue = ref<string>("");
+
+    const table = computed(() => {
+        return rawToTable(rawValue.value);
+    });
+
+    const columnCount = computed<number>(() => {
+        const tableVal = table.value;
+        if (tableVal && tableVal.length) {
+            return tableVal[0]?.length || 0;
+        } else {
+            return 0;
+        }
+    });
+
+    const isJaggedData = computed<boolean>(() => {
+        const tableVal = table.value;
+        const columnCountVal = columnCount.value;
+        for (const row of tableVal) {
+            if (row.length != columnCountVal) {
+                return true;
+            }
+        }
+        return false;
+    });
+
+    const jaggedDataWarning = computed<string | undefined>(() => {
+        if (isJaggedData.value) {
+            return "This data contains a different number of columns per-row, this probably shouldn't be used as is.";
+        } else {
+            return undefined;
+        }
+    });
+    return {
+        rawValue,
+        isJaggedData,
+        jaggedDataWarning,
+        columnCount,
+        table,
+    };
+}
+
+export function rawToTable(content: string): string[][] {
+    const hasNonWhitespaceChars = RegExp(/[^\s]/);
+    // Have pasted data, data from a history dataset, or FTP list.
+    const lines = content.split(/[\n\r]/).filter((line) => line.length > 0 && hasNonWhitespaceChars.exec(line));
+    // Really poor tabular parser - we should get a library for this or expose options? I'm not
+    // sure.
+    let hasTabs = false;
+    if (lines.length > 0) {
+        const firstLine = lines[0];
+        if (firstLine && firstLine.indexOf("\t") >= 0) {
+            hasTabs = true;
+        }
+    }
+    const regex = hasTabs ? /\t/ : /\s+/;
+    return lines.map((line) => line.split(regex));
+}
diff --git a/client/src/components/Collections/wizard/CreatingWhat.vue b/client/src/components/Collections/wizard/CreatingWhat.vue
new file mode 100644
index 000000000000..20c54ebcf412
--- /dev/null
+++ b/client/src/components/Collections/wizard/CreatingWhat.vue
@@ -0,0 +1,43 @@
+<script setup lang="ts">
+import { BCard, BCardGroup, BCardTitle } from "bootstrap-vue";
+
+import { borderVariant } from "@/components/Common/Wizard/utils";
+
+import { type RulesCreatingWhat } from "./types";
+
+interface Props {
+    creatingWhat: RulesCreatingWhat;
+}
+
+const emit = defineEmits(["onChange"]);
+
+defineProps<Props>();
+</script>
+
+<template>
+    <BCardGroup deck>
+        <BCard
+            data-creating-what="datasets"
+            class="wizard-selection-card"
+            :border-variant="borderVariant(creatingWhat === 'datasets')"
+            @click="emit('onChange', 'datasets')">
+            <BCardTitle>
+                <b>Datasets</b>
+            </BCardTitle>
+            <div>
+                This option lets you import any number of individual Galaxy datasets. These will be unique items in your
+                Galaxy history.
+            </div>
+        </BCard>
+        <BCard
+            data-creating-what="collections"
+            class="wizard-selection-card"
+            :border-variant="borderVariant(creatingWhat === 'collections')"
+            @click="emit('onChange', 'collections')">
+            <BCardTitle>
+                <b>Collections</b>
+            </BCardTitle>
+            <div>This option lets you create or more Galaxy dataset collections.</div>
+        </BCard>
+    </BCardGroup>
+</template>
diff --git a/client/src/components/Collections/wizard/JaggedDataAlert.vue b/client/src/components/Collections/wizard/JaggedDataAlert.vue
new file mode 100644
index 000000000000..75fa2ef95adc
--- /dev/null
+++ b/client/src/components/Collections/wizard/JaggedDataAlert.vue
@@ -0,0 +1,17 @@
+<script setup lang="ts">
+import { BAlert } from "bootstrap-vue";
+
+interface Props {
+    jaggedDataWarning?: string;
+}
+
+defineProps<Props>();
+</script>
+
+<template>
+    <span>
+        <BAlert v-if="jaggedDataWarning" show variant="warning">
+            {{ jaggedDataWarning }}
+        </BAlert>
+    </span>
+</template>
diff --git a/client/src/components/Collections/wizard/PasteData.vue b/client/src/components/Collections/wizard/PasteData.vue
new file mode 100644
index 000000000000..1c9b2849fd65
--- /dev/null
+++ b/client/src/components/Collections/wizard/PasteData.vue
@@ -0,0 +1,82 @@
+<script setup lang="ts">
+import { ref, watch } from "vue";
+
+import { useTableSummary } from "@/components/Collections/tables";
+
+import JaggedDataAlert from "./JaggedDataAlert.vue";
+
+const emit = defineEmits(["onChange"]);
+
+const isDragging = ref(false);
+const { rawValue, jaggedDataWarning, table } = useTableSummary();
+
+watch(table, (newValue: string[][]) => {
+    emit("onChange", table.value);
+});
+
+const handleDrop = (event: DragEvent) => {
+    isDragging.value = false;
+    const file = event.dataTransfer?.files[0];
+    if (file) {
+        const reader = new FileReader();
+
+        reader.onload = () => {
+            rawValue.value = reader.result as string;
+        };
+
+        reader.onerror = () => {
+            console.error("Failed to read file");
+        };
+
+        reader.readAsText(file); // Read the file as text
+    }
+};
+</script>
+
+<template>
+    <div class="paste-data">
+        <JaggedDataAlert :jaggedDataWarning="jaggedDataWarning" />
+        <div
+            class="dropzone"
+            :class="{ highlight: isDragging }"
+            @drop.prevent="handleDrop"
+            @dragover.prevent="isDragging = true"
+            @dragleave.prevent="isDragging = false">
+            <textarea v-model="rawValue" class="p-2 mt-2" placeholder="Paste URIs and optional metadata here." />
+        </div>
+    </div>
+</template>
+
+<style scoped>
+@import "theme/blue.scss";
+
+.paste-data {
+    min-width: 576px;
+    display: flex;
+    flex-flow: row wrap;
+    margin-right: -15px;
+    margin-left: -15px;
+}
+
+.paste-data textarea {
+    resize: none;
+    width: 100%;
+    height: 300px;
+    font-size: $font-size-base;
+    -moz-border-radius: $border-radius-large;
+    border-radius: $border-radius-large;
+    border-color: $border-color;
+    border-width: 2px;
+}
+.dropzone {
+    padding: 7px !important;
+    width: 100%;
+}
+.dropzone.highlight {
+    border-width: 2px;
+    border-color: $border-color;
+    border-style: dashed;
+    border-radius: $border-radius-large;
+    -moz-border-radius: $border-radius-large;
+}
+</style>
diff --git a/client/src/components/Collections/wizard/SelectDataset.vue b/client/src/components/Collections/wizard/SelectDataset.vue
new file mode 100644
index 000000000000..ac3b8d617e22
--- /dev/null
+++ b/client/src/components/Collections/wizard/SelectDataset.vue
@@ -0,0 +1,62 @@
+<script setup lang="ts">
+import { BAlert, BCard, BCardTitle } from "bootstrap-vue";
+import { ref, watch } from "vue";
+
+import { getGalaxyInstance } from "@/app";
+import { useTableSummary } from "@/components/Collections/tables";
+import { errorMessageAsString } from "@/utils/simple-error";
+import { urlData } from "@/utils/url";
+
+import JaggedDataAlert from "./JaggedDataAlert.vue";
+
+const emit = defineEmits(["onChange", "onError"]);
+const errorMessage = ref<string | undefined>(undefined);
+const { rawValue, jaggedDataWarning, table } = useTableSummary();
+
+async function fetchAndHandleData(response: Record) {
+    const selectedDatasetId = response.id;
+    const historyId = response.history_id;
+    try {
+        const newSourceContent = await urlData({
+            url: `/api/histories/${historyId}/contents/${selectedDatasetId}/display`,
+        });
+        rawValue.value = newSourceContent as string;
+    } catch (error) {
+        rawValue.value = "";
+        errorMessage.value = errorMessageAsString(error);
+    }
+}
+
+interface Record {
+    id: string;
+    history_id: string;
+}
+
+function inputDialog() {
+    const Galaxy = getGalaxyInstance();
+    Galaxy.data.dialog(fetchAndHandleData, {
+        multiple: false,
+        library: false,
+        format: null,
+        allowUpload: false,
+    });
+}
+
+watch(table, (newValue: string[][]) => {
+    emit("onChange", table.value);
+});
+</script>
+
+<template>
+    <BCard class="wizard-selection-card" border-variant="primary" @click="inputDialog">
+        <BCardTitle>
+            <b>Select dataset</b>
+        </BCardTitle>
+        <div>
+            <BAlert v-if="errorMessage" show variant="danger">{{ errorMessage }}</BAlert>
+            <JaggedDataAlert :jaggedDataWarning="jaggedDataWarning" />
+            Select a history datasets, the contents will be loaded as tabular data and made available to the rule based
+            import utility.
+        </div>
+    </BCard>
+</template>
diff --git a/client/src/components/Collections/wizard/SelectFolder.vue b/client/src/components/Collections/wizard/SelectFolder.vue
new file mode 100644
index 000000000000..643cded78017
--- /dev/null
+++ b/client/src/components/Collections/wizard/SelectFolder.vue
@@ -0,0 +1,35 @@
+<script setup lang="ts">
+import { BFormGroup, BLink } from "bootstrap-vue";
+import { ref, watch } from "vue";
+
+import FilesInput from "@/components/FilesDialog/FilesInput.vue";
+
+interface Props {
+    ftpUploadSite?: string;
+}
+
+defineProps<Props>();
+
+const remoteUri = ref<string>("");
+
+const emit = defineEmits(["onChange", "onFtp"]);
+
+watch(remoteUri, (newValue: string) => {
+    emit("onChange", newValue);
+});
+</script>
+
+<template>
+    <div>
+        <BFormGroup
+            id="fieldset-directory"
+            label-for="directory"
+            :description="`Select a 'remote files' directory to import from.`"
+            class="mt-3">
+            <FilesInput id="directory" v-model="remoteUri" mode="directory" :require-writable="false" />
+        </BFormGroup>
+        <div v-if="ftpUploadSite">
+            Alternatively, <BLink @click="emit('onFtp')">click here to load your Galaxy FTP directory contents</BLink>.
+        </div>
+    </div>
+</template>
diff --git a/client/src/components/Collections/wizard/SourceFromCollection.vue b/client/src/components/Collections/wizard/SourceFromCollection.vue
new file mode 100644
index 000000000000..4c6098de7c38
--- /dev/null
+++ b/client/src/components/Collections/wizard/SourceFromCollection.vue
@@ -0,0 +1,29 @@
+<script setup lang="ts">
+import { BCard, BCardTitle } from "bootstrap-vue";
+
+import { borderVariant } from "@/components/Common/Wizard/utils";
+
+interface Props {
+    selected: boolean;
+}
+
+defineProps<Props>();
+
+const emit = defineEmits(["select"]);
+</script>
+
+<template>
+    <BCard
+        data-import-source-from="collection"
+        class="wizard-selection-card"
+        :border-variant="borderVariant(selected)"
+        @click="emit('select', 'collection')">
+        <BCardTitle>
+            <b>An Existing Collection</b>
+        </BCardTitle>
+        <div>
+            The "Apply Rules" tool allows you to transform an existing collection using the same set of rules as can be
+            used to import new data.
+        </div>
+    </BCard>
+</template>
diff --git a/client/src/components/Collections/wizard/SourceFromDatasetAsTable.vue b/client/src/components/Collections/wizard/SourceFromDatasetAsTable.vue
new file mode 100644
index 000000000000..2a3b754de066
--- /dev/null
+++ b/client/src/components/Collections/wizard/SourceFromDatasetAsTable.vue
@@ -0,0 +1,29 @@
+<script setup lang="ts">
+import { BCard, BCardTitle } from "bootstrap-vue";
+
+import { borderVariant } from "@/components/Common/Wizard/utils";
+
+interface Props {
+    selected: boolean;
+}
+
+defineProps<Props>();
+
+const emit = defineEmits(["select"]);
+</script>
+
+<template>
+    <BCard
+        data-import-source-from="dataset_as_table"
+        class="wizard-selection-card"
+        :border-variant="borderVariant(selected)"
+        @click="emit('select', 'dataset_as_table')">
+        <BCardTitle>
+            <b>Dataset As Table</b>
+        </BCardTitle>
+        <div>
+            This option lets you load a list of URIs or any sort of tabular data that can be transformed into a list of
+            URIs to describe the datasets and metadata to import from an existing Galaxy dataset.
+        </div>
+    </BCard>
+</template>
diff --git a/client/src/components/Collections/wizard/SourceFromPastedData.vue b/client/src/components/Collections/wizard/SourceFromPastedData.vue
new file mode 100644
index 000000000000..74a6bae7d01c
--- /dev/null
+++ b/client/src/components/Collections/wizard/SourceFromPastedData.vue
@@ -0,0 +1,29 @@
+<script setup lang="ts">
+import { BCard, BCardTitle } from "bootstrap-vue";
+
+import { borderVariant } from "@/components/Common/Wizard/utils";
+
+interface Props {
+    selected: boolean;
+}
+
+defineProps<Props>();
+
+const emit = defineEmits(["select"]);
+</script>
+
+<template>
+    <BCard
+        data-import-source-from="pasted_table"
+        class="wizard-selection-card"
+        :border-variant="borderVariant(selected)"
+        @click="emit('select', 'pasted_table')">
+        <BCardTitle>
+            <b>Pasted Table</b>
+        </BCardTitle>
+        <div>
+            This option lets you just paste in a list of URLs/URIs or any sort of tabular data that can be transformed
+            into a list of URIs to describe the datasets and metadata to import.
+        </div>
+    </BCard>
+</template>
diff --git a/client/src/components/Collections/wizard/SourceFromRemoteFiles.vue b/client/src/components/Collections/wizard/SourceFromRemoteFiles.vue
new file mode 100644
index 000000000000..a0778ca7c64e
--- /dev/null
+++ b/client/src/components/Collections/wizard/SourceFromRemoteFiles.vue
@@ -0,0 +1,26 @@
+<script setup lang="ts">
+import { BCard, BCardTitle } from "bootstrap-vue";
+
+import { borderVariant } from "@/components/Common/Wizard/utils";
+
+interface Props {
+    selected: boolean;
+}
+
+defineProps<Props>();
+
+const emit = defineEmits(["select"]);
+</script>
+
+<template>
+    <BCard
+        data-import-source-from="remote_files"
+        class="wizard-selection-card"
+        :border-variant="borderVariant(selected)"
+        @click="emit('select', 'remote_files')">
+        <BCardTitle>
+            <b>Remote Files</b>
+        </BCardTitle>
+        <div>This option lets you select a folder of file URIs from Galaxy's configured "remote file" sources.</div>
+    </BCard>
+</template>
diff --git a/client/src/components/Collections/wizard/types.ts b/client/src/components/Collections/wizard/types.ts
new file mode 100644
index 000000000000..070e00717397
--- /dev/null
+++ b/client/src/components/Collections/wizard/types.ts
@@ -0,0 +1,8 @@
+import { type components } from "@/api/schema";
+
+export type RulesCreatingWhat = "datasets" | "collections";
+export type RulesSourceFrom = "remote_files" | "pasted_table" | "dataset_as_table" | "collection";
+
+export type ListUriResponse = components["schemas"]["ListUriResponse"];
+export type RemoteFile = components["schemas"]["RemoteFile"];
+export type RemoteDirectory = components["schemas"]["RemoteDirectory"];
diff --git a/client/src/components/Collections/wizard/useFileSetSources.ts b/client/src/components/Collections/wizard/useFileSetSources.ts
new file mode 100644
index 000000000000..9d7bfcb35747
--- /dev/null
+++ b/client/src/components/Collections/wizard/useFileSetSources.ts
@@ -0,0 +1,45 @@
+import { type Ref, ref } from "vue";
+
+import { getRemoteEntriesAt } from "@/components/Upload/utils";
+
+import { type ListUriResponse, type RemoteDirectory, type RemoteFile } from "./types";
+
+export function useFileSetSources(isBusy: Ref<boolean>) {
+    const pasteData = ref<string[][]>([] as string[][]);
+    const tabularDatasetContents = ref<string[][]>([] as string[][]);
+    const uris = ref<RemoteFile[]>([]);
+
+    async function setRemoteFilesFolder(uri: string) {
+        isBusy.value = true;
+        const rawFiles = await getRemoteEntriesAt(uri);
+        if (rawFiles) {
+            const files: RemoteFile[] = (rawFiles as ListUriResponse).filter(
+                (file: RemoteFile | RemoteDirectory) => file["class"] == "File"
+            ) as RemoteFile[];
+            uris.value = files;
+        }
+        isBusy.value = false;
+    }
+
+    async function onFtp() {
+        setRemoteFilesFolder("gxftp://");
+    }
+
+    function setDatasetContents(contents: string[][]) {
+        tabularDatasetContents.value = contents;
+    }
+
+    function setPasteTable(newValue: string[][]) {
+        pasteData.value = newValue;
+    }
+
+    return {
+        pasteData,
+        tabularDatasetContents,
+        uris,
+        setRemoteFilesFolder,
+        onFtp,
+        setDatasetContents,
+        setPasteTable,
+    };
+}
diff --git a/client/src/components/Common/Wizard/GenericWizard.vue b/client/src/components/Common/Wizard/GenericWizard.vue
index 3a2d165dd015..dc75454e5f0f 100644
--- a/client/src/components/Common/Wizard/GenericWizard.vue
+++ b/client/src/components/Common/Wizard/GenericWizard.vue
@@ -41,16 +41,32 @@ interface Props {
 
 const props = withDefaults(defineProps<Props>(), {
     use: undefined,
-    title: "Generic Wizard",
+    title: undefined,
     submitButtonLabel: "Submit",
     isBusy: false,
 });
 
+function dynamicIsLast() {
+    if (props.use.isLast.value) {
+        return true;
+    }
+
+    let nextStepIndex = props.use.index.value + 1;
+    let nextStepName = props.use.stepNames.value.at(nextStepIndex);
+
+    while (nextStepName && props.use.steps.value[nextStepName]?.isSkippable()) {
+        nextStepIndex++;
+        nextStepName = props.use.stepNames.value.at(nextStepIndex);
+    }
+
+    return !nextStepName;
+}
+
 const emit = defineEmits(["submit"]);
 
 function goNext() {
     if (props.use.current.value.isValid()) {
-        if (props.use.isLast.value) {
+        if (dynamicIsLast()) {
             emit("submit");
         }
 
@@ -109,11 +125,20 @@ const stepsGridColumnsTemplate = computed(() => {
             .join(" ") + " max-content"
     );
 });
+
+const bodyStyle = computed(() => {
+    const width = props.use.current.value.width;
+    if (width) {
+        return { width: width };
+    } else {
+        return {};
+    }
+});
 </script>
 
 <template>
     <BCard class="wizard-container">
-        <BCardTitle>
+        <BCardTitle v-if="title">
             <h2>{{ title }}</h2>
         </BCardTitle>
         <BCardBody v-if="props.use?.steps?.value" class="wizard">
@@ -130,7 +155,7 @@ const stepsGridColumnsTemplate = computed(() => {
                             :disabled="(!allStepsBeforeAreValid(i) && props.use.isBefore(id)) || isBusy"
                             @click="props.use.goTo(id)">
                             <FontAwesomeIcon v-if="isStepDone(i)" :icon="faCheck" />
-                            <FontAwesomeIcon v-else-if="props.use.isLast && isBusy" :icon="faSpinner" spin />
+                            <FontAwesomeIcon v-else-if="dynamicIsLast() && isBusy" :icon="faSpinner" spin />
                             <span v-else>{{ determineDisplayStepIndex(i) }}</span>
                         </button>
                         <div class="step-label" v-text="step.label" />
@@ -142,7 +167,7 @@ const stepsGridColumnsTemplate = computed(() => {
             <div class="step-content">
                 <span class="h-md step-instructions" v-text="props.use.current.value.instructions" />
 
-                <div class="step-body">
+                <div class="step-body" :style="bodyStyle">
                     <slot>
                         <p>
                             Missing body for step <b>{{ props.use.current.value.label }}</b>
@@ -158,16 +183,16 @@ const stepsGridColumnsTemplate = computed(() => {
                 <button
                     class="go-next-btn"
                     :disabled="!props.use.current.value.isValid() || isBusy"
-                    :class="props.use.isLast.value ? 'btn-primary' : ''"
+                    :class="dynamicIsLast() ? 'btn-primary' : ''"
                     @click="goNext">
-                    {{ props.use.isLast.value ? submitButtonLabel : "Next" }}
+                    {{ dynamicIsLast() ? submitButtonLabel : "Next" }}
                 </button>
             </div>
         </BCardBody>
     </BCard>
 </template>
 
-<style scoped lang="scss">
+<style lang="scss">
 @import "theme/blue.scss";
 
 .wizard {
diff --git a/client/src/components/Common/Wizard/useWizard.ts b/client/src/components/Common/Wizard/useWizard.ts
index f863347fdad6..569b687d621a 100644
--- a/client/src/components/Common/Wizard/useWizard.ts
+++ b/client/src/components/Common/Wizard/useWizard.ts
@@ -25,6 +25,12 @@ export interface WizardStep {
      * This is useful for optional or conditional steps.
      */
     isSkippable: () => boolean;
+
+    /**
+     * Hack added by John, someone component in CSS should undo this or come up
+     * with an alternative that doesn't require this to be set.
+     */
+    hackBodyWidth?: string;
 }
 
 /**
diff --git a/client/src/components/Common/Wizard/utils.ts b/client/src/components/Common/Wizard/utils.ts
new file mode 100644
index 000000000000..7a817bcf3283
--- /dev/null
+++ b/client/src/components/Common/Wizard/utils.ts
@@ -0,0 +1,5 @@
+type BorderVariant = "primary" | "default";
+
+export function borderVariant(isPrimary: boolean): BorderVariant {
+    return isPrimary ? "primary" : "default";
+}
diff --git a/client/src/components/Form/Elements/FormData/FormData.vue b/client/src/components/Form/Elements/FormData/FormData.vue
index 0695af21369b..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,16 +498,25 @@ function canAcceptSrc(historyContentType: "dataset" | "dataset_collection", coll
     }
 }
 
+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) =>
-    ["list", "list:paired", "paired"].includes(collectionType)
+    collectionTypesWithBuilders.includes(collectionType)
 );
 
 function buildNewCollection(collectionType: string) {
-    if (!["list", "list:paired", "paired"].includes(collectionType)) {
+    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/Form/Elements/FormSelection.vue b/client/src/components/Form/Elements/FormSelection.vue
index 15176a48f063..12d681f4a517 100644
--- a/client/src/components/Form/Elements/FormSelection.vue
+++ b/client/src/components/Form/Elements/FormSelection.vue
@@ -100,7 +100,7 @@ watch(
 );
 
 const showSelectPreference = computed(
-    () => props.multiple && props.display !== "checkboxes" && props.display !== "radio"
+    () => props.multiple && props.display !== "checkboxes" && props.display !== "radio" && props.display !== "simple"
 );
 
 const displayMany = computed(() => showSelectPreference.value && useMany.value);
diff --git a/client/src/components/Form/FormListElementOperations.vue b/client/src/components/Form/FormListElementOperations.vue
new file mode 100644
index 000000000000..b2271deaa960
--- /dev/null
+++ b/client/src/components/Form/FormListElementOperations.vue
@@ -0,0 +1,70 @@
+<script setup lang="ts">
+import { library } from "@fortawesome/fontawesome-svg-core";
+import { faCaretDown, faCaretUp, faTrashAlt } from "@fortawesome/free-solid-svg-icons";
+import { FontAwesomeIcon } from "@fortawesome/vue-fontawesome";
+import { BButton, BButtonGroup } from "bootstrap-vue";
+
+// @ts-ignore: bad library types
+library.add(faTrashAlt, faCaretUp, faCaretDown);
+
+interface Props {
+    index: number;
+    numElements: number;
+    upButtonId: string;
+    downButtonId: string;
+    canDelete: boolean;
+    deleteTooltip: string;
+}
+
+defineProps<Props>();
+
+const emit = defineEmits<{
+    (e: "delete"): void;
+    (e: "swap-up"): void;
+    (e: "swap-down"): void;
+}>();
+</script>
+
+<template>
+    <span class="float-right">
+        <BButtonGroup>
+            <BButton
+                :id="upButtonId"
+                v-b-tooltip.hover.bottom
+                :disabled="index == 0"
+                title="move up"
+                role="button"
+                variant="link"
+                size="sm"
+                class="ml-0"
+                @click="() => emit('swap-up')">
+                <FontAwesomeIcon icon="caret-up" />
+            </BButton>
+            <BButton
+                :id="downButtonId"
+                v-b-tooltip.hover.bottom
+                :disabled="index >= numElements - 1"
+                title="move down"
+                role="button"
+                variant="link"
+                size="sm"
+                class="ml-0"
+                @click="() => emit('swap-down')">
+                <FontAwesomeIcon icon="caret-down" />
+            </BButton>
+        </BButtonGroup>
+
+        <span v-b-tooltip.hover.bottom :title="deleteTooltip">
+            <BButton
+                :disabled="!canDelete"
+                title="delete"
+                role="button"
+                variant="link"
+                size="sm"
+                class="ml-0"
+                @click="() => emit('delete')">
+                <FontAwesomeIcon icon="trash-alt" />
+            </BButton>
+        </span>
+    </span>
+</template>
diff --git a/client/src/components/Form/FormRepeat.vue b/client/src/components/Form/FormRepeat.vue
index b12b85bde084..7d707ae021aa 100644
--- a/client/src/components/Form/FormRepeat.vue
+++ b/client/src/components/Form/FormRepeat.vue
@@ -1,6 +1,6 @@
 <script setup lang="ts">
 import { library } from "@fortawesome/fontawesome-svg-core";
-import { faCaretDown, faCaretUp, faPlus, faTrashAlt } from "@fortawesome/free-solid-svg-icons";
+import { faPlus } from "@fortawesome/free-solid-svg-icons";
 import { FontAwesomeIcon } from "@fortawesome/vue-fontawesome";
 import { defineAsyncComponent, nextTick, type PropType } from "vue";
 import { computed } from "vue";
@@ -9,6 +9,7 @@ import { useKeyedObjects } from "@/composables/keyedObjects";
 import localize from "@/utils/localization";
 
 import FormCard from "./FormCard.vue";
+import FormListElementOperations from "./FormListElementOperations.vue";
 
 const FormNode = defineAsyncComponent(() => import("./FormInputs.vue"));
 
@@ -68,7 +69,7 @@ const emit = defineEmits<{
 }>();
 
 // @ts-ignore: bad library types
-library.add(faPlus, faTrashAlt, faCaretUp, faCaretDown);
+library.add(faPlus);
 
 function onInsert() {
     emit("insert");
@@ -127,45 +128,17 @@ const { keyObject } = useKeyedObjects();
             class="card"
             :title="getTitle(cacheId)">
             <template v-slot:operations>
-                <span v-if="!props.sustainRepeats" class="float-right">
-                    <b-button-group>
-                        <b-button
-                            :id="getButtonId(cacheId, 'up')"
-                            v-b-tooltip.hover.bottom
-                            title="move up"
-                            role="button"
-                            variant="link"
-                            size="sm"
-                            class="ml-0"
-                            @click="() => swap(cacheId, cacheId - 1, 'up')">
-                            <FontAwesomeIcon icon="caret-up" />
-                        </b-button>
-                        <b-button
-                            :id="getButtonId(cacheId, 'down')"
-                            v-b-tooltip.hover.bottom
-                            title="move down"
-                            role="button"
-                            variant="link"
-                            size="sm"
-                            class="ml-0"
-                            @click="() => swap(cacheId, cacheId + 1, 'down')">
-                            <FontAwesomeIcon icon="caret-down" />
-                        </b-button>
-                    </b-button-group>
-
-                    <span v-b-tooltip.hover.bottom :title="deleteTooltip">
-                        <b-button
-                            :disabled="!minRepeats"
-                            title="delete"
-                            role="button"
-                            variant="link"
-                            size="sm"
-                            class="ml-0"
-                            @click="() => onDelete(cacheId)">
-                            <FontAwesomeIcon icon="trash-alt" />
-                        </b-button>
-                    </span>
-                </span>
+                <FormListElementOperations
+                    v-if="!props.sustainRepeats"
+                    :index="cacheId"
+                    :num-elements="props.input.cache?.length || 0"
+                    :up-button-id="getButtonId(cacheId, 'up')"
+                    :down-button-id="getButtonId(cacheId, 'down')"
+                    :delete-tooltip="deleteTooltip"
+                    :can-delete="minRepeats"
+                    @swap-up="() => swap(cacheId, cacheId - 1, 'up')"
+                    @swap-down="() => swap(cacheId, cacheId + 1, 'down')"
+                    @delete="() => onDelete(cacheId)" />
             </template>
 
             <template v-slot:body>
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.test.js b/client/src/components/History/CurrentHistory/HistoryOperations/SelectionOperations.test.js
index c7f9594cf230..dba528c72b8b 100644
--- a/client/src/components/History/CurrentHistory/HistoryOperations/SelectionOperations.test.js
+++ b/client/src/components/History/CurrentHistory/HistoryOperations/SelectionOperations.test.js
@@ -207,20 +207,15 @@ describe("History Selection Operations", () => {
             });
 
             it("should display collection building options only on active (non-deleted) items", async () => {
-                const buildListOption = '[data-description="build list"]';
-                const buildListOfPairsOption = '[data-description="build list of pairs"]';
+                const buildListOption = '[data-description="auto build list"]';
                 await wrapper.setProps({ filterText: "visible:true deleted:false" });
                 expect(wrapper.find(buildListOption).exists()).toBe(true);
-                expect(wrapper.find(buildListOfPairsOption).exists()).toBe(true);
                 await wrapper.setProps({ filterText: "deleted:true" });
                 expect(wrapper.find(buildListOption).exists()).toBe(false);
-                expect(wrapper.find(buildListOfPairsOption).exists()).toBe(false);
                 await wrapper.setProps({ filterText: "visible:any deleted:false" });
                 expect(wrapper.find(buildListOption).exists()).toBe(true);
-                expect(wrapper.find(buildListOfPairsOption).exists()).toBe(true);
                 await wrapper.setProps({ filterText: "deleted:any" });
                 expect(wrapper.find(buildListOption).exists()).toBe(false);
-                expect(wrapper.find(buildListOfPairsOption).exists()).toBe(false);
             });
 
             it("should display list building option when all are selected", async () => {
diff --git a/client/src/components/History/CurrentHistory/HistoryOperations/SelectionOperations.vue b/client/src/components/History/CurrentHistory/HistoryOperations/SelectionOperations.vue
index d36a3fb0d59d..f356a7ff4afb 100644
--- a/client/src/components/History/CurrentHistory/HistoryOperations/SelectionOperations.vue
+++ b/client/src/components/History/CurrentHistory/HistoryOperations/SelectionOperations.vue
@@ -34,18 +34,6 @@
                 <span v-localize>Delete (permanently)</span>
             </b-dropdown-item>
             <b-dropdown-divider v-if="showBuildOptions" />
-            <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">
-                <span v-localize>Build List of Dataset Pairs</span>
-            </b-dropdown-item>
-            <b-dropdown-item
-                v-if="showBuildOptions"
-                data-description="build collection from rules"
-                @click="buildCollectionFromRules">
-                <span v-localize>Build Collection from Rules</span>
-            </b-dropdown-item>
             <b-dropdown-divider v-if="showBuildOptionForAll" />
             <b-dropdown-item
                 v-if="showBuildOptionForAll"
@@ -69,6 +57,13 @@
             <b-dropdown-item v-b-modal:remove-tags-from-selected-content data-description="remove tags">
                 <span v-localize>Remove tags</span>
             </b-dropdown-item>
+            <b-dropdown-divider v-if="showBuildOptions" />
+            <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>
 
         <b-modal id="hide-selected-content" title="Hide Selected Content?" title-tag="h2" @ok="hideSelected">
@@ -168,10 +163,8 @@ import { DatatypesProvider, DbKeyProvider } from "components/providers";
 import SingleItemSelector from "components/SingleItemSelector";
 import { StatelessTags } from "components/Tags";
 
-import { createDatasetCollection } from "@/components/History/model/queries";
 import { useConfig } from "@/composables/config";
-
-import { buildRuleCollectionModal } from "../../adapters/buildCollectionModal";
+import { useCollectionBuilderItemSelection } from "@/stores/collectionBuilderItemsStore";
 
 import CollectionCreatorModal from "@/components/Collections/CollectionCreatorModal.vue";
 
@@ -305,6 +298,12 @@ export default {
         },
     },
     methods: {
+        listWizard(advanced) {
+            const { setSelectedItems } = useCollectionBuilderItemSelection();
+            const selection = Array.from(this.contentSelection.values());
+            setSelectedItems(selection);
+            this.$router.push({ path: `/collection/new_list?advanced=${advanced}` });
+        },
         // Selected content manipulation, hide/show/delete/purge
         hideSelected() {
             this.runOnSelection(hideSelectedContent);
@@ -374,36 +373,11 @@ export default {
         onSelectedDatatype(datatype) {
             this.selectedDatatype = datatype;
         },
-
-        // collection creation, fires up a modal
-        buildDatasetList() {
-            this.collectionModalType = "list";
-            this.collectionSelection = Array.from(this.contentSelection.values());
-            this.collectionModalShow = true;
-        },
         buildDatasetListAll() {
             this.collectionModalType = "list";
             this.collectionSelection = undefined;
             this.collectionModalShow = true;
         },
-        buildListOfPairs() {
-            this.collectionModalType = "list:paired";
-            this.collectionSelection = Array.from(this.contentSelection.values());
-            this.collectionModalShow = true;
-        },
-        createdCollection(collection) {
-            this.$emit("reset-selection");
-        },
-        async buildCollectionFromRules() {
-            const modalResult = await buildRuleCollectionModal(this.contentSelection, this.history.id);
-            await createDatasetCollection(this.history, modalResult);
-
-            // have to hide the source items if that was requested
-            if (modalResult.hide_source_items) {
-                this.$emit("hide-selection", this.contentSelection);
-            }
-            this.$emit("reset-selection");
-        },
     },
 };
 </script>
@@ -413,4 +387,10 @@ export default {
     overflow: initial;
     min-height: 300px; /* To make room for the selector */
 }
+
+.subtle-header {
+    font-size: 0.74375rem;
+    color: #404862;
+    font-weight: normal;
+}
 </style>
diff --git a/client/src/components/History/adapters/buildCollectionModal.ts b/client/src/components/History/adapters/buildCollectionModal.ts
index 53a41b424914..890d489abf4b 100644
--- a/client/src/components/History/adapters/buildCollectionModal.ts
+++ b/client/src/components/History/adapters/buildCollectionModal.ts
@@ -14,13 +14,27 @@ 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 DatasetPair = {
-    forward: HDASummary;
-    reverse: HDASummary;
+export type CollectionType =
+    | "list"
+    | "paired"
+    | "list:paired"
+    | "rules"
+    | "list:paired_or_unpaired"
+    | "list:list"
+    | "list:list:paired";
+
+interface HasName {
+    name: string | null;
+}
+
+export type GenericPair<T extends HasName> = {
+    forward: T;
+    reverse: T;
     name: string;
 };
 
+export type DatasetPair = GenericPair<HDASummary>;
+
 // stand-in for buildCollection from history-view-edit.js
 export async function buildRuleCollectionModal(
     selectedContent: HistoryItemSummary[],
diff --git a/client/src/components/History/model/queries.ts b/client/src/components/History/model/queries.ts
index 5cad0faee73e..b2f76cb1a47a 100644
--- a/client/src/components/History/model/queries.ts
+++ b/client/src/components/History/model/queries.ts
@@ -1,4 +1,5 @@
 import { type components, GalaxyApi, type HistoryItemSummary, type HistorySummary } from "@/api";
+import { createHistoryDatasetCollectionInstanceSimple } from "@/api/datasetCollections";
 import { rethrowSimple } from "@/utils/simple-error";
 
 type BulkOperation = components["schemas"]["HistoryContentItemOperation"];
@@ -86,17 +87,10 @@ export async function createDatasetCollection(history: HistorySummary, inputs =
         copy_elements: true,
         name: "list",
         element_identifiers: [],
+        fields: "auto",
         hide_source_items: true,
+        history_id: history.id,
     };
     const payload = Object.assign({}, defaults, inputs);
-
-    const { data, error } = await GalaxyApi().POST("/api/histories/{history_id}/contents", {
-        params: { path: { history_id: history.id } },
-        body: { ...payload, instance_type: "history", type: "dataset_collection" },
-    });
-
-    if (error) {
-        rethrowSimple(error);
-    }
-    return data;
+    return createHistoryDatasetCollectionInstanceSimple(payload);
 }
diff --git a/client/src/components/Panels/ToolBox.vue b/client/src/components/Panels/ToolBox.vue
index d34f8ee6f501..9e7880e29d95 100644
--- a/client/src/components/Panels/ToolBox.vue
+++ b/client/src/components/Panels/ToolBox.vue
@@ -4,9 +4,9 @@ import { faEye, faEyeSlash } from "@fortawesome/free-regular-svg-icons";
 import { FontAwesomeIcon } from "@fortawesome/vue-fontawesome";
 import { storeToRefs } from "pinia";
 import { computed, type ComputedRef, type PropType, type Ref, ref } from "vue";
-import { useRouter } from "vue-router/composables";
 
 import { useGlobalUploadModal } from "@/composables/globalUploadModal";
+import { useToolRouting } from "@/composables/route";
 import { type Tool, type ToolSection as ToolSectionType } from "@/stores/toolStore";
 import { useToolStore } from "@/stores/toolStore";
 import localize from "@/utils/localization";
@@ -19,7 +19,7 @@ import ToolSection from "./Common/ToolSection.vue";
 const SECTION_IDS_TO_EXCLUDE = ["expression_tools"]; // if this isn't the Workflow Editor panel
 
 const { openGlobalUploadModal } = useGlobalUploadModal();
-const router = useRouter();
+const { routeToTool } = useToolRouting();
 
 const emit = defineEmits<{
     (e: "update:show-advanced", showAdvanced: boolean): void;
@@ -143,8 +143,7 @@ function onToolClick(tool: Tool, evt: Event) {
         } else if (tool.form_style === "regular") {
             evt.preventDefault();
             // encode spaces in tool.id
-            const toolId = tool.id;
-            router.push(`/?tool_id=${encodeURIComponent(toolId)}&version=latest`);
+            routeToTool(tool.id);
         }
     } else {
         evt.preventDefault();
diff --git a/client/src/components/RuleBuilder/RuleGrid.vue b/client/src/components/RuleBuilder/RuleGrid.vue
new file mode 100644
index 000000000000..90921457ba18
--- /dev/null
+++ b/client/src/components/RuleBuilder/RuleGrid.vue
@@ -0,0 +1,125 @@
+<script lang="ts" setup>
+import { useResizeObserver } from "@vueuse/core";
+import { type ColDef, type IHeaderParams, type ValueGetterParams } from "ag-grid-community";
+import { computed, ref, watch } from "vue";
+
+import { useAgGrid } from "@/composables/useAgGrid";
+
+interface Props {
+    data: string[][];
+    colHeaders: string[];
+    height?: string;
+}
+
+const props = withDefaults(defineProps<Props>(), {
+    height: "500px",
+});
+
+const agGrid = ref<HTMLDivElement | null>(null);
+useResizeObserver(agGrid, () => {
+    resize();
+});
+
+// Default Column Properties
+const defaultColDef = ref<ColDef>({
+    editable: false,
+    sortable: false,
+    filter: false,
+    resizable: false, // we add columns automatically, best if this is just off right?
+    suppressMovable: true,
+});
+
+const style = computed(() => {
+    return { width: "100%", height: props.height };
+});
+
+const agColumnHeaders = computed(() => {
+    return props.colHeaders.map((header: string, index: number) => {
+        return {
+            headerName: header,
+            headerComponent: CustomHeader,
+            valueGetter: (params: ValueGetterParams) => {
+                return params.data[index];
+            },
+        };
+    });
+});
+
+// Rule builder builds column headers with HTML (mix of b and i tags),
+// this custom component renders HTML instead of text.
+class CustomHeader {
+    private eGui: HTMLElement | undefined;
+
+    init(params: IHeaderParams) {
+        this.eGui = document.createElement("div");
+        this.eGui.style.cssText = "width: 100%; text-align: center";
+        this.eGui.innerHTML = `${params.displayName}`;
+    }
+
+    getGui() {
+        return this.eGui!;
+    }
+
+    refresh(params: IHeaderParams): boolean {
+        return false;
+    }
+}
+
+// this doesn't work but the idea is to increase the column widths to fill
+// the horizontal space if they are too small after auto-sizing.
+/*
+function cleanUpColumnsIfNeeded() {
+    if(columnApi.value) {
+        const gridWidth = document.querySelector("#rules-ag-grid")?.clientWidth || 0;
+        const totalColumnWidth = (columnApi.value.getAllColumns() || []).reduce(
+            (sum: number, col: Column) => sum + (col.getActualWidth() || 0),
+            0
+        );
+        if (totalColumnWidth < gridWidth && gridApi.value) {
+            gridApi.value.sizeColumnsToFit();
+        }
+    }
+}
+*/
+
+function resize() {
+    if (columnApi.value) {
+        columnApi.value.autoSizeAllColumns();
+    }
+}
+
+const { columnApi, AgGridVue, onGridReady, resizeOnNextTick, theme } = useAgGrid(resize);
+
+watch(() => props.colHeaders, resizeOnNextTick);
+</script>
+
+<template>
+    <div :class="theme" :style="style">
+        <AgGridVue
+            id="rules-ag-grid"
+            ref="agGrid"
+            :rowData="data"
+            :columnDefs="agColumnHeaders"
+            :defaultColDef="defaultColDef"
+            :style="style"
+            :row-height="20"
+            :header-height="30"
+            :cell-selection="true"
+            @gridReady="onGridReady" />
+    </div>
+</template>
+
+<style>
+/* Reduce padding and font size for compact rows */
+.ag-theme-alpine .ag-row {
+    font-size: 12px;
+    line-height: 20px; /* Adjust line height to match rowHeight */
+    padding: 2px 5px; /* Adjust padding */
+}
+
+/* Adjust header font size and padding */
+.ag-theme-alpine .ag-header-cell-label {
+    font-size: 13px;
+    padding: 3px 5px;
+}
+</style>
diff --git a/client/src/components/RuleCollectionBuilder.vue b/client/src/components/RuleCollectionBuilder.vue
index 2b452512a9d9..9099abd30421 100644
--- a/client/src/components/RuleCollectionBuilder.vue
+++ b/client/src/components/RuleCollectionBuilder.vue
@@ -452,12 +452,20 @@
                 <!--  style="width: 70%;" -->
                 <div v-if="initialElements !== null" class="table-column" :class="orientation" style="width: 100%">
                     <HotTable
+                        v-if="gridImplementation == 'hot'"
                         id="hot-table"
                         ref="hotTable"
                         :data="hotData.data"
                         :col-headers="colHeadersDisplay"
                         :read-only="true"
                         stretch-h="all"></HotTable>
+                    <RuleGrid
+                        v-else
+                        id="hot-table"
+                        ref="hotTable"
+                        :data="hotData.data"
+                        :col-headers="colHeadersDisplay"
+                        stretch-h="all"></RuleGrid>
                 </div>
             </div>
         </RuleModalMiddle>
@@ -504,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"
@@ -545,7 +553,7 @@
                 )
             }}
         </RuleModalHeader>
-        <RuleModalFooter>
+        <RuleModalFooter v-if="mode == 'modal'">
             <b-button class="creator-cancel-btn" tabindex="-1" @click="cancel">{{ l("Close") }}</b-button>
         </RuleModalFooter>
     </StateDiv>
@@ -555,7 +563,7 @@
         <RuleModalMiddle>
             <p class="errormessagelarge">{{ errorMessage }}</p>
         </RuleModalMiddle>
-        <RuleModalFooter>
+        <RuleModalFooter v-if="mode == 'modal'">
             <b-button v-b-tooltip.hover :title="titleCancel" class="creator-cancel-btn" tabindex="-1" @click="cancel">{{
                 l("Close")
             }}</b-button>
@@ -576,6 +584,7 @@ import RegularExpressionInput from "components/RuleBuilder/RegularExpressionInpu
 import RuleDefs from "components/RuleBuilder/rule-definitions";
 import RuleComponent from "components/RuleBuilder/RuleComponent";
 import RuleDisplay from "components/RuleBuilder/RuleDisplay";
+import RuleGrid from "components/RuleBuilder/RuleGrid";
 import RuleModalFooter from "components/RuleBuilder/RuleModalFooter";
 import RuleModalHeader from "components/RuleBuilder/RuleModalHeader";
 import RuleModalMiddle from "components/RuleBuilder/RuleModalMiddle";
@@ -612,6 +621,7 @@ export default {
     components: {
         TooltipOnHover,
         HotTable,
+        RuleGrid,
         RuleComponent,
         RuleTargetComponent,
         SavedRulesSelector,
@@ -661,20 +671,32 @@ export default {
             required: false,
             default: true,
         },
-        // Callbacks sent in by modal code.
+        // Callbacks sent in by modal code, optional if mode is not modal
         oncancel: {
-            required: true,
+            required: false,
             type: Function,
+            default: null,
         },
         oncreate: {
-            required: true,
+            required: false,
             type: Function,
+            default: null,
         },
         ftpUploadSite: {
             type: String,
             required: false,
             default: null,
         },
+        gridImplementation: {
+            type: String,
+            required: false,
+            default: "aggrid",
+        },
+        mode: {
+            type: String,
+            required: false,
+            default: "modal", // set to wizard to use embedded formatting
+        },
     },
     data: function () {
         let orientation = "vertical";
@@ -1157,6 +1179,9 @@ export default {
                 }
             }
         },
+        validInput: function (newState) {
+            this.$emit("validInput", newState);
+        },
     },
     created() {
         if (this.elementsType !== "collection_contents") {
@@ -1206,9 +1231,11 @@ export default {
     mounted() {
         // something bizarre is up with the rendering of hands-on-table, needs a click to render.
         // Vue.nextTick() didn't work here.
-        setTimeout(() => {
-            this.$refs.hotTable.$el.click();
-        }, 200);
+        if (this.gridImplementation == "hot") {
+            setTimeout(() => {
+                this.$refs.hotTable.$el.click();
+            }, 200);
+        }
     },
     methods: {
         restoreRules(event) {
@@ -1346,7 +1373,11 @@ export default {
                     this.doFullJobCheck(jobId);
                 } else {
                     refreshContentsWrapper();
-                    this.oncreate();
+                    this.$emit("onCreate", jobResponse.data);
+                    if (this.oncreate) {
+                        // legacy non-event handling
+                        this.oncreate();
+                    }
                 }
             };
             const doJobCheck = () => {
@@ -1398,6 +1429,9 @@ export default {
                 });
             }
         },
+        attemptCreate() {
+            this.createCollection();
+        },
         createCollection() {
             const asJson = {
                 rules: this.rules,
@@ -1415,21 +1449,36 @@ 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();
                 if (this.state !== "error") {
                     this.saveRulesFn(this.ruleSourceJson);
-                    this.oncreate();
+                    this.$emit("onCreate");
+                    if (this.oncreate) {
+                        this.oncreate();
+                    }
                 }
             } else {
                 const Galaxy = getGalaxyInstance();
diff --git a/client/src/components/Upload/useUploadDatatypes.ts b/client/src/components/Upload/useUploadDatatypes.ts
new file mode 100644
index 000000000000..2df57a4f36ad
--- /dev/null
+++ b/client/src/components/Upload/useUploadDatatypes.ts
@@ -0,0 +1,29 @@
+import { ref } from "vue";
+
+import type { CompositeFileInfo } from "@/api/datatypes";
+import { AUTO_EXTENSION, getUploadDatatypes } from "@/components/Upload/utils";
+
+type ExtensionDetails = {
+    id: string;
+    text: string;
+    description: string | null;
+    description_url: string | null;
+    composite_files?: CompositeFileInfo[] | null;
+    upload_warning?: string | null;
+};
+
+export function useUploadDatatypes() {
+    const listExtensions = ref<ExtensionDetails[]>([]);
+    const extensionsSet = ref(false);
+
+    async function loadExtensions() {
+        listExtensions.value = await getUploadDatatypes(false, AUTO_EXTENSION);
+        extensionsSet.value = true;
+    }
+
+    return {
+        listExtensions,
+        extensionsSet,
+        loadExtensions,
+    };
+}
diff --git a/client/src/components/Workflow/Editor/Forms/FormCollectionType.vue b/client/src/components/Workflow/Editor/Forms/FormCollectionType.vue
new file mode 100644
index 000000000000..f337d2d48c5a
--- /dev/null
+++ b/client/src/components/Workflow/Editor/Forms/FormCollectionType.vue
@@ -0,0 +1,57 @@
+<script setup lang="ts">
+import { ref, watch } from "vue";
+
+import { isValidCollectionTypeStr } from "@/components/Workflow/Editor/modules/collectionTypeDescription";
+
+import FormElement from "@/components/Form/FormElement.vue";
+
+interface Props {
+    value?: string;
+}
+
+const props = defineProps<Props>();
+
+const currentValue = ref<string | undefined>(undefined);
+const warning = ref<string | null>(null);
+const error = ref<string | null>(null);
+
+function onInput(newCollectionType: string | undefined) {
+    emit("onChange", newCollectionType);
+}
+
+const collectionTypeOptions = [
+    { value: "list", label: "List of Datasets" },
+    { value: "paired", label: "Dataset Pair" },
+    { 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) {
+    currentValue.value = newValue;
+    warning.value = null;
+    error.value = null;
+    if (!newValue) {
+        warning.value = "Typically, a value for this collection type should be specified.";
+    } else if (!isValidCollectionTypeStr(newValue)) {
+        error.value = "Invalid collection type";
+    }
+}
+
+watch(() => props.value, updateValue, { immediate: true });
+const emit = defineEmits(["onChange"]);
+</script>
+
+<template>
+    <FormElement
+        id="collection_type"
+        :value="currentValue"
+        :attributes="{ datalist: collectionTypeOptions }"
+        :warning="warning"
+        :error="error"
+        title="Collection type"
+        :optional="true"
+        type="text"
+        @input="onInput" />
+</template>
diff --git a/client/src/components/Workflow/Editor/Forms/FormDatatype.vue b/client/src/components/Workflow/Editor/Forms/FormDatatype.vue
index 466a9fca75e3..cc50d02a612f 100644
--- a/client/src/components/Workflow/Editor/Forms/FormDatatype.vue
+++ b/client/src/components/Workflow/Editor/Forms/FormDatatype.vue
@@ -1,5 +1,5 @@
 <script setup lang="ts">
-import { computed } from "vue";
+import { computed, ref, watch } from "vue";
 
 import type { DatatypesMapperModel } from "@/components/Datatypes/model";
 
@@ -8,16 +8,27 @@ import FormElement from "@/components/Form/FormElement.vue";
 const props = withDefaults(
     defineProps<{
         id: string;
-        value?: string;
+        value?: string | string[];
         title: string;
         help: string;
+        multiple?: boolean;
         datatypes: DatatypesMapperModel["datatypes"];
     }>(),
     {
         value: null,
+        multiple: false,
     }
 );
 
+const currentValue = ref<string | string[] | undefined>(undefined);
+
+watch(
+    () => props.value,
+    (newValue) => {
+        currentValue.value = newValue;
+    },
+    { immediate: true }
+);
 const emit = defineEmits(["onChange"]);
 
 const datatypeExtensions = computed(() => {
@@ -34,25 +45,28 @@ const datatypeExtensions = computed(() => {
         0: "Roadmaps",
         1: "Roadmaps",
     });
-    extensions.unshift({
-        0: "Leave unchanged",
-        1: "",
-    });
+    if (!props.multiple) {
+        extensions.unshift({
+            0: "Leave unchanged",
+            1: "",
+        });
+    }
     return extensions;
 });
 
-function onChange(newDatatype: unknown) {
-    emit("onChange", newDatatype);
+function onInput(newDatatype: string) {
+    currentValue.value = newDatatype;
+    emit("onChange", currentValue.value);
 }
 </script>
 
 <template>
     <FormElement
         :id="id"
-        :value="value"
-        :attributes="{ options: datatypeExtensions }"
+        :value="currentValue"
+        :attributes="{ options: datatypeExtensions, multiple: multiple, display: 'simple', optional: true }"
         :title="title"
         type="select"
         :help="help"
-        @input="onChange" />
+        @input="onInput" />
 </template>
diff --git a/client/src/components/Workflow/Editor/Forms/FormDefault.vue b/client/src/components/Workflow/Editor/Forms/FormDefault.vue
index 3a0f82c0a9d6..a455ba3a0c5b 100644
--- a/client/src/components/Workflow/Editor/Forms/FormDefault.vue
+++ b/client/src/components/Workflow/Editor/Forms/FormDefault.vue
@@ -43,8 +43,15 @@
                 v-if="isSubworkflow"
                 :step="step"
                 @onUpdateStep="(id, step) => emit('onUpdateStep', id, step)" />
+            <FormInputCollection
+                v-if="type == 'data_collection_input'"
+                :step="step"
+                :datatypes="datatypes"
+                :inputs="configForm.inputs"
+                @onChange="onChange">
+            </FormInputCollection>
             <FormDisplay
-                v-if="configForm?.inputs"
+                v-else-if="configForm?.inputs"
                 :id="formDisplayId"
                 :key="formKey"
                 :inputs="configForm.inputs"
@@ -78,6 +85,7 @@ import FormConditional from "./FormConditional.vue";
 import FormCard from "@/components/Form/FormCard.vue";
 import FormDisplay from "@/components/Form/FormDisplay.vue";
 import FormElement from "@/components/Form/FormElement.vue";
+import FormInputCollection from "@/components/Workflow/Editor/Forms/FormInputCollection.vue";
 import FormOutputLabel from "@/components/Workflow/Editor/Forms/FormOutputLabel.vue";
 
 const props = defineProps<{
diff --git a/client/src/components/Workflow/Editor/Forms/FormFieldType.vue b/client/src/components/Workflow/Editor/Forms/FormFieldType.vue
new file mode 100644
index 000000000000..ea05ea815e22
--- /dev/null
+++ b/client/src/components/Workflow/Editor/Forms/FormFieldType.vue
@@ -0,0 +1,60 @@
+<script setup lang="ts">
+import { ref, watch } from "vue";
+
+import { type FieldType } from "@/api";
+
+import FormElement from "@/components/Form/FormElement.vue";
+
+interface Props {
+    value: FieldType;
+    prefix: string;
+}
+
+const props = defineProps<Props>();
+
+type SupportedFieldTypesAsString = "File" | "File?";
+
+function fieldTypeToSupportedString(type: FieldType): SupportedFieldTypesAsString {
+    if (Array.isArray(type) && type.length == 2) {
+        return "File?";
+    } else {
+        return "File";
+    }
+}
+
+const currentValue = ref<SupportedFieldTypesAsString>(fieldTypeToSupportedString(props.value));
+
+function onInput(newType: SupportedFieldTypesAsString) {
+    if (newType == "File?") {
+        console.log("emitting File|null");
+        emit("onChange", ["File", "null"]);
+    } else {
+        emit("onChange", "File");
+    }
+}
+
+function updateValue(newValue: FieldType) {
+    currentValue.value = fieldTypeToSupportedString(newValue);
+}
+
+const fieldTypes = [
+    { value: "File", label: "File" },
+    { value: "File?", label: "Optional File" },
+];
+
+watch(() => props.value, updateValue, { immediate: true });
+const emit = defineEmits(["onChange"]);
+</script>
+
+<template>
+    <div>
+        <FormElement
+            :id="prefix + '_type'"
+            :value="currentValue"
+            :attributes="{ data: fieldTypes }"
+            title="Field type"
+            :optional="false"
+            type="select"
+            @input="onInput" />
+    </div>
+</template>
diff --git a/client/src/components/Workflow/Editor/Forms/FormInputCollection.vue b/client/src/components/Workflow/Editor/Forms/FormInputCollection.vue
new file mode 100644
index 000000000000..ceda3e459fa5
--- /dev/null
+++ b/client/src/components/Workflow/Editor/Forms/FormInputCollection.vue
@@ -0,0 +1,130 @@
+<script setup lang="ts">
+import { computed, toRef } from "vue";
+
+import { type FieldDict } from "@/api";
+import type { DatatypesMapperModel } from "@/components/Datatypes/model";
+import type { Step } from "@/stores/workflowStepStore";
+
+import { useToolState } from "../composables/useToolState";
+
+import FormElement from "@/components/Form/FormElement.vue";
+import FormCollectionType from "@/components/Workflow/Editor/Forms/FormCollectionType.vue";
+import FormDatatype from "@/components/Workflow/Editor/Forms/FormDatatype.vue";
+import FormRecordFieldDefinitions from "@/components/Workflow/Editor/Forms/FormRecordFieldDefinitions.vue";
+
+interface ToolState {
+    collection_type: string | null;
+    optional: boolean;
+    format: string | null;
+    tag: string | null;
+    fields: FieldDict[] | null;
+}
+
+const props = defineProps<{
+    step: Step;
+    datatypes: DatatypesMapperModel["datatypes"];
+}>();
+
+function asToolState(toolState: unknown) {
+    return toolState as ToolState;
+}
+
+const stepRef = toRef(props, "step");
+const { toolState } = useToolState(stepRef);
+
+function cleanToolState(): ToolState {
+    if (toolState.value) {
+        return asToolState({ ...toolState.value });
+    } else {
+        return {
+            collection_type: null,
+            optional: false,
+            tag: null,
+            format: null,
+            fields: null,
+        };
+    }
+}
+
+const emit = defineEmits(["onChange"]);
+
+function onDatatype(newDatatype: string[]) {
+    const state = cleanToolState();
+    state.format = newDatatype.join(",");
+    emit("onChange", state);
+}
+
+function onTags(newTags: string | null) {
+    const state = cleanToolState();
+    state.tag = newTags;
+    emit("onChange", state);
+}
+
+function onOptional(newOptional: boolean) {
+    const state = cleanToolState();
+    state.optional = newOptional;
+    emit("onChange", state);
+}
+
+function onCollectionType(newCollectionType: string | null) {
+    const state = cleanToolState();
+    state.collection_type = newCollectionType;
+    emit("onChange", state);
+}
+
+function onRecordFieldDefinitions(newRecordFieldDefinitions: FieldDict[]) {
+    const state = cleanToolState();
+    state.fields = newRecordFieldDefinitions;
+    emit("onChange", state);
+}
+
+const isRecordType = computed(() => {
+    const collectionType = asToolState(toolState.value).collection_type;
+    return collectionType == "record" || collectionType == "list:record";
+});
+
+const formatsAsList = computed(() => {
+    const formatStr = toolState.value?.format as string | string[] | null;
+    if (formatStr && typeof formatStr === "string") {
+        return formatStr.split(/\s*,\s*/);
+    } else if (formatStr) {
+        return formatStr;
+    } else {
+        return [];
+    }
+});
+
+// Terrible Hack: The parent component (./FormDefault.vue) ignores the first update, so
+// I am sending a dummy update here. Ideally, the parent FormDefault would not expect this.
+emit("onChange", cleanToolState());
+</script>
+
+<template>
+    <div>
+        <FormCollectionType
+            :value="asToolState(toolState).collection_type || ''"
+            :optional="true"
+            @onChange="onCollectionType" />
+        <FormElement id="optional" :value="toolState?.optional" title="Optional" type="boolean" @input="onOptional" />
+        <FormDatatype
+            id="format"
+            :value="formatsAsList"
+            :datatypes="datatypes"
+            title="Format(s)"
+            :multiple="true"
+            help="Leave empty to auto-generate filtered list at runtime based on connections."
+            @onChange="onDatatype" />
+        <FormElement
+            id="tag"
+            :value="toolState?.tag"
+            title="Tag filter"
+            :optional="true"
+            type="text"
+            help="Tags to automatically filter inputs"
+            @input="onTags" />
+        <FormRecordFieldDefinitions
+            v-if="isRecordType"
+            :value="asToolState(toolState).fields || []"
+            @onChange="onRecordFieldDefinitions" />
+    </div>
+</template>
diff --git a/client/src/components/Workflow/Editor/Forms/FormRecordFieldDefinition.vue b/client/src/components/Workflow/Editor/Forms/FormRecordFieldDefinition.vue
new file mode 100644
index 000000000000..5b574c9fe7fe
--- /dev/null
+++ b/client/src/components/Workflow/Editor/Forms/FormRecordFieldDefinition.vue
@@ -0,0 +1,49 @@
+<script setup lang="ts">
+import { type FieldDict, type FieldType } from "@/api";
+
+import FormFieldType from "./FormFieldType.vue";
+import FormElement from "@/components/Form/FormElement.vue";
+
+interface Props {
+    value: FieldDict;
+    index: number;
+    prefix: string; // prefix for ID objects
+}
+
+const props = defineProps<Props>();
+
+const emit = defineEmits(["onChange"]);
+
+function stateCopy(): FieldDict {
+    return JSON.parse(JSON.stringify(props.value));
+}
+
+function onName(name: string) {
+    const state = stateCopy();
+    state.name = name;
+    emit("onChange", state, props.index);
+}
+
+function onType(newType: FieldType) {
+    const state = stateCopy();
+    state.type = newType;
+    emit("onChange", state, props.index);
+}
+</script>
+
+<template>
+    <div>
+        <FormElement
+            :id="prefix + '_name'"
+            :value="value.name"
+            title="Name"
+            type="text"
+            help="Provide a short, unique name to describe this field."
+            @input="onName" />
+        <FormFieldType :prefix="prefix" :value="value.type" @onChange="onType" />
+    </div>
+</template>
+
+<style lang="scss" scoped>
+@import "@/components/Form/_form-elements.scss";
+</style>
diff --git a/client/src/components/Workflow/Editor/Forms/FormRecordFieldDefinitions.vue b/client/src/components/Workflow/Editor/Forms/FormRecordFieldDefinitions.vue
new file mode 100644
index 000000000000..b21036882294
--- /dev/null
+++ b/client/src/components/Workflow/Editor/Forms/FormRecordFieldDefinitions.vue
@@ -0,0 +1,145 @@
+<script setup lang="ts">
+import { library } from "@fortawesome/fontawesome-svg-core";
+import { faCaretDown, faCaretUp, faPlus, faTrashAlt } from "@fortawesome/free-solid-svg-icons";
+import { FontAwesomeIcon } from "@fortawesome/vue-fontawesome";
+import { BLink } from "bootstrap-vue";
+import { computed } from "vue";
+
+import { type FieldDict } from "@/api";
+import localize from "@/utils/localization";
+
+import FormRecordFieldDefinition from "./FormRecordFieldDefinition.vue";
+import FormCard from "@/components/Form/FormCard.vue";
+
+library.add(faPlus, faTrashAlt, faCaretUp, faCaretDown);
+
+type FieldDefinitions = FieldDict[];
+
+interface Props {
+    value: FieldDefinitions;
+}
+
+const props = defineProps<Props>();
+
+function addField() {
+    const state = stateCopy();
+    state.push({ type: "File", name: "field" });
+    emit("onChange", state);
+}
+
+function stateCopy(): FieldDict[] {
+    return JSON.parse(JSON.stringify(props.value || []));
+}
+
+function onRemove(index: number) {
+    const state = stateCopy();
+    state.splice(index, 1);
+    emit("onChange", state);
+}
+
+function titleForFieldDefinition(index: number) {
+    return `Field ${index + 1}`;
+}
+
+function getPrefix(index: number) {
+    const name = `field_definition_${index}`;
+    return name;
+}
+
+function getButtonId(index: number, direction: "up" | "down") {
+    const prefix = getPrefix(index);
+    return `${prefix}_${direction}`;
+}
+
+function swap(index: number, swapWith: number, direction: "up" | "down") {
+    // the FormRepeat version does cool highlighting - probably worth implementing
+    // on next pass
+    const state = stateCopy();
+    if (swapWith >= 0 && swapWith < state.length && index >= 0 && index < state.length) {
+        const wasSwapped = state[swapWith] as FieldDict;
+        state[swapWith] = state[index] as FieldDict;
+        state[index] = wasSwapped;
+    }
+    emit("onChange", state);
+}
+
+function onChildUpdate(childState: FieldDict, index: number) {
+    const state = stateCopy();
+    state[index] = childState;
+    emit("onChange", state);
+}
+
+const deleteTooltip = computed(() => {
+    return localize(`Click to delete field definition`);
+});
+
+const emit = defineEmits(["onChange"]);
+</script>
+
+<template>
+    <div class="ui-form-element section-row">
+        <div class="ui-form-title">
+            <span class="ui-form-title-text">Record Fields</span>
+        </div>
+        <FormCard
+            v-for="(fieldDefinition, index) in value"
+            v-bind:key="index"
+            data-description="field definition block"
+            class="card"
+            :title="titleForFieldDefinition(index)">
+            <template v-slot:operations>
+                <!-- code modelled after FormRepeat -->
+                <span class="float-right">
+                    <b-button-group>
+                        <b-button
+                            :id="getButtonId(index, 'up')"
+                            v-b-tooltip.hover.bottom
+                            title="move up"
+                            role="button"
+                            variant="link"
+                            size="sm"
+                            class="ml-0"
+                            @click="() => swap(index, index - 1, 'up')">
+                            <FontAwesomeIcon icon="caret-up" />
+                        </b-button>
+                        <b-button
+                            :id="getButtonId(index, 'down')"
+                            v-b-tooltip.hover.bottom
+                            title="move down"
+                            role="button"
+                            variant="link"
+                            size="sm"
+                            class="ml-0"
+                            @click="() => swap(index, index + 1, 'down')">
+                            <FontAwesomeIcon icon="caret-down" />
+                        </b-button>
+                    </b-button-group>
+
+                    <span v-b-tooltip.hover.bottom :title="deleteTooltip">
+                        <b-button
+                            title="delete"
+                            role="button"
+                            variant="link"
+                            size="sm"
+                            class="ml-0"
+                            @click="() => onRemove(index)">
+                            <FontAwesomeIcon icon="trash-alt" />
+                        </b-button>
+                    </span>
+                </span>
+            </template>
+            <template v-slot:body>
+                <FormRecordFieldDefinition
+                    :index="index"
+                    :value="fieldDefinition"
+                    :prefix="getPrefix(index)"
+                    @onChange="onChildUpdate" />
+            </template>
+        </FormCard>
+        <BLink @click="addField">Add field.</BLink>
+    </div>
+</template>
+
+<style lang="scss" scoped>
+@import "../../../Form/_form-elements.scss";
+</style>
diff --git a/client/src/components/Workflow/Editor/composables/useStepProps.ts b/client/src/components/Workflow/Editor/composables/useStepProps.ts
index 95e4787bdfd9..fe63f09b3930 100644
--- a/client/src/components/Workflow/Editor/composables/useStepProps.ts
+++ b/client/src/components/Workflow/Editor/composables/useStepProps.ts
@@ -12,6 +12,7 @@ export function useStepProps(step: Ref<Step>) {
         inputs: stepInputs,
         outputs: stepOutputs,
         post_job_actions: postJobActions,
+        tool_state: toolState,
     } = toRefs(step);
 
     const label = computed(() => step.value.label ?? undefined);
@@ -29,5 +30,6 @@ export function useStepProps(step: Ref<Step>) {
         stepOutputs,
         configForm,
         postJobActions,
+        toolState,
     };
 }
diff --git a/client/src/components/Workflow/Editor/composables/useToolState.ts b/client/src/components/Workflow/Editor/composables/useToolState.ts
new file mode 100644
index 000000000000..6feb13589de9
--- /dev/null
+++ b/client/src/components/Workflow/Editor/composables/useToolState.ts
@@ -0,0 +1,40 @@
+import { toRefs } from "@vueuse/core";
+import { computed, type Ref } from "vue";
+
+import { type Step } from "@/stores/workflowStepStore";
+
+export function useToolState(step: Ref<Step>) {
+    const { tool_state: rawToolStateRef } = toRefs(step);
+
+    const toolState = computed(() => {
+        const rawToolState: Record<string, unknown> = rawToolStateRef.value;
+        const parsedToolState: Record<string, unknown> = {};
+
+        // This is less than ideal in a couple ways. The fact the JSON response
+        // has encoded JSON is gross and it would be great for module types that
+        // do not use the tool form to just return a simple JSON blob without
+        // the extra encoded. As a step two if each of these module types could
+        // also define a schema so we could use typed entities shared between the
+        // client and server that would be ideal.
+        for (const key in rawToolState) {
+            if (Object.prototype.hasOwnProperty.call(rawToolState, key)) {
+                const value = rawToolState[key];
+                if (typeof value === "string") {
+                    try {
+                        const parsedValue = JSON.parse(value);
+                        parsedToolState[key] = parsedValue;
+                    } catch (error) {
+                        parsedToolState[key] = rawToolState[key];
+                    }
+                } else {
+                    parsedToolState[key] = rawToolState[key];
+                }
+            }
+        }
+        return parsedToolState;
+    });
+
+    return {
+        toolState,
+    };
+}
diff --git a/client/src/components/Workflow/Editor/modules/collectionTypeDescription.ts b/client/src/components/Workflow/Editor/modules/collectionTypeDescription.ts
index 792a842b0df9..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);
         }
@@ -128,3 +208,13 @@ export class CollectionTypeDescription implements CollectionTypeDescriptor {
         return str.indexOf(suffix, str.length - suffix.length) !== -1;
     }
 }
+
+const collectionTypeRegex = /^(list|paired|record)(:(list|paired|record))*$/;
+
+export function isValidCollectionTypeStr(collectionType: string | undefined) {
+    if (collectionType) {
+        return collectionTypeRegex.test(collectionType);
+    } else {
+        return true;
+    }
+}
diff --git a/client/src/components/Workflow/Editor/modules/terminals.test.ts b/client/src/components/Workflow/Editor/modules/terminals.test.ts
index dcc6802ad5b9..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);
     });
@@ -175,6 +179,21 @@ describe("canAccept", () => {
         expect(dataIn.canAccept(collectionOut).canAccept).toBe(true);
         expect(dataIn.mapOver).toEqual(NULL_COLLECTION_TYPE_DESCRIPTION);
     });
+    it("accepts paired data -> data connection", () => {
+        const collectionOut = terminals["paired 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", 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 mapped over data output on mapped over data input", () => {
         const collectionOut = terminals["list input"]!["output"] as OutputCollectionTerminal;
         const dataIn = terminals["multiple simple data"]!["input1"] as InputTerminal;
@@ -194,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;
@@ -254,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;
@@ -451,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/components/Workflow/Invocation/Export/InvocationExportWizard.vue b/client/src/components/Workflow/Invocation/Export/InvocationExportWizard.vue
index 23c6d1d0c8dd..f9c6dcad3b38 100644
--- a/client/src/components/Workflow/Invocation/Export/InvocationExportWizard.vue
+++ b/client/src/components/Workflow/Invocation/Export/InvocationExportWizard.vue
@@ -4,6 +4,7 @@ import { computed, reactive, ref, watch } from "vue";
 
 import { GalaxyApi } from "@/api";
 import { useWizard } from "@/components/Common/Wizard/useWizard";
+import { borderVariant } from "@/components/Common/Wizard/utils";
 import {
     AVAILABLE_INVOCATION_EXPORT_PLUGINS,
     getInvocationExportPluginByType,
@@ -329,7 +330,7 @@ Examples of RDM repositories include [Zenodo](https://zenodo.org/), [Invenio RDM
                         :key="plugin.id"
                         :data-invocation-export-type="plugin.id"
                         class="wizard-selection-card"
-                        :border-variant="exportData.exportPluginFormat === plugin.id ? 'primary' : 'default'"
+                        :border-variant="borderVariant(exportData.exportPluginFormat)"
                         @click="exportData.exportPluginFormat = plugin.id">
                         <BCardTitle>
                             <b>{{ plugin.title }}</b>
@@ -352,7 +353,7 @@ Examples of RDM repositories include [Zenodo](https://zenodo.org/), [Invenio RDM
                         v-for="target in exportDestinationTargets"
                         :key="target.destination"
                         :data-invocation-export-destination="target.destination"
-                        :border-variant="exportData.destination === target.destination ? 'primary' : 'default'"
+                        :border-variant="borderVariant(exportData.destination === target.destination)"
                         :header-bg-variant="exportData.destination === target.destination ? 'primary' : 'default'"
                         :header-text-variant="exportData.destination === target.destination ? 'white' : 'default'"
                         :header="target.label"
diff --git a/client/src/composables/route.ts b/client/src/composables/route.ts
index d783f14a36a1..65775ac7f3b2 100644
--- a/client/src/composables/route.ts
+++ b/client/src/composables/route.ts
@@ -1,6 +1,6 @@
 import { type MaybeRefOrGetter, toValue } from "@vueuse/core";
 import { computed } from "vue";
-import { useRoute } from "vue-router/composables";
+import { useRoute, useRouter } from "vue-router/composables";
 
 /** use a route query parameter as a boolean computed */
 export function useRouteQueryBool(
@@ -26,3 +26,12 @@ export function useRouteQueryNumber(parameter: MaybeRefOrGetter<string>, default
         }
     });
 }
+
+export function useToolRouting() {
+    const router = useRouter();
+
+    function routeToTool(toolId: string) {
+        router.push(`/?tool_id=${encodeURIComponent(toolId)}&version=latest`);
+    }
+    return { routeToTool };
+}
diff --git a/client/src/composables/useAgGrid.ts b/client/src/composables/useAgGrid.ts
new file mode 100644
index 000000000000..693cbb292d76
--- /dev/null
+++ b/client/src/composables/useAgGrid.ts
@@ -0,0 +1,27 @@
+import "ag-grid-community/styles/ag-grid.min.css";
+import "ag-grid-community/styles/ag-theme-alpine.min.css";
+
+import { type ColumnApi, type GridApi, type GridReadyEvent } from "ag-grid-community";
+import { defineAsyncComponent, nextTick, ref } from "vue";
+
+export function useAgGrid(forceGridSize: () => void) {
+    const gridApi = ref<GridApi | null>(null);
+    const columnApi = ref<ColumnApi | null>(null);
+    const theme = "ag-theme-alpine";
+    function resizeOnNextTick() {
+        nextTick(forceGridSize);
+    }
+
+    function onGridReady(params: GridReadyEvent) {
+        gridApi.value = params.api;
+        columnApi.value = params.columnApi;
+        forceGridSize();
+    }
+
+    const AgGridVue = defineAsyncComponent(async () => {
+        const { AgGridVue } = await import(/* webpackChunkName: "agGrid" */ "ag-grid-vue");
+        return AgGridVue;
+    });
+
+    return { AgGridVue, gridApi, columnApi, resizeOnNextTick, onGridReady, theme };
+}
diff --git a/client/src/entry/analysis/router.js b/client/src/entry/analysis/router.js
index 033b70136cb2..6112acbc6df4 100644
--- a/client/src/entry/analysis/router.js
+++ b/client/src/entry/analysis/router.js
@@ -67,6 +67,8 @@ import { parseBool } from "@/utils/utils";
 import { patchRouterPush } from "./router-push";
 
 import AboutGalaxy from "@/components/AboutGalaxy.vue";
+import ListWizard from "@/components/Collections/ListWizard.vue";
+import RulesStandalone from "@/components/Collections/RulesStandalone.vue";
 import EditFileSourceInstance from "@/components/FileSources/Instances/EditInstance.vue";
 import ManageFileSourceIndex from "@/components/FileSources/Instances/ManageIndex.vue";
 import UpgradeFileSourceInstance from "@/components/FileSources/Instances/UpgradeInstance.vue";
@@ -213,6 +215,13 @@ export function getRouter(Galaxy) {
                         component: CustomBuilds,
                         redirect: redirectAnon(),
                     },
+                    {
+                        path: "collection/new_list",
+                        component: ListWizard,
+                        props: (route) => ({
+                            initialAdvanced: parseBool(route.query.advanced),
+                        }),
+                    },
                     {
                         path: "collection/:collectionId/edit",
                         component: CollectionEditView,
@@ -496,6 +505,16 @@ export function getRouter(Galaxy) {
                         component: TourRunner,
                         props: true,
                     },
+                    {
+                        path: "rules",
+                        component: RulesStandalone,
+                        props: (route) => {
+                            return {
+                                mode: "standalone",
+                                ...route.query,
+                            };
+                        },
+                    },
                     {
                         path: "tools/list",
                         component: ToolsList,
diff --git a/client/src/stores/activitySetup.ts b/client/src/stores/activitySetup.ts
index af494b4b0409..60e1277a224d 100644
--- a/client/src/stores/activitySetup.ts
+++ b/client/src/stores/activitySetup.ts
@@ -13,6 +13,7 @@ import {
     faList,
     faPlay,
     faSitemap,
+    faTable,
     faUpload,
     faWrench,
 } from "@fortawesome/free-solid-svg-icons";
@@ -164,6 +165,19 @@ export const defaultActivities = [
         to: "/libraries",
         visible: true,
     },
+    {
+        anonymous: true,
+        description: "Rule-based advanced import of datasets or collections.",
+        icon: faTable,
+        id: "rules",
+        mutable: false,
+        optional: true,
+        panel: false,
+        title: "Rule-based Data Import",
+        tooltip: "Launch rule-based advanced import of datasets or collections",
+        to: "/rules",
+        visible: false,
+    },
 ] as const;
 
 export function convertDropData(data: EventData): Activity | null {
diff --git a/client/src/stores/collectionBuilderItemsStore.ts b/client/src/stores/collectionBuilderItemsStore.ts
index dc5705a7b4b7..2e39344afe5f 100644
--- a/client/src/stores/collectionBuilderItemsStore.ts
+++ b/client/src/stores/collectionBuilderItemsStore.ts
@@ -1,7 +1,7 @@
 import { defineStore } from "pinia";
 import { ref, set } from "vue";
 
-import { GalaxyApi, type HDASummary } from "@/api";
+import { GalaxyApi, type HDASummary, type HistoryItemSummary } from "@/api";
 import { HistoryFilters } from "@/components/History/HistoryFilters";
 import { filtersToQueryValues } from "@/components/History/model/queries";
 import { errorMessageAsString } from "@/utils/simple-error";
@@ -76,3 +76,40 @@ export const useCollectionBuilderItemsStore = defineStore("collectionBuilderItem
         fetchDatasetsForFiltertext,
     };
 });
+
+/**
+ * Stores the history items selected for collection building.
+ */
+export const useCollectionBuilderItemSelection = defineStore("collectionBuilderItemSelection", () => {
+    const selectedItems = ref<HistoryItemSummary[]>([]);
+
+    function setSelectedItems(newSelectedItems: HistoryItemSummary[]) {
+        selectedItems.value = newSelectedItems;
+    }
+
+    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/client/src/stores/workflowStepStore.ts b/client/src/stores/workflowStepStore.ts
index dcb0547c9d7b..14fb6612d11f 100644
--- a/client/src/stores/workflowStepStore.ts
+++ b/client/src/stores/workflowStepStore.ts
@@ -1,5 +1,6 @@
 import { computed, del, ref, set } from "vue";
 
+import { type FieldDict } from "@/api";
 import { type CollectionTypeDescriptor } from "@/components/Workflow/Editor/modules/collectionTypeDescription";
 import { type Connection, getConnectionId, useConnectionStore } from "@/stores/workflowConnectionStore";
 import { assertDefined } from "@/utils/assertions";
@@ -71,6 +72,7 @@ export interface DataStepInput extends BaseStepInput {
 export interface DataCollectionStepInput extends BaseStepInput {
     input_type: "dataset_collection";
     collection_types: string[];
+    fields: FieldDict[];
 }
 
 export interface ParameterStepInput extends Omit<BaseStepInput, "input_type"> {
diff --git a/client/yarn.lock b/client/yarn.lock
index cd6c4bf5f55a..9f7eb64fc714 100644
--- a/client/yarn.lock
+++ b/client/yarn.lock
@@ -3183,6 +3183,16 @@ acorn@^8.1.0, acorn@^8.7.1, acorn@^8.8.0, acorn@^8.8.1, acorn@^8.8.2, acorn@^8.9
   resolved "https://registry.yarnpkg.com/acorn/-/acorn-8.10.0.tgz#8be5b3907a67221a81ab23c7889c4c5526b62ec5"
   integrity sha512-F0SAmZ8iUtS//m8DmCTA0jlh6TDKkHQyK6xc6V4KDTyZKA9dnvX9/3sRTVQrWm79glUAZbnmmNcdYwUIHWVybw==
 
+ag-grid-community@^30:
+  version "30.2.1"
+  resolved "https://registry.yarnpkg.com/ag-grid-community/-/ag-grid-community-30.2.1.tgz#a83d153ad1dbec46402ebe89f74ebb4b0710b3c7"
+  integrity sha512-1slonXskJbbI9ybhTx//4YKfJpZVAEnHL8dui1rQJRSXKByUi+/f7XtvkLsbgBkawoWbqvRAySjYtvz80+kBfA==
+
+ag-grid-vue@^30:
+  version "30.2.1"
+  resolved "https://registry.yarnpkg.com/ag-grid-vue/-/ag-grid-vue-30.2.1.tgz#56395cf053ca2df70107123cf589618ddc3f84b3"
+  integrity sha512-dnyltXrVUPk0ALQ1PfwnjBtYk/GDOjRjyOMy8LVAiWxVQA6Tmnb/dTnS1yjym1uggu+dDKof2zgPxVKayIHtWg==
+
 agent-base@6:
   version "6.0.2"
   resolved "https://registry.npmjs.org/agent-base/-/agent-base-6.0.2.tgz"
@@ -12355,6 +12365,11 @@ vinyl@^2.0.0:
     remove-trailing-separator "^1.0.1"
     replace-ext "^1.0.0"
 
+vue-class-component@^7.2.6:
+  version "7.2.6"
+  resolved "https://registry.yarnpkg.com/vue-class-component/-/vue-class-component-7.2.6.tgz#8471e037b8e4762f5a464686e19e5afc708502e4"
+  integrity sha512-+eaQXVrAm/LldalI272PpDe3+i4mPis0ORiMYxF6Ae4hyuCh15W8Idet7wPUEs4N4YptgFHGys4UrgNQOMyO6w==
+
 vue-demi@>=0.14.5, vue-demi@>=0.14.6:
   version "0.14.6"
   resolved "https://registry.yarnpkg.com/vue-demi/-/vue-demi-0.14.6.tgz#dc706582851dc1cdc17a0054f4fec2eb6df74c92"
@@ -12446,6 +12461,11 @@ vue-prismjs@^1.2.0:
   dependencies:
     prismjs "^1.6.0"
 
+vue-property-decorator@^9.1.2:
+  version "9.1.2"
+  resolved "https://registry.yarnpkg.com/vue-property-decorator/-/vue-property-decorator-9.1.2.tgz#266a2eac61ba6527e2e68a6933cfb98fddab5457"
+  integrity sha512-xYA8MkZynPBGd/w5QFJ2d/NM0z/YeegMqYTphy7NJQXbZcuU6FC6AOdUAcy4SXP+YnkerC6AfH+ldg7PDk9ESQ==
+
 vue-router@^3.6.5:
   version "3.6.5"
   resolved "https://registry.yarnpkg.com/vue-router/-/vue-router-3.6.5.tgz#95847d52b9a7e3f1361cb605c8e6441f202afad8"
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/jobs/__init__.py b/lib/galaxy/jobs/__init__.py
index ddfb5f01102f..65fd233a6919 100644
--- a/lib/galaxy/jobs/__init__.py
+++ b/lib/galaxy/jobs/__init__.py
@@ -1778,8 +1778,9 @@ def _finish_dataset(
                 dataset.mark_unhidden()
         elif not purged:
             # If the tool was expected to set the extension, attempt to retrieve it
-            if dataset.ext == "auto":
-                dataset.extension = context.get("ext", "data")
+            context_ext = context.get("ext", "data")
+            if dataset.ext == "auto" or (dataset.ext == "data" and context_ext != "data"):
+                dataset.extension = context_ext
                 dataset.init_meta(copy_from=dataset)
             # if a dataset was copied, it won't appear in our dictionary:
             # either use the metadata from originating output dataset, or call set_meta on the copies
diff --git a/lib/galaxy/managers/collections.py b/lib/galaxy/managers/collections.py
index fae6d0563347..e9042e3aac55 100644
--- a/lib/galaxy/managers/collections.py
+++ b/lib/galaxy/managers/collections.py
@@ -175,6 +175,7 @@ def create(
         flush=True,
         completed_job=None,
         output_name=None,
+        fields=None,
     ):
         """
         PRECONDITION: security checks on ability to add to parent
@@ -199,6 +200,7 @@ def create(
                 hide_source_items=hide_source_items,
                 copy_elements=copy_elements,
                 history=history,
+                fields=fields,
             )
 
         implicit_inputs = []
@@ -285,17 +287,20 @@ def create_dataset_collection(
         hide_source_items=None,
         copy_elements=False,
         history=None,
+        fields=None,
     ):
         # Make sure at least one of these is None.
         assert element_identifiers is None or elements is None
-
         if element_identifiers is None and elements is None:
             raise RequestParameterInvalidException(ERROR_INVALID_ELEMENTS_SPECIFICATION)
         if not collection_type:
             raise RequestParameterInvalidException(ERROR_NO_COLLECTION_TYPE)
 
-        collection_type_description = self.collection_type_descriptions.for_collection_type(collection_type)
+        collection_type_description = self.collection_type_descriptions.for_collection_type(
+            collection_type, fields=fields
+        )
         has_subcollections = collection_type_description.has_subcollections()
+
         # If we have elements, this is an internal request, don't need to load
         # objects from identifiers.
         if elements is None:
@@ -319,8 +324,9 @@ def create_dataset_collection(
 
         if elements is not self.ELEMENTS_UNINITIALIZED:
             type_plugin = collection_type_description.rank_type_plugin()
-            dataset_collection = builder.build_collection(type_plugin, elements)
+            dataset_collection = builder.build_collection(type_plugin, elements, fields=fields)
         else:
+            # TODO: Pass fields here - need test case first.
             dataset_collection = model.DatasetCollection(populated=False)
         dataset_collection.collection_type = collection_type
         return dataset_collection
diff --git a/lib/galaxy/managers/collections_util.py b/lib/galaxy/managers/collections_util.py
index 32feab23889d..7f129992c754 100644
--- a/lib/galaxy/managers/collections_util.py
+++ b/lib/galaxy/managers/collections_util.py
@@ -39,6 +39,7 @@ def api_payload_to_create_params(payload):
         name=payload.get("name", None),
         hide_source_items=string_as_bool(payload.get("hide_source_items", False)),
         copy_elements=string_as_bool(payload.get("copy_elements", False)),
+        fields=payload.get("fields", None),
     )
     return params
 
diff --git a/lib/galaxy/model/__init__.py b/lib/galaxy/model/__init__.py
index 1ec69bab1c74..e4c270e5fceb 100644
--- a/lib/galaxy/model/__init__.py
+++ b/lib/galaxy/model/__init__.py
@@ -1769,8 +1769,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)
@@ -1785,12 +1785,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):
@@ -2413,11 +2415,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[Optional[Dict[str, Any]]] = mapped_column(JSONType, nullable=True)
     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
@@ -2454,12 +2458,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[Optional[Dict[str, Any]]] = mapped_column(JSONType, nullable=True)
     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):
@@ -2471,12 +2477,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[Optional[Dict[str, Any]]] = mapped_column(JSONType, nullable=True)
     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
@@ -6516,6 +6524,7 @@ class DatasetCollection(Base, Dictifiable, UsesAnnotations, Serializable):
     element_count: Mapped[Optional[int]]
     create_time: Mapped[datetime] = mapped_column(default=now, nullable=True)
     update_time: Mapped[datetime] = mapped_column(default=now, onupdate=now, nullable=True)
+    fields: Mapped[Optional[bytes]] = mapped_column(JSONType, nullable=True)
 
     elements: Mapped[List["DatasetCollectionElement"]] = relationship(
         primaryjoin=(lambda: DatasetCollection.id == DatasetCollectionElement.dataset_collection_id),
@@ -6528,12 +6537,21 @@ class DatasetCollection(Base, Dictifiable, UsesAnnotations, Serializable):
 
     populated_states = DatasetCollectionPopulatedState
 
-    def __init__(self, id=None, collection_type=None, populated=True, element_count=None):
+    def __init__(
+        self,
+        id=None,
+        collection_type=None,
+        populated=True,
+        element_count=None,
+        fields=None,
+    ):
         self.id = id
         self.collection_type = collection_type
         if not populated:
             self.populated_state = DatasetCollection.populated_states.NEW
         self.element_count = element_count
+        # TODO: persist fields...
+        self.fields = fields
 
     def _build_nested_collection_attributes_stmt(
         self,
@@ -6708,6 +6726,10 @@ def populated_optimized(self):
 
         return self._populated_optimized
 
+    @property
+    def allow_implicit_mapping(self):
+        return self.collection_type != "record"
+
     @property
     def populated(self):
         top_level_populated = self.populated_state == DatasetCollection.populated_states.OK
diff --git a/lib/galaxy/model/dataset_collections/adapters.py b/lib/galaxy/model/dataset_collections/adapters.py
new file mode 100644
index 000000000000..bf5c3236bc6c
--- /dev/null
+++ b/lib/galaxy/model/dataset_collections/adapters.py
@@ -0,0 +1,289 @@
+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):
+        # 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
+
+    @property
+    def collection_type(self) -> str:
+        raise NotImplementedError()
+
+
+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
+
+    @property
+    def _adapting_src_dict(self):
+        return {
+            "src": "dce",
+            "id": self._dce.id,
+        }
+
+
+class PromoteCollectionElementToCollectionAdapter(DCECollectionAdapter):
+    # allow a singleton list element to act as paired_or_unpaired collection
+
+    def to_adapter_model(self) -> AdaptedDataCollectionPromoteCollectionElementToCollectionRequestInternal:
+        adapting_model = DatasetCollectionElementReference.model_validate(self._adapting_src_dict)
+        return AdaptedDataCollectionPromoteCollectionElementToCollectionRequestInternal(
+            src="CollectionAdapter",
+            adapter_type="PromoteCollectionElementToCollection",
+            adapting=adapting_model,
+        )
+
+    @property
+    def collection_type(self) -> str:
+        return "paired_or_unpaired"
+
+
+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) -> AdaptedDataCollectionPromoteDatasetToCollectionRequestInternal:
+        adapting = {
+            "src": "hda",
+            "id": self._hda.id,
+        }
+        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
+
+    @property
+    def collection_type(self) -> str:
+        return self._collection_type
+
+
+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) -> 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
+
+    @property
+    def collection_type(self) -> str:
+        return self._collection_type
+
+
+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/builder.py b/lib/galaxy/model/dataset_collections/builder.py
index 2ae001f33a22..c4ea2f518102 100644
--- a/lib/galaxy/model/dataset_collections/builder.py
+++ b/lib/galaxy/model/dataset_collections/builder.py
@@ -1,28 +1,37 @@
+from typing import (
+    Any,
+    Dict,
+    List,
+)
+
 from galaxy import model
 from galaxy.model.orm.util import add_object_to_object_session
+from galaxy.schema.schema import FieldDict
 from galaxy.util.oset import OrderedSet
 from .type_description import COLLECTION_TYPE_DESCRIPTION_FACTORY
 
 
-def build_collection(type, dataset_instances, collection=None, associated_identifiers=None):
+def build_collection(type, dataset_instances, collection=None, associated_identifiers=None, fields=None):
     """
     Build DatasetCollection with populated DatasetcollectionElement objects
     corresponding to the supplied dataset instances or throw exception if
     this is not a valid collection of the specified type.
     """
-    dataset_collection = collection or model.DatasetCollection()
+    dataset_collection = collection or model.DatasetCollection(fields=fields)
     associated_identifiers = associated_identifiers or set()
-    set_collection_elements(dataset_collection, type, dataset_instances, associated_identifiers)
+    set_collection_elements(dataset_collection, type, dataset_instances, associated_identifiers, fields=fields)
     return dataset_collection
 
 
-def set_collection_elements(dataset_collection, type, dataset_instances, associated_identifiers):
+def set_collection_elements(dataset_collection, type, dataset_instances, associated_identifiers, fields=None):
     new_element_keys = OrderedSet(dataset_instances.keys()) - associated_identifiers
     new_dataset_instances = {k: dataset_instances[k] for k in new_element_keys}
     dataset_collection.element_count = dataset_collection.element_count or 0
     element_index = dataset_collection.element_count
     elements = []
-    for element in type.generate_elements(new_dataset_instances):
+    if type.collection_type == "record" and fields == "auto":
+        fields = guess_fields(dataset_instances)
+    for element in type.generate_elements(new_dataset_instances, fields=fields):
         element.element_index = element_index
         add_object_to_object_session(element, dataset_collection)
         element.collection = dataset_collection
@@ -35,6 +44,16 @@ def set_collection_elements(dataset_collection, type, dataset_instances, associa
     return dataset_collection
 
 
+def guess_fields(dataset_instances: Dict[str, Any]) -> List[FieldDict]:
+    fields: List[FieldDict] = []
+    for identifier, element in dataset_instances.items():
+        # TODO: Make generic enough to handle nested record types.
+        assert element.history_content_type == "dataset"
+        fields.append({"type": "File", "name": identifier})
+
+    return fields
+
+
 class CollectionBuilder:
     """Purely functional builder pattern for building a dataset collection."""
 
diff --git a/lib/galaxy/model/dataset_collections/registry.py b/lib/galaxy/model/dataset_collections/registry.py
index 9c849dfdad6f..ed75294f68e7 100644
--- a/lib/galaxy/model/dataset_collections/registry.py
+++ b/lib/galaxy/model/dataset_collections/registry.py
@@ -2,9 +2,16 @@
 from .types import (
     list,
     paired,
+    paired_or_unpaired,
+    record,
 )
 
-PLUGIN_CLASSES = [list.ListDatasetCollectionType, paired.PairedDatasetCollectionType]
+PLUGIN_CLASSES = [
+    list.ListDatasetCollectionType,
+    paired.PairedDatasetCollectionType,
+    record.RecordDatasetCollectionType,
+    paired_or_unpaired.PairedOrUnpairedDatasetCollectionType,
+]
 
 
 class DatasetCollectionTypesRegistry:
@@ -14,13 +21,13 @@ def __init__(self):
     def get(self, plugin_type):
         return self.__plugins[plugin_type]
 
-    def prototype(self, plugin_type):
+    def prototype(self, plugin_type, fields=None):
         plugin_type_object = self.get(plugin_type)
         if not hasattr(plugin_type_object, "prototype_elements"):
             raise Exception(f"Cannot pre-determine structure for collection of type {plugin_type}")
 
         dataset_collection = model.DatasetCollection()
-        for e in plugin_type_object.prototype_elements():
+        for e in plugin_type_object.prototype_elements(fields=fields):
             e.collection = dataset_collection
         return dataset_collection
 
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 cade102453ca..0c93e746b41a 100644
--- a/lib/galaxy/model/dataset_collections/type_description.py
+++ b/lib/galaxy/model/dataset_collections/type_description.py
@@ -9,50 +9,27 @@ def __init__(self, type_registry=DATASET_COLLECTION_TYPES_REGISTRY):
         # I think.
         self.type_registry = type_registry
 
-    def for_collection_type(self, collection_type):
+    def for_collection_type(self, collection_type, fields=None):
         assert collection_type is not None
-        return CollectionTypeDescription(collection_type, self)
+        return CollectionTypeDescription(collection_type, self, fields=fields)
 
 
 class CollectionTypeDescription:
     """Abstraction over dataset collection type that ties together string
-    reprentation in database/model with type registry.
-
-    >>> factory = CollectionTypeDescriptionFactory(None)
-    >>> nested_type_description = factory.for_collection_type("list:paired")
-    >>> paired_type_description = factory.for_collection_type("paired")
-    >>> nested_type_description.has_subcollections_of_type("list")
-    False
-    >>> nested_type_description.has_subcollections_of_type("list:paired")
-    False
-    >>> nested_type_description.has_subcollections_of_type("paired")
-    True
-    >>> nested_type_description.has_subcollections_of_type(paired_type_description)
-    True
-    >>> nested_type_description.has_subcollections()
-    True
-    >>> paired_type_description.has_subcollections()
-    False
-    >>> paired_type_description.rank_collection_type()
-    'paired'
-    >>> nested_type_description.rank_collection_type()
-    'list'
-    >>> nested_type_description.effective_collection_type(paired_type_description)
-    'list'
-    >>> nested_type_description.effective_collection_type_description(paired_type_description).collection_type
-    'list'
-    >>> nested_type_description.child_collection_type()
-    'paired'
+    representation in database/model with type registry.
     """
 
     collection_type: str
 
-    def __init__(self, collection_type: Union[str, "CollectionTypeDescription"], collection_type_description_factory):
+    def __init__(
+        self, collection_type: Union[str, "CollectionTypeDescription"], collection_type_description_factory, fields=None
+    ):
         if isinstance(collection_type, CollectionTypeDescription):
             self.collection_type = collection_type.collection_type
         else:
             self.collection_type = collection_type
         self.collection_type_description_factory = collection_type_description_factory
+        self.fields = fields
         self.__has_subcollections = self.collection_type.find(":") > 0
 
     def child_collection_type(self):
@@ -74,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.
@@ -88,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 bfcf7bae79a6..30eee0489d58 100644
--- a/lib/galaxy/model/dataset_collections/types/__init__.py
+++ b/lib/galaxy/model/dataset_collections/types/__init__.py
@@ -11,7 +11,7 @@
 
 class DatasetCollectionType(metaclass=ABCMeta):
     @abstractmethod
-    def generate_elements(self, dataset_instances):
+    def generate_elements(self, dataset_instances: dict, **kwds):
         """Generate DatasetCollectionElements with corresponding
         to the supplied dataset instances or throw exception if
         this is not a valid collection of the specified type.
@@ -21,3 +21,11 @@ def generate_elements(self, dataset_instances):
 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
new file mode 100644
index 000000000000..2b7155a2026a
--- /dev/null
+++ b/lib/galaxy/model/dataset_collections/types/collection_semantics.yml
@@ -0,0 +1,548 @@
+- doc: |
+    # 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.
+
+- example:
+    label: BASIC_MAPPING_PAIRED
+    assumptions:
+    - 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_map_over_data_with_paired_or_unpaired_paired
+        workflow_editor: "accepts paired_or_unpaired data -> data connection"
+
+- example:
+    label: BASIC_MAPPING_LIST
+    assumptions:
+    - 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"
+        workflow_editor: "accepts collection data -> data connection"
+
+- doc: |
+    The above description of mapping over inputs works naturally and as expected for
+    nested collections.
+
+- 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_tool_execute::test_map_over_data_with_list_paired_or_unpaired"
+        workflow_editor: "accepts list:paired_or_unpaired data -> data connection"
+
+- doc: |
+
+    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.
+
+- example:
+    label: BASIC_MAPPING_INCLUDING_SINGLE_DATASET
+    assumptions:
+    - 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
+    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.
+
+- example:
+    label: BASIC_MAPPING_TWO_INPUTS_WITH_IDENTICAL_STRUCTURE
+    assumptions:
+    - 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
+
+- 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.
+
+    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.
+
+- example:
+    label: COLLECTION_INPUT_PAIRED
+    assumptions:
+    - 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:
+        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" and does not result in implicit collection creation.
+
+- example:
+    label: LIST_REDUCTION
+    assumptions:
+    - 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_subcollection_mapping"
+        workflow_editor: "accepts list:paired -> paired connection"
+
+- doc: |
+    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:
+    - 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:
+        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/list.py b/lib/galaxy/model/dataset_collections/types/list.py
index 18ce4db76537..d4421d009c34 100644
--- a/lib/galaxy/model/dataset_collections/types/list.py
+++ b/lib/galaxy/model/dataset_collections/types/list.py
@@ -7,8 +7,8 @@ class ListDatasetCollectionType(BaseDatasetCollectionType):
 
     collection_type = "list"
 
-    def generate_elements(self, elements):
-        for identifier, element in elements.items():
+    def generate_elements(self, dataset_instances, **kwds):
+        for identifier, element in dataset_instances.items():
             association = DatasetCollectionElement(
                 element=element,
                 element_identifier=identifier,
diff --git a/lib/galaxy/model/dataset_collections/types/paired.py b/lib/galaxy/model/dataset_collections/types/paired.py
index 4ae95a1442a2..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,
@@ -15,21 +16,27 @@ class PairedDatasetCollectionType(BaseDatasetCollectionType):
 
     collection_type = "paired"
 
-    def generate_elements(self, elements):
-        if forward_dataset := elements.get(FORWARD_IDENTIFIER):
+    def generate_elements(self, dataset_instances, **kwds):
+        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 := elements.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,
             )
             yield right_association
 
-    def prototype_elements(self):
+    def prototype_elements(self, **kwds):
         left_association = DatasetCollectionElement(
             element=HistoryDatasetAssociation(),
             element_identifier=FORWARD_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/record.py b/lib/galaxy/model/dataset_collections/types/record.py
new file mode 100644
index 000000000000..193509f439ee
--- /dev/null
+++ b/lib/galaxy/model/dataset_collections/types/record.py
@@ -0,0 +1,45 @@
+from galaxy.exceptions import RequestParameterMissingException
+from galaxy.model import (
+    DatasetCollectionElement,
+    HistoryDatasetAssociation,
+)
+from ..types import BaseDatasetCollectionType
+
+
+class RecordDatasetCollectionType(BaseDatasetCollectionType):
+    """Arbitrary CWL-style record type."""
+
+    collection_type = "record"
+
+    def generate_elements(self, dataset_instances, **kwds):
+        fields = kwds.get("fields", None)
+        if fields is None:
+            raise RequestParameterMissingException("Missing or null parameter 'fields' required for record types.")
+        if len(dataset_instances) != len(fields):
+            self._validation_failed("Supplied element do not match fields.")
+        index = 0
+        for identifier, element in dataset_instances.items():
+            field = fields[index]
+            if field["name"] != identifier:
+                self._validation_failed("Supplied element do not match fields.")
+
+            # TODO: validate type and such.
+            association = DatasetCollectionElement(
+                element=element,
+                element_identifier=identifier,
+            )
+            yield association
+            index += 1
+
+    def prototype_elements(self, fields=None, **kwds):
+        if fields is None:
+            raise RequestParameterMissingException("Missing or null parameter 'fields' required for record types.")
+        for field in fields:
+            name = field.get("name", None)
+            assert name
+            assert field.get("type", "File")  # NS: this assert doesn't make sense as it is
+            field_dataset = DatasetCollectionElement(
+                element=HistoryDatasetAssociation(),
+                element_identifier=name,
+            )
+            yield field_dataset
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..402ea198f760
--- /dev/null
+++ b/lib/galaxy/model/dataset_collections/types/semantics.py
@@ -0,0 +1,211 @@
+#!/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)
+
+    if current_doc:
+        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/model/migrations/alembic/versions_gxy/ec25b23b08e2_implement_fixed_length_collections.py b/lib/galaxy/model/migrations/alembic/versions_gxy/ec25b23b08e2_implement_fixed_length_collections.py
new file mode 100644
index 000000000000..8eac0946d1b4
--- /dev/null
+++ b/lib/galaxy/model/migrations/alembic/versions_gxy/ec25b23b08e2_implement_fixed_length_collections.py
@@ -0,0 +1,46 @@
+"""Implement fixed length collection types.
+
+Revision ID: ec25b23b08e2
+Revises: 75348cfb3715
+Create Date: 2024-12-09 10:28:54.902847
+
+"""
+
+from sqlalchemy import Column
+
+from galaxy.model.custom_types import JSONType
+from galaxy.model.migrations.util import (
+    add_column,
+    drop_column,
+    transaction,
+)
+
+# revision identifiers, used by Alembic.
+revision = "ec25b23b08e2"
+down_revision = "75348cfb3715"
+branch_labels = None
+depends_on = None
+
+dataset_collection_element_table = "dataset_collection_element"
+dataset_collection_table = "dataset_collection"
+job_to_input_dataset_table = "job_to_input_dataset"
+job_to_input_dataset_collection_table = "job_to_input_dataset_collection"
+job_to_input_dataset_collection_element_table = "job_to_input_dataset_collection_element"
+
+
+def upgrade():
+    with transaction():
+        add_column(dataset_collection_table, Column("fields", JSONType(), default=None))
+
+        add_column(job_to_input_dataset_table, Column("adapter", JSONType(), default=None))
+        add_column(job_to_input_dataset_collection_table, Column("adapter", JSONType(), default=None))
+        add_column(job_to_input_dataset_collection_element_table, Column("adapter", JSONType(), default=None))
+
+
+def downgrade():
+    with transaction():
+        drop_column(dataset_collection_table, "fields")
+
+        drop_column(job_to_input_dataset_table, "adapter")
+        drop_column(job_to_input_dataset_collection_table, "adapter")
+        drop_column(job_to_input_dataset_collection_element_table, "adapter")
diff --git a/lib/galaxy/schema/schema.py b/lib/galaxy/schema/schema.py
index 25b13cd4c0eb..fa464dd99e3b 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
@@ -1647,6 +1649,18 @@ class CollectionElementIdentifier(Model):
     )
 
 
+# For fields... just implementing a subset of CWL for Galaxy flavors of these objects
+# so far.
+CwlType = Literal["File", "null", "boolean", "int", "float", "string"]
+FieldType = Union[CwlType, List[CwlType]]
+
+
+class FieldDict(TypedDict):
+    name: str
+    type: FieldType
+    format: NotRequired[Optional[str]]
+
+
 class CreateNewCollectionPayload(Model):
     collection_type: Optional[CollectionType] = OptionalCollectionTypeField
     element_identifiers: Optional[List[CollectionElementIdentifier]] = Field(
@@ -1682,6 +1696,11 @@ class CreateNewCollectionPayload(Model):
         default=None,
         description="The ID of the library folder that will contain the collection. Required if `instance_type=library`.",
     )
+    fields_: Optional[Union[str, List[FieldDict]]] = Field(
+        default=[],
+        description="List of fields to create for this collection. Set to 'auto' to guess fields from identifiers.",
+        alias="fields",
+    )
 
 
 class ModelStoreFormat(str, Enum):
diff --git a/lib/galaxy/tool_util/parameters/models.py b/lib/galaxy/tool_util/parameters/models.py
index 1feae64168f2..9c6219680398 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,80 @@ 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)  # type:ignore[var-annotated]
+
+
+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
+)  # type:ignore[var-annotated]
+
+
 class DataCollectionParameterModel(BaseGalaxyToolParameterModelDefinition):
     parameter_type: Literal["gx_data_collection"] = "gx_data_collection"
     collection_type: Optional[str] = None
diff --git a/lib/galaxy/tool_util/parser/interface.py b/lib/galaxy/tool_util/parser/interface.py
index af72bf4a4825..ed819ee99aad 100644
--- a/lib/galaxy/tool_util/parser/interface.py
+++ b/lib/galaxy/tool_util/parser/interface.py
@@ -26,6 +26,7 @@
     TypedDict,
 )
 
+from galaxy.schema.schema import FieldDict
 from galaxy.util import Element
 from galaxy.util.path import safe_walk
 from .parameter_validators import AnyValidatorModel
@@ -595,7 +596,8 @@ class TestCollectionDefElementInternal(TypedDict):
 class XmlTestCollectionDefDict(TypedDict):
     model_class: Literal["TestCollectionDef"]
     attributes: TestCollectionAttributeDict
-    collection_type: CollectionType
+    collection_type: Optional[CollectionType]
+    fields: Optional[List[FieldDict]]
     elements: List[TestCollectionDefElementDict]
     name: str
 
@@ -635,7 +637,7 @@ class XmlTestCollectionDefDict(TypedDict):
     "BaseJsonTestCollectionDefCollectionElementDict",
     {
         "class": Literal["Collection"],
-        "collection_type": str,
+        "collection_type": Optional[str],
         "elements": NotRequired[Optional[List[JsonTestCollectionDefElementDict]]],
     },
 )
@@ -644,7 +646,7 @@ class XmlTestCollectionDefDict(TypedDict):
     {
         "identifier": str,
         "class": Literal["Collection"],
-        "collection_type": str,
+        "collection_type": Optional[str],
         "elements": NotRequired[Optional[List[JsonTestCollectionDefElementDict]]],
     },
 )
@@ -652,7 +654,7 @@ class XmlTestCollectionDefDict(TypedDict):
     "JsonTestCollectionDefDict",
     {
         "class": Literal["Collection"],
-        "collection_type": str,
+        "collection_type": Optional[str],
         "elements": NotRequired[Optional[List[JsonTestCollectionDefElementDict]]],
         "name": NotRequired[Optional[str]],
     },
@@ -692,12 +694,17 @@ def _copy_if_exists(attributes, as_dict, name: str, as_name: Optional[str] = Non
 class TestCollectionDef:
     __test__ = False  # Prevent pytest from discovering this class (issue #12071)
     elements: List[TestCollectionDefElementInternal]
+    collection_type: Optional[str]
+    fields: Optional[List[FieldDict]]
 
-    def __init__(self, attrib, name, collection_type, elements):
+    def __init__(
+        self, attrib, name, collection_type: Optional[str], elements, fields: Optional[List[FieldDict]] = None
+    ):
         self.attrib = attrib
         self.collection_type = collection_type
         self.elements = elements
         self.name = name
+        self.fields = fields
 
     def _test_format_to_dict(self) -> "BaseJsonTestCollectionDefCollectionElementDict":
 
@@ -754,6 +761,7 @@ def element_to_dict(element_dict):
             "collection_type": self.collection_type,
             "elements": list(map(element_to_dict, self.elements or [])),
             "name": self.name,
+            "fields": self.fields,
         }
 
     @staticmethod
@@ -777,6 +785,7 @@ def element_from_dict(element_dict) -> TestCollectionDefElementInternal:
                 name=xml_as_dict.get("name", "Unnamed Collection"),
                 elements=list(map(element_from_dict, xml_as_dict["elements"] or [])),
                 collection_type=xml_as_dict["collection_type"],
+                fields=xml_as_dict.get("fields", None),
             )
         else:
             json_as_dict = cast(JsonTestCollectionDefDict, as_dict)
diff --git a/lib/galaxy/tool_util/parser/output_objects.py b/lib/galaxy/tool_util/parser/output_objects.py
index 63148c1fb946..7825d6308197 100644
--- a/lib/galaxy/tool_util/parser/output_objects.py
+++ b/lib/galaxy/tool_util/parser/output_objects.py
@@ -402,12 +402,14 @@ def __init__(
         collection_type_from_rules: Optional[str] = None,
         structured_like: Optional[str] = None,
         dataset_collector_descriptions: Optional[List[DatasetCollectionDescription]] = None,
+        fields=None,
     ) -> None:
         self.collection_type = collection_type
         self.collection_type_source = collection_type_source
         self.collection_type_from_rules = collection_type_from_rules
         self.structured_like = structured_like
         self.dataset_collector_descriptions = dataset_collector_descriptions or []
+        self.fields = fields
         if collection_type and collection_type_source:
             raise ValueError("Cannot set both type and type_source on collection output.")
         if (
@@ -424,6 +426,10 @@ def __init__(
             raise ValueError(
                 "Cannot specify dynamic structure (discover_datasets) and collection type attributes structured_like or collection_type_from_rules."
             )
+        if collection_type == "record" and fields is None:
+            raise ValueError("If record outputs are defined, fields must be defined as well.")
+        if fields is not None and collection_type != "record":
+            raise ValueError("If fields are specified for outputs, the collection type must be record.")
         self.dynamic = bool(dataset_collector_descriptions)
 
     def collection_prototype(self, inputs, type_registry):
@@ -433,7 +439,7 @@ def collection_prototype(self, inputs, type_registry):
         else:
             collection_type = self.collection_type
             assert collection_type
-            collection_prototype = type_registry.prototype(collection_type)
+            collection_prototype = type_registry.prototype(collection_type, fields=self.fields)
             collection_prototype.collection_type = collection_type
         return collection_prototype
 
diff --git a/lib/galaxy/tool_util/parser/xml.py b/lib/galaxy/tool_util/parser/xml.py
index 863a316e45df..a35e2fd71b5a 100644
--- a/lib/galaxy/tool_util/parser/xml.py
+++ b/lib/galaxy/tool_util/parser/xml.py
@@ -1030,13 +1030,18 @@ def _test_collection_def_dict(elem: Element) -> XmlTestCollectionDefDict:
         else:
             element_definition = __parse_param_elem(element)
         elements.append({"element_identifier": element_identifier, "element_definition": element_definition})
-
+    fields_json = "null"
+    fields_el = elem.find("fields")
+    if fields_el is not None:
+        fields_json = fields_el.text or "null"
+    fields = json.loads(fields_json)
     return XmlTestCollectionDefDict(
         model_class="TestCollectionDef",
         attributes=attrib,
         collection_type=collection_type,
         elements=elements,
         name=name,
+        fields=fields,
     )
 
 
diff --git a/lib/galaxy/tool_util/verify/interactor.py b/lib/galaxy/tool_util/verify/interactor.py
index 2a112b7cc162..421ad3769009 100644
--- a/lib/galaxy/tool_util/verify/interactor.py
+++ b/lib/galaxy/tool_util/verify/interactor.py
@@ -658,6 +658,8 @@ def _create_collection(self, history_id, collection_def):
             collection_type=collection_def.collection_type,
             history_id=history_id,
         )
+        if collection_def.fields:
+            create_payload["fields"] = collection_def.fields
         return self._post("dataset_collections", data=create_payload, json=True).json()["id"]
 
     def _element_identifiers(self, collection_def):
diff --git a/lib/galaxy/tools/__init__.py b/lib/galaxy/tools/__init__.py
index bb62f87e05d5..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
@@ -3549,7 +3606,7 @@ def produce_outputs(self, trans, out_data, output_collections, incoming, history
             collection = has_collection.collection
 
         collection_type = collection.collection_type
-        assert collection_type in ["list", "paired"]
+        assert collection_type in ["list", "paired", "record"]
         how = incoming["which"]["which_dataset"]
         if how == "first":
             extracted_element = collection.first_dataset_element
diff --git a/lib/galaxy/tools/actions/__init__.py b/lib/galaxy/tools/actions/__init__.py
index 841eea988d49..0b59f2d0b61f 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,14 +267,19 @@ 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
 
+                assert collection
                 action_tuples = collection.dataset_action_tuples
                 if not trans.user_is_admin and not trans.app.security_agent.can_access_datasets(
                     current_user_roles, action_tuples
@@ -679,7 +686,10 @@ def handle_output(name, output, hidden=None):
                         assert not element_identifiers  # known_outputs must have been empty
                         element_kwds = dict(elements=collections_manager.ELEMENTS_UNINITIALIZED)
                     else:
-                        element_kwds = dict(element_identifiers=element_identifiers)
+                        element_kwds = dict(
+                            element_identifiers=element_identifiers,
+                            fields=output.structure.fields,
+                        )
                     output_collections.create_collection(
                         output=output, name=name, completed_job=completed_job, **element_kwds
                     )
@@ -932,6 +942,26 @@ 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).
+                    adapting = adapter.adapting
+                    adapter_model = cast(BaseModel, adapter.to_adapter_model())
+                    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/extract_dataset.xml b/lib/galaxy/tools/extract_dataset.xml
index 37986eb722f9..5c7ece160abe 100644
--- a/lib/galaxy/tools/extract_dataset.xml
+++ b/lib/galaxy/tools/extract_dataset.xml
@@ -10,7 +10,7 @@
     <edam_operation>operation_3695</edam_operation>
   </edam_operations>
   <inputs>
-    <param type="data_collection" collection_type="list,paired" name="input" label="Input List" />
+    <param type="data_collection" collection_type="list,paired,record" name="input" label="Input List" />
     <conditional name="which">
       <param name="which_dataset" type="select" label="How should a dataset be selected?">
         <option value="first">The first dataset</option>
@@ -73,6 +73,18 @@ This tool will create new history datasets from your collection but your quota u
         <metadata name="name" value="foo" />
       </output>
     </test>
+    <test>
+      <param name="input">
+        <collection type="record">
+          <fields>[{"name": "parent", "type": "File"}, {"name": "child", "type": "File"}]</fields>
+          <element name="parent" value="simple_line.txt" />
+          <element name="child" value="simple_line_alternative.txt" />
+        </collection>
+      </param>
+      <output name="output" file="simple_line.txt">
+        <metadata name="name" value="parent" />
+      </output>
+    </test>
     <test>
       <conditional name="which">
         <param name="which_dataset" value="by_identifier" />
diff --git a/lib/galaxy/tools/parameters/basic.py b/lib/galaxy/tools/parameters/basic.py
index b578739ccdb9..66eb2a16cdcf 100644
--- a/lib/galaxy/tools/parameters/basic.py
+++ b/lib/galaxy/tools/parameters/basic.py
@@ -13,6 +13,7 @@
 from collections.abc import MutableMapping
 from typing import (
     Any,
+    cast,
     Dict,
     List,
     Optional,
@@ -40,6 +41,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,14 +2020,38 @@ def do_validate(v):
                 raise ValueError(f"At most {self.max} datasets are required for {self.name}")
 
 
-def src_id_to_item(
-    sa_session: "Session", value: typing.MutableMapping[str, Any], security: "IdEncodingHelper"
-) -> Union[
+ItemFromSrcAny = Union[
     DatasetCollectionElement,
     HistoryDatasetAssociation,
     HistoryDatasetCollectionAssociation,
     LibraryDatasetDatasetAssociation,
-]:
+    CollectionAdapter,
+]
+ItemFromSrcCollection = Union[
+    DatasetCollectionElement,
+    HistoryDatasetCollectionAssociation,
+    CollectionAdapter,
+]
+
+
+def src_id_to_item(
+    sa_session: "Session", value: typing.MutableMapping[str, Any], security: "IdEncodingHelper"
+) -> ItemFromSrcAny:
+    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,
+                    cast(HistoryDatasetAssociation, 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,
@@ -2035,10 +2066,21 @@ 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
 
 
+def src_id_to_item_collection(
+    sa_session: "Session", value: typing.MutableMapping[str, Any], security: "IdEncodingHelper"
+) -> ItemFromSrcCollection:
+    rval = src_id_to_item(sa_session, value, security)
+    if isinstance(rval, (LibraryDatasetDatasetAssociation, HistoryDatasetAssociation)):
+        raise ValueError("Expected to find collection, but got single dataset wrapper")
+    return cast(ItemFromSrcCollection, rval)
+
+
 class DataToolParameter(BaseDataToolParameter):
     # TODO, Nate: Make sure the following unit tests appropriately test the dataset security
     # components.  Add as many additional tests as necessary.
@@ -2126,6 +2168,7 @@ def from_json(self, value, trans, other_values=None):
                 HistoryDatasetAssociation,
                 HistoryDatasetCollectionAssociation,
                 LibraryDatasetDatasetAssociation,
+                CollectionAdapter,
             ]
         ] = []
         if isinstance(value, list):
@@ -2465,7 +2508,7 @@ def from_json(self, value, trans, other_values=None):
         session = trans.sa_session
 
         other_values = other_values or {}
-        rval: Optional[Union[DatasetCollectionElement, HistoryDatasetCollectionAssociation]] = None
+        rval: Optional[ItemFromSrcCollection] = None
         if trans.workflow_building_mode is workflow_building_modes.ENABLED:
             return None
         if not value and not self.optional and not self.default_object:
@@ -2485,9 +2528,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_collection(sa_session=trans.sa_session, value=value, security=trans.security)
         elif isinstance(value, list):
             if len(value) > 0:
                 value = value[0]
@@ -2579,6 +2627,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)"
@@ -2809,13 +2863,19 @@ 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
+        return collection_adapter.to_adapter_model().dict()
     if isinstance(value, MutableMapping) and "src" in value and "id" in value:
         return value
     elif isinstance(value, DatasetCollectionElement):
@@ -2831,4 +2891,5 @@ 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}
+        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..b20d0da83e0c 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) -> Optional["DatasetCollectionElementWrapper"]:
+        return self[0]
+
     @property
     def is_input_supplied(self) -> bool:
         return self.__input_supplied
diff --git a/lib/galaxy/webapps/galaxy/api/workflows.py b/lib/galaxy/webapps/galaxy/api/workflows.py
index b52d495d40e6..e82dc623497a 100644
--- a/lib/galaxy/webapps/galaxy/api/workflows.py
+++ b/lib/galaxy/webapps/galaxy/api/workflows.py
@@ -528,15 +528,22 @@ def build_module(self, trans: GalaxyWebTransaction, payload=None):
         # payload is tool state
         if payload is None:
             payload = {}
+        module_type = payload.get("type", "tool")
         inputs = payload.get("inputs", {})
         trans.workflow_building_mode = workflow_building_modes.ENABLED
-        module = module_factory.from_dict(trans, payload, from_tool_form=True)
-
+        from_tool_form = True if module_type != "data_collection_input" else False
+        if not from_tool_form and "tool_state" not in payload and "inputs" in payload:
+            # tool state not sent, use the manually constructed inputs
+            payload["tool_state"] = payload["inputs"]
+        module = module_factory.from_dict(trans, payload, from_tool_form=from_tool_form)
         module_state: Dict[str, Any] = {}
         errors: ParameterValidationErrorsT = {}
-        populate_state(trans, module.get_inputs(), inputs, module_state, errors=errors, check=True)
-        module.recover_state(module_state, from_tool_form=True)
-        module.check_and_update_state()
+        if from_tool_form:
+            populate_state(trans, module.get_inputs(), inputs, module_state, errors=errors, check=True)
+            module.recover_state(module_state, from_tool_form=True)
+            module.check_and_update_state()
+        else:
+            module_state = module.get_export_state()
         step_dict = {
             "name": module.get_name(),
             "tool_state": module_state,
@@ -546,7 +553,7 @@ def build_module(self, trans: GalaxyWebTransaction, payload=None):
             "config_form": module.get_config_form(),
             "errors": errors or None,
         }
-        if payload["type"] == "tool":
+        if module_type == "tool":
             step_dict["tool_version"] = module.get_version()
         return step_dict
 
diff --git a/lib/galaxy/webapps/galaxy/buildapp.py b/lib/galaxy/webapps/galaxy/buildapp.py
index 9c1f9de277e6..5918834bd6d6 100644
--- a/lib/galaxy/webapps/galaxy/buildapp.py
+++ b/lib/galaxy/webapps/galaxy/buildapp.py
@@ -282,8 +282,10 @@ def app_pair(global_conf, load_app_kwds=None, wsgi_preflight=True, **kwargs):
     webapp.add_client_route("/datasets/{dataset_id}/preview")
     webapp.add_client_route("/datasets/{dataset_id}/show_params")
     webapp.add_client_route("/collection/{collection_id}/edit")
+    webapp.add_client_route("/collection/new_list")
     webapp.add_client_route("/jobs/submission/success")
     webapp.add_client_route("/jobs/{job_id}/view")
+    webapp.add_client_route("/rules")
     webapp.add_client_route("/wizard")
     webapp.add_client_route("/workflows/list")
     webapp.add_client_route("/workflows/list_published")
diff --git a/lib/galaxy/webapps/galaxy/services/dataset_collections.py b/lib/galaxy/webapps/galaxy/services/dataset_collections.py
index e37335d829f0..2c21909e095d 100644
--- a/lib/galaxy/webapps/galaxy/services/dataset_collections.py
+++ b/lib/galaxy/webapps/galaxy/services/dataset_collections.py
@@ -122,7 +122,7 @@ def create(self, trans: ProvidesHistoryContext, payload: CreateNewCollectionPayl
         :returns:   element view of new dataset collection
         """
         # TODO: Error handling...
-        create_params = api_payload_to_create_params(payload.dict(exclude_unset=True))
+        create_params = api_payload_to_create_params(payload.dict(exclude_unset=True, by_alias=True))
         if payload.instance_type == "history":
             if payload.history_id is None:
                 raise exceptions.RequestParameterInvalidException("Parameter history_id is required.")
diff --git a/lib/galaxy/workflow/modules.py b/lib/galaxy/workflow/modules.py
index 08d65f6206cc..2fa2e31e6a3b 100644
--- a/lib/galaxy/workflow/modules.py
+++ b/lib/galaxy/workflow/modules.py
@@ -547,7 +547,7 @@ def _find_collections_to_match(self, progress: "WorkflowProgress", step, all_inp
         for input_dict in all_inputs:
             name = input_dict["name"]
             data = progress.replacement_for_input(self.trans, step, input_dict)
-            can_map_over = hasattr(data, "collection")  # and data.collection.allow_implicit_mapping
+            can_map_over = hasattr(data, "collection") and data.collection.allow_implicit_mapping
 
             if not can_map_over:
                 continue
@@ -1110,34 +1110,8 @@ class InputDataCollectionModule(InputModule):
     collection_type = default_collection_type
 
     def get_inputs(self):
-        parameter_def = self._parse_state_into_dict()
-        collection_type = parameter_def["collection_type"]
-        tag = parameter_def["tag"]
-        optional = parameter_def["optional"]
-        collection_type_source = dict(
-            name="collection_type", label="Collection type", type="text", value=collection_type
-        )
-        collection_type_source["options"] = [
-            {"value": "list", "label": "List of Datasets"},
-            {"value": "paired", "label": "Dataset Pair"},
-            {"value": "list:paired", "label": "List of Dataset Pairs"},
-        ]
-        input_collection_type = TextToolParameter(None, collection_type_source)
-        tag_source = dict(
-            name="tag",
-            label="Tag filter",
-            type="text",
-            optional="true",
-            value=tag,
-            help="Tags to automatically filter inputs",
-        )
-        input_tag = TextToolParameter(None, tag_source)
-        inputs = {}
-        inputs["collection_type"] = input_collection_type
-        inputs["optional"] = optional_param(optional)
-        inputs["format"] = format_param(self.trans, parameter_def.get("format"))
-        inputs["tag"] = input_tag
-        return inputs
+        # migrated to frontend
+        return {}
 
     def get_runtime_inputs(self, step, connections: Optional[Iterable[WorkflowStepConnection]] = None):
         parameter_def = self._parse_state_into_dict()
@@ -1182,6 +1156,12 @@ def _parse_state_into_dict(self):
         else:
             collection_type = self.default_collection_type
         state_as_dict["collection_type"] = collection_type
+        if "fields" in inputs:
+            fields = inputs["fields"]
+        else:
+            fields = None
+        state_as_dict["collection_type"] = collection_type
+        state_as_dict["fields"] = fields
         return state_as_dict
 
 
diff --git a/lib/galaxy_test/api/test_dataset_collections.py b/lib/galaxy_test/api/test_dataset_collections.py
index d7710c57b2fa..d2b3e416f5a2 100644
--- a/lib/galaxy_test/api/test_dataset_collections.py
+++ b/lib/galaxy_test/api/test_dataset_collections.py
@@ -1,3 +1,4 @@
+import json
 import zipfile
 from io import BytesIO
 from typing import List
@@ -100,6 +101,125 @@ 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"),
+            ("control1", "4\t5\t6"),
+            ("control2", "7\t8\t9"),
+        ]
+        record_identifiers = self.dataset_collection_populator.list_identifiers(history_id, contents)
+        fields = [
+            {"name": "condition", "type": "File"},
+            {"name": "control1", "type": "File"},
+            {"name": "control2", "type": "File"},
+        ]
+        payload = dict(
+            name="a record",
+            instance_type="history",
+            history_id=history_id,
+            element_identifiers=record_identifiers,
+            collection_type="record",
+            fields=fields,
+        )
+        create_response = self._post("dataset_collections", payload, json=True)
+        dataset_collection = self._check_create_response(create_response)
+        assert dataset_collection["collection_type"] == "record"
+        assert dataset_collection["name"] == "a record"
+        returned_collections = dataset_collection["elements"]
+        assert len(returned_collections) == 3, dataset_collection
+        record_pos_0_element = returned_collections[0]
+        self._assert_has_keys(record_pos_0_element, "element_index")
+        record_pos_0_object = record_pos_0_element["object"]
+        self._assert_has_keys(record_pos_0_object, "name", "history_content_type")
+
+    def test_record_requires_fields(self, history_id):
+        contents = [
+            ("condition", "1\t2\t3"),
+            ("control1", "4\t5\t6"),
+            ("control2", "7\t8\t9"),
+        ]
+        record_identifiers = self.dataset_collection_populator.list_identifiers(history_id, contents)
+        payload = dict(
+            name="a record",
+            instance_type="history",
+            history_id=history_id,
+            element_identifiers=json.dumps(record_identifiers),
+            collection_type="record",
+        )
+        create_response = self._post("dataset_collections", payload)
+        self._assert_status_code_is(create_response, 400)
+
+    def test_record_auto_fields(self, history_id):
+        contents = [
+            ("condition", "1\t2\t3"),
+            ("control1", "4\t5\t6"),
+            ("control2", "7\t8\t9"),
+        ]
+        record_identifiers = self.dataset_collection_populator.list_identifiers(history_id, contents)
+        payload = dict(
+            name="a record",
+            instance_type="history",
+            history_id=history_id,
+            element_identifiers=record_identifiers,
+            collection_type="record",
+            fields="auto",
+        )
+        create_response = self._post("dataset_collections", payload, json=True)
+        self._check_create_response(create_response)
+
+    def test_record_field_validation(self, history_id):
+        contents = [
+            ("condition", "1\t2\t3"),
+            ("control1", "4\t5\t6"),
+            ("control2", "7\t8\t9"),
+        ]
+        record_identifiers = self.dataset_collection_populator.list_identifiers(history_id, contents)
+        too_few_fields = [
+            {"name": "condition", "type": "File"},
+            {"name": "control1", "type": "File"},
+        ]
+        too_many_fields = [
+            {"name": "condition", "type": "File"},
+            {"name": "control1", "type": "File"},
+            {"name": "control2", "type": "File"},
+            {"name": "control3", "type": "File"},
+        ]
+        wrong_name_fields = [
+            {"name": "condition", "type": "File"},
+            {"name": "control1", "type": "File"},
+            {"name": "control3", "type": "File"},
+        ]
+        for fields in [too_few_fields, too_many_fields, wrong_name_fields]:
+            payload = dict(
+                name="a record",
+                instance_type="history",
+                history_id=history_id,
+                element_identifiers=json.dumps(record_identifiers),
+                collection_type="record",
+                fields=json.dumps(fields),
+            )
+            create_response = self._post("dataset_collections", payload)
+            self._assert_status_code_is(create_response, 400)
+
     def test_list_download(self):
         with self.dataset_populator.test_history(require_new=False) as history_id:
             fetch_response = self.dataset_collection_populator.create_list_in_history(
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/collection_record_test_two_files.xml b/test/functional/tools/collection_record_test_two_files.xml
new file mode 100644
index 000000000000..ae69549fe006
--- /dev/null
+++ b/test/functional/tools/collection_record_test_two_files.xml
@@ -0,0 +1,32 @@
+<tool id="collection_record_test_two_files" name="collection_record_test_two_files" version="0.1.0">
+  <command>
+    cat $f1.parent $f1['child'] >> $out1;
+    echo 'Collection name: $f1.name'
+  </command>
+  <inputs>
+    <param name="f1" type="data_collection" collection_type="record" label="Input collection" />
+  </inputs>
+  <outputs>
+    <data format="txt" name="out1" />
+  </outputs>
+  <tests>
+    <test>
+      <param name="f1">
+        <collection type="record" name="collection name">
+          <fields>[{"name": "parent", "type": "File"}, {"name": "child", "type": "File"}]</fields>
+          <element name="parent" value="simple_line.txt" />
+          <element name="child" 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="Collection name: collection name" />
+      </assert_stdout>
+    </test>
+  </tests>
+</tool>
diff --git a/test/functional/tools/sample_tool_conf.xml b/test/functional/tools/sample_tool_conf.xml
index 0918d7dc92b4..e5d947904626 100644
--- a/test/functional/tools/sample_tool_conf.xml
+++ b/test/functional/tools/sample_tool_conf.xml
@@ -212,6 +212,9 @@
   <tool file="collection_creates_dynamic_nested_fail.xml" />
   <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" />
@@ -319,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 a7bb1985569c..93c7fd4a8c7d 100644
--- a/test/unit/data/dataset_collections/test_matching.py
+++ b/test/unit/data/dataset_collections/test_matching.py
@@ -17,14 +17,7 @@ def test_lists_of_same_cardinality_match():
 
 
 def test_nested_lists_match():
-    nested_list = list_instance(
-        elements=[
-            pair_element("data1"),
-            pair_element("data2"),
-            pair_element("data3"),
-        ],
-        collection_type="list:paired",
-    )
+    nested_list = list_paired_instance()
     assert_can_match(nested_list, nested_list)
 
 
@@ -55,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)
@@ -86,6 +92,19 @@ def pair_element(element_identifier):
     return collection_element(element_identifier, pair_instance().collection)
 
 
+def list_element(element_identifier, list_collection=None):
+    return collection_element(element_identifier, list_collection or list_instance().collection)
+
+
+def list_of_lists_instance():
+    return list_instance(
+        elements=[
+            list_element("outer1"),
+            list_element("outer2"),
+        ]
+    )
+
+
 def pair_instance():
     paired_collection_instance = collection_instance(
         collection_type="paired",
@@ -97,6 +116,55 @@ def pair_instance():
     return paired_collection_instance
 
 
+def list_paired_instance():
+    return list_instance(
+        elements=[
+            pair_element("data1"),
+            pair_element("data2"),
+            pair_element("data3"),
+        ],
+        collection_type="list:paired",
+    )
+
+
+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
new file mode 100644
index 000000000000..438c6c1c3690
--- /dev/null
+++ b/test/unit/data/dataset_collections/test_structure.py
@@ -0,0 +1,74 @@
+from galaxy.model.dataset_collections.structure import get_structure
+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,
+)
+
+factory = CollectionTypeDescriptionFactory(None)
+
+
+def test_get_structure_simple():
+    paired_type_description = factory.for_collection_type("paired")
+    tree = get_structure(pair_instance(), paired_type_description)
+    assert len(tree.children) == 2
+    assert tree.children[0][0] == "left"  # why not forward?
+    assert tree.children[0][1].is_leaf
+
+
+def test_get_structure_list_paired_over_paired():
+    paired_type_description = factory.for_collection_type("list:paired")
+    tree = get_structure(list_paired_instance(), paired_type_description, "paired")
+    assert tree.collection_type_description.collection_type == "list"
+    assert len(tree.children) == 3
+    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)
+    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
+
+
+def test_get_structure_list_of_lists_over_list():
+    list_of_lists_type_description = factory.for_collection_type("list:list")
+    tree = get_structure(list_of_lists_instance(), list_of_lists_type_description, "list")
+    assert tree.collection_type_description.collection_type == "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
new file mode 100644
index 000000000000..abea57c5bcde
--- /dev/null
+++ b/test/unit/data/dataset_collections/test_type_descriptions.py
@@ -0,0 +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():
+    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"
+
+
+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")
diff --git a/test/unit/tool_util/test_test_definition_parsing.py b/test/unit/tool_util/test_test_definition_parsing.py
index ed5fbdaaee91..77cda95c737b 100644
--- a/test/unit/tool_util/test_test_definition_parsing.py
+++ b/test/unit/tool_util/test_test_definition_parsing.py
@@ -58,6 +58,13 @@
 BIGWIG_TO_WIG_EXPECTATIONS = [
     (["inputs", "chrom"], "chr21"),
 ]
+RECORD_TWO_FILES_EXPECTATIONS = [
+    (["inputs", "f1", "model_class"], "TestCollectionDef"),
+    (["inputs", "f1", "collection_type"], "record"),
+    (["inputs", "f1", "fields", 0, "type"], "File"),
+    (["inputs", "f1", "fields", 0, "name"], "parent"),
+    (["inputs", "f1", "fields", 1, "type"], "File"),
+]
 
 
 class TestTestParsing(TestCase):
@@ -118,6 +125,12 @@ def test_unqualified_access_disabled_in_24_2(self):
         test_0 = test_dicts[0].to_dict()
         assert test_0["error"] is True
 
+    def test_field_collection_inputs(self):
+        self._init_tool_for_path(functional_test_tool_path("collection_record_test_two_files.xml"))
+        test_dicts = self._parse_tests()
+        test_0 = test_dicts[0].to_dict()
+        self._verify_each(test_0, RECORD_TWO_FILES_EXPECTATIONS)
+
     def test_bigwigtowig_converter(self):
         # defines
         if in_packages():
diff --git a/test/unit/workflows/test_modules.py b/test/unit/workflows/test_modules.py
index d2e40b88138f..83c3f597818e 100644
--- a/test/unit/workflows/test_modules.py
+++ b/test/unit/workflows/test_modules.py
@@ -126,17 +126,6 @@ def test_data_collection_input_connections():
     assert output["collection_type"] == "list:paired"
 
 
-def test_data_collection_input_config_form():
-    module = __from_step(
-        type="data_collection_input",
-        tool_inputs={
-            "collection_type": "list:paired",
-        },
-    )
-    result = module.get_config_form()
-    assert result["inputs"][0]["value"], "list:paired"
-
-
 def test_cannot_create_tool_modules_for_missing_tools():
     trans = MockTrans()
     module = modules.module_factory.from_dict(trans, {"type": "tool", "tool_id": "cat1"})