diff --git a/src/components/DataBrowser.vue b/src/components/DataBrowser.vue
index 1de1cd27..954e84c4 100644
--- a/src/components/DataBrowser.vue
+++ b/src/components/DataBrowser.vue
@@ -1,5 +1,6 @@
 <script lang="ts">
 import { computed, defineComponent, ref, watch } from 'vue';
+import { isRegularImage } from '@/src/utils/dataSelection';
 import SampleDataBrowser from './SampleDataBrowser.vue';
 import { useDicomWebStore } from '../store/dicom-web/dicom-web-store';
 import ImageDataBrowser from './ImageDataBrowser.vue';
@@ -42,9 +43,7 @@ export default defineComponent({
     );
 
     const hasAnonymousImages = computed(
-      () =>
-        imageStore.idList.filter((id) => !(id in dicomStore.imageIDToVolumeKey))
-          .length > 0
+      () => imageStore.idList.filter((id) => isRegularImage(id)).length > 0
     );
 
     const panels = ref<string[]>([SAMPLE_DATA_KEY, DICOM_WEB_KEY]);
diff --git a/src/components/DicomQuickInfoButton.vue b/src/components/DicomQuickInfoButton.vue
index eb88e6f1..123e90cb 100644
--- a/src/components/DicomQuickInfoButton.vue
+++ b/src/components/DicomQuickInfoButton.vue
@@ -1,6 +1,7 @@
 <script setup lang="ts">
 import { useDICOMStore } from '@/src/store/datasets-dicom';
 import { Maybe } from '@/src/types';
+import { isDicomImage } from '@/src/utils/dataSelection';
 import { computed, toRef } from 'vue';
 
 interface Props {
@@ -12,8 +13,8 @@ const imageId = toRef(props, 'imageId');
 
 const dicomStore = useDICOMStore();
 const dicomInfo = computed(() => {
-  if (imageId.value != null && imageId.value in dicomStore.imageIDToVolumeKey) {
-    const volumeKey = dicomStore.imageIDToVolumeKey[imageId.value];
+  const volumeKey = imageId.value;
+  if (volumeKey && isDicomImage(volumeKey)) {
     const volumeInfo = dicomStore.volumeInfo[volumeKey];
     const studyKey = dicomStore.volumeStudy[volumeKey];
     const studyInfo = dicomStore.studyInfo[studyKey];
diff --git a/src/components/ImageDataBrowser.vue b/src/components/ImageDataBrowser.vue
index 50df1e74..14d5ce14 100644
--- a/src/components/ImageDataBrowser.vue
+++ b/src/components/ImageDataBrowser.vue
@@ -6,12 +6,11 @@ import ImageListCard from '@/src/components/ImageListCard.vue';
 import { createVTKImageThumbnailer } from '@/src/core/thumbnailers/vtk-image';
 import { useSegmentGroupStore } from '@/src/store/segmentGroups';
 import {
-  DataSelection,
-  ImageSelection,
+  isRegularImage,
+  type DataSelection,
   selectionEquals,
 } from '@/src/utils/dataSelection';
 import { useImageStore } from '../store/datasets-images';
-import { useDICOMStore } from '../store/datasets-dicom';
 import { useDatasetStore } from '../store/datasets';
 
 import { useMultiSelection } from '../composables/useMultiSelection';
@@ -29,7 +28,6 @@ export default defineComponent({
   },
   setup() {
     const imageStore = useImageStore();
-    const dicomStore = useDICOMStore();
     const dataStore = useDatasetStore();
     const layersStore = useLayersStore();
     const segmentGroupStore = useSegmentGroupStore();
@@ -37,7 +35,7 @@ export default defineComponent({
     const primarySelection = computed(() => dataStore.primarySelection);
 
     const nonDICOMImages = computed(() =>
-      imageStore.idList.filter((id) => !(id in dicomStore.imageIDToVolumeKey))
+      imageStore.idList.filter((id) => isRegularImage(id))
     );
 
     const images = computed(() => {
@@ -45,23 +43,17 @@ export default defineComponent({
 
       const layerImages = layersStore
         .getLayers(primarySelection.value)
-        .filter(({ selection }) => selection.type === 'image');
-      const layerImageIDs = layerImages.map(
-        ({ selection }) => (selection as ImageSelection).dataID
-      );
+        .filter(({ selection }) => isRegularImage(selection));
+      const layerImageIDs = layerImages.map(({ selection }) => selection);
       const loadedLayerImageIDs = layerImages
         .filter(({ id }) => id in layersStore.layerImages)
-        .map(({ selection }) => (selection as ImageSelection).dataID);
+        .map(({ selection }) => selection);
 
       const selectedImageID =
-        primarySelection.value?.type === 'image' &&
-        primarySelection.value?.dataID;
+        isRegularImage(primarySelection.value) && primarySelection.value;
 
       return nonDICOMImages.value.map((id) => {
-        const selectionKey = {
-          type: 'image',
-          dataID: id,
-        } as DataSelection;
+        const selectionKey = id as DataSelection;
         const isLayer = layerImageIDs.includes(id);
         const layerLoaded = loadedLayerImageIDs.includes(id);
         const layerLoading = isLayer && !layerLoaded;
@@ -136,10 +128,7 @@ export default defineComponent({
 
     function convertToLabelMap(key: string) {
       if (primarySelection.value) {
-        segmentGroupStore.convertImageToLabelmap(
-          { type: 'image', dataID: key },
-          primarySelection.value
-        );
+        segmentGroupStore.convertImageToLabelmap(key, primarySelection.value);
       }
     }
 
@@ -261,9 +250,9 @@ export default defineComponent({
                       image.layerable ? convertToLabelMap(image.id) : null
                     "
                   >
-                    <v-icon v-if="!image.layerable" class="mr-1"
-                      >mdi-alert</v-icon
-                    >
+                    <v-icon v-if="!image.layerable" class="mr-1">
+                      mdi-alert
+                    </v-icon>
                     Convert to Segment Group
                     <v-tooltip
                       activator="parent"
diff --git a/src/components/LayerProperties.vue b/src/components/LayerProperties.vue
index b574d674..6e17b10b 100644
--- a/src/components/LayerProperties.vue
+++ b/src/components/LayerProperties.vue
@@ -1,6 +1,5 @@
 <script lang="ts">
 import { computed, defineComponent, PropType, toRefs } from 'vue';
-import { getImageID } from '@/src/utils/dataSelection';
 import { InitViewSpecs } from '../config';
 import { useImageStore } from '../store/datasets-images';
 import { BlendConfig } from '../types/views';
@@ -25,9 +24,7 @@ export default defineComponent({
 
     const imageName = computed(() => {
       const { selection } = props.layer;
-      const imageID = getImageID(selection);
-      if (imageID === undefined) throw new Error('imageID is undefined');
-      return imageStore.metadata[imageID].name;
+      return imageStore.metadata[selection].name;
     });
 
     const layerColoringStore = useLayerColoringStore();
diff --git a/src/components/PatientBrowser.vue b/src/components/PatientBrowser.vue
index f788df58..ab830c0f 100644
--- a/src/components/PatientBrowser.vue
+++ b/src/components/PatientBrowser.vue
@@ -1,7 +1,7 @@
 <script lang="ts">
 import { computed, defineComponent, ref, toRefs, watch } from 'vue';
 import ItemGroup from '@/src/components/ItemGroup.vue';
-import { DataSelection, selectionEquals } from '@/src/utils/dataSelection';
+import { type DataSelection, selectionEquals } from '@/src/utils/dataSelection';
 import { useDICOMStore } from '../store/datasets-dicom';
 import { useDatasetStore } from '../store/datasets';
 import { useMultiSelection } from '../composables/useMultiSelection';
diff --git a/src/components/PatientStudyVolumeBrowser.vue b/src/components/PatientStudyVolumeBrowser.vue
index 1fba59c1..ffed6b9b 100644
--- a/src/components/PatientStudyVolumeBrowser.vue
+++ b/src/components/PatientStudyVolumeBrowser.vue
@@ -3,7 +3,7 @@ import { computed, defineComponent, reactive, toRefs, watch } from 'vue';
 import { Image } from 'itk-wasm';
 import type { PropType } from 'vue';
 import GroupableItem from '@/src/components/GroupableItem.vue';
-import { DataSelection, DICOMSelection } from '@/src/utils/dataSelection';
+import { DataSelection, isDicomImage } from '@/src/utils/dataSelection';
 import { getDisplayName, useDICOMStore } from '../store/datasets-dicom';
 import { useDatasetStore } from '../store/datasets';
 import { useMultiSelection } from '../composables/useMultiSelection';
@@ -78,21 +78,16 @@ export default defineComponent({
       const primarySelection = primarySelectionRef.value;
       const layerVolumes = layersStore
         .getLayers(primarySelection)
-        .filter(({ selection }) => selection.type === 'dicom');
-      const layerVolumeKeys = layerVolumes.map(
-        ({ selection }) => (selection as DICOMSelection).volumeKey
-      );
+        .filter(({ selection }) => isDicomImage(selection));
+      const layerVolumeKeys = layerVolumes.map(({ selection }) => selection);
       const loadedLayerVolumeKeys = layerVolumes
         .filter(({ id }) => id in layersStore.layerImages)
-        .map(({ selection }) => (selection as DICOMSelection).volumeKey);
+        .map(({ selection }) => selection);
       const selectedVolumeKey =
-        primarySelection?.type === 'dicom' && primarySelection.volumeKey;
+        isDicomImage(primarySelection) && primarySelection;
 
       return volumeKeys.value.map((volumeKey) => {
-        const selectionKey = {
-          type: 'dicom',
-          volumeKey,
-        } as DataSelection;
+        const selectionKey = volumeKey as DataSelection;
         const isLayer = layerVolumeKeys.includes(volumeKey);
         const layerLoaded = loadedLayerVolumeKeys.includes(volumeKey);
         const layerLoading = isLayer && !layerLoaded;
diff --git a/src/components/SliceViewer.vue b/src/components/SliceViewer.vue
index 6a20efb3..19b937e4 100644
--- a/src/components/SliceViewer.vue
+++ b/src/components/SliceViewer.vue
@@ -177,6 +177,7 @@ import VtkMouseInteractionManipulator from '@/src/components/vtk/VtkMouseInterac
 import vtkMouseCameraTrackballPanManipulator from '@kitware/vtk.js/Interaction/Manipulators/MouseCameraTrackballPanManipulator';
 import vtkMouseCameraTrackballZoomToMouseManipulator from '@kitware/vtk.js/Interaction/Manipulators/MouseCameraTrackballZoomToMouseManipulator';
 import { useResetViewsEvents } from '@/src/components/tools/ResetViews.vue';
+import { whenever } from '@vueuse/core';
 
 interface Props extends LayoutViewProps {
   viewDirection: LPSAxisDir;
@@ -216,6 +217,13 @@ const { slice: currentSlice, range: sliceRange } = useSliceConfig(
   currentImageID
 );
 
+whenever(
+  computed(() => !isImageLoading.value),
+  () => {
+    resetCamera();
+  }
+);
+
 // segmentations
 const segmentations = computed(() => {
   if (!currentImageID.value) return [];
diff --git a/src/components/VolumeViewer.vue b/src/components/VolumeViewer.vue
index a3289eec..7456fcec 100644
--- a/src/components/VolumeViewer.vue
+++ b/src/components/VolumeViewer.vue
@@ -74,6 +74,7 @@ import VtkOrientationMarker from '@/src/components/vtk/VtkOrientationMarker.vue'
 import ViewOverlayGrid from '@/src/components/ViewOverlayGrid.vue';
 import useVolumeColoringStore from '@/src/store/view-configs/volume-coloring';
 import { useResetViewsEvents } from '@/src/components/tools/ResetViews.vue';
+import { whenever } from '@vueuse/core';
 
 interface Props extends LayoutViewProps {
   viewDirection: LPSAxisDir;
@@ -100,6 +101,13 @@ useViewAnimationListener(vtkView, viewId, viewType);
 // base image
 const { currentImageID, isImageLoading } = useCurrentImage();
 
+whenever(
+  computed(() => !isImageLoading.value),
+  () => {
+    resetCamera();
+  }
+);
+
 // color preset
 const coloringStore = useVolumeColoringStore();
 const coloringConfig = computed(() =>
diff --git a/src/components/tools/windowing/WindowLevelControls.vue b/src/components/tools/windowing/WindowLevelControls.vue
index 0f0c4131..57997e0e 100644
--- a/src/components/tools/windowing/WindowLevelControls.vue
+++ b/src/components/tools/windowing/WindowLevelControls.vue
@@ -7,6 +7,7 @@ import useWindowingStore, {
 import { useViewStore } from '@/src/store/views';
 import { WLAutoRanges, WLPresetsCT, WL_AUTO_DEFAULT } from '@/src/constants';
 import { getWindowLevels, useDICOMStore } from '@/src/store/datasets-dicom';
+import { isDicomImage } from '@/src/utils/dataSelection';
 
 export default defineComponent({
   setup() {
@@ -31,11 +32,8 @@ export default defineComponent({
     // --- CT Preset Options --- //
 
     const modality = computed(() => {
-      if (
-        currentImageID.value &&
-        currentImageID.value in dicomStore.imageIDToVolumeKey
-      ) {
-        const volKey = dicomStore.imageIDToVolumeKey[currentImageID.value];
+      if (currentImageID.value && isDicomImage(currentImageID.value)) {
+        const volKey = currentImageID.value;
         const { Modality } = dicomStore.volumeInfo[volKey];
         return Modality;
       }
@@ -98,11 +96,8 @@ export default defineComponent({
 
     // --- Tag WL Options --- //
     const tags = computed(() => {
-      if (
-        currentImageID.value &&
-        currentImageID.value in dicomStore.imageIDToVolumeKey
-      ) {
-        const volKey = dicomStore.imageIDToVolumeKey[currentImageID.value];
+      if (currentImageID.value && isDicomImage(currentImageID.value)) {
+        const volKey = currentImageID.value;
         return getWindowLevels(dicomStore.volumeInfo[volKey]);
       }
       return [];
diff --git a/src/composables/useCurrentImage.ts b/src/composables/useCurrentImage.ts
index 78498d38..394939cc 100644
--- a/src/composables/useCurrentImage.ts
+++ b/src/composables/useCurrentImage.ts
@@ -15,7 +15,6 @@ import {
 import { useLayersStore } from '@/src/store/datasets-layers';
 import { createLPSBounds, getAxisBounds } from '@/src/utils/lps';
 import { useDatasetStore } from '@/src/store/datasets';
-import { getDataSelection, getImageID } from '@/src/utils/dataSelection';
 import { storeToRefs } from 'pinia';
 
 export interface CurrentImageContext {
@@ -57,21 +56,16 @@ export function getImageData(imageID: Maybe<string>) {
 }
 
 export function getIsImageLoading(imageID: Maybe<string>) {
-  const dataStore = useDatasetStore();
-  if (!dataStore.primarySelection) return false;
-
-  const selectedImageID = getImageID(dataStore.primarySelection);
-  if (selectedImageID !== unref(imageID)) return false;
-
-  return !!dataStore.primarySelection && !dataStore.primaryDataset;
+  if (!imageID) return false;
+  const imageStore = useImageStore();
+  return !imageStore.dataIndex[imageID];
 }
 
 export function getImageLayers(imageID: Maybe<string>) {
   if (!imageID) return [];
-  const selection = getDataSelection(imageID);
   const layersStore = useLayersStore();
   return layersStore
-    .getLayers(selection)
+    .getLayers(imageID)
     .filter(({ id }) => id in layersStore.layerImages);
 }
 
diff --git a/src/composables/useSliceConfigInitializer.ts b/src/composables/useSliceConfigInitializer.ts
index 590070b5..68b5557c 100644
--- a/src/composables/useSliceConfigInitializer.ts
+++ b/src/composables/useSliceConfigInitializer.ts
@@ -16,7 +16,7 @@ export function useSliceConfigInitializer(
 ) {
   const store = useViewSliceStore();
   const { config: sliceConfig } = useSliceConfig(viewID, imageID);
-  const { metadata } = useImage(imageID);
+  const { metadata, isLoading } = useImage(imageID);
 
   const viewAxis = computed(() => getLPSAxisFromDir(unref(viewDirection)));
   const sliceDomain = computed(() => {
@@ -33,17 +33,22 @@ export function useSliceConfigInitializer(
   });
 
   watchImmediate(
-    [toRef(sliceDomain), toRef(viewDirection)] as const,
-    ([domain, axisDirection]) => {
+    [
+      toRef(sliceDomain),
+      toRef(viewDirection),
+      toRef(imageID),
+      isLoading,
+    ] as const,
+    ([domain, axisDirection, id, loading]) => {
+      if (loading || !id) return;
+
       const configExisted = !!sliceConfig.value;
-      const imageIdVal = unref(imageID);
-      if (!imageIdVal) return;
-      store.updateConfig(unref(viewID), imageIdVal, {
+      store.updateConfig(unref(viewID), id, {
         ...domain,
         axisDirection,
       });
       if (!configExisted) {
-        store.resetSlice(unref(viewID), imageIdVal);
+        store.resetSlice(unref(viewID), id);
       }
     }
   );
diff --git a/src/composables/useVolumeColoringInitializer.ts b/src/composables/useVolumeColoringInitializer.ts
index 4c176893..b2fe1568 100644
--- a/src/composables/useVolumeColoringInitializer.ts
+++ b/src/composables/useVolumeColoringInitializer.ts
@@ -13,10 +13,10 @@ export function useVolumeColoringInitializer(
     store.getConfig(unref(viewId), unref(imageId))
   );
 
-  const { imageData } = useImage(imageId);
+  const { imageData, isLoading } = useImage(imageId);
 
-  watchImmediate(coloringConfig, (config) => {
-    if (config) return;
+  watchImmediate([coloringConfig, viewId, imageId, isLoading], () => {
+    if (coloringConfig.value || isLoading.value) return;
 
     const viewIdVal = unref(viewId);
     const imageIdVal = unref(imageId);
diff --git a/src/composables/useWindowingConfigInitializer.ts b/src/composables/useWindowingConfigInitializer.ts
index c2ef802a..0208fc0b 100644
--- a/src/composables/useWindowingConfigInitializer.ts
+++ b/src/composables/useWindowingConfigInitializer.ts
@@ -9,6 +9,7 @@ import { getWindowLevels, useDICOMStore } from '@/src/store/datasets-dicom';
 import useWindowingStore from '@/src/store/view-configs/windowing';
 import { Maybe } from '@/src/types';
 import { useResetViewsEvents } from '@/src/components/tools/ResetViews.vue';
+import { isDicomImage } from '@/src/utils/dataSelection';
 
 function useAutoRangeValues(imageID: MaybeRef<Maybe<string>>) {
   const { imageData } = useImage(imageID);
@@ -80,8 +81,8 @@ export function useWindowingConfigInitializer(
 
   const firstTag = computed(() => {
     const id = unref(imageID);
-    if (id && id in dicomStore.imageIDToVolumeKey) {
-      const volKey = dicomStore.imageIDToVolumeKey[id];
+    if (id && isDicomImage(id)) {
+      const volKey = id;
       const windowLevels = getWindowLevels(dicomStore.volumeInfo[volKey]);
       if (windowLevels.length) {
         return windowLevels[0];
diff --git a/src/io/import/importDataSources.ts b/src/io/import/importDataSources.ts
index b271b62d..a9259825 100644
--- a/src/io/import/importDataSources.ts
+++ b/src/io/import/importDataSources.ts
@@ -22,10 +22,6 @@ import restoreStateFile from '@/src/io/import/processors/restoreStateFile';
 import updateFileMimeType from '@/src/io/import/processors/updateFileMimeType';
 import handleConfig from '@/src/io/import/processors/handleConfig';
 import { useDICOMStore } from '@/src/store/datasets-dicom';
-import {
-  makeDICOMSelection,
-  makeImageSelection,
-} from '@/src/utils/dataSelection';
 import { applyConfig } from '@/src/io/import/configJson';
 
 /**
@@ -177,16 +173,8 @@ export type ImportDataSourcesResult = Awaited<
 >[number];
 
 export function toDataSelection(loadable: VolumeResult) {
-  const { dataID, dataType } = loadable;
-  if (dataType === 'dicom') {
-    return makeDICOMSelection(dataID);
-  }
-  if (dataType === 'image') {
-    return makeImageSelection(dataID);
-  }
-
-  const _exhaustiveCheck: never = dataType;
-  throw new Error(`invalid loadable type ${_exhaustiveCheck}`);
+  const { dataID } = loadable;
+  return dataID;
 }
 
 export function convertSuccessResultToDataSelection(
diff --git a/src/io/import/processors/restoreStateFile.ts b/src/io/import/processors/restoreStateFile.ts
index cc577b57..2704086e 100644
--- a/src/io/import/processors/restoreStateFile.ts
+++ b/src/io/import/processors/restoreStateFile.ts
@@ -22,11 +22,6 @@ import doneWithDataSource from '@/src/io/import/processors/doneWithDataSource';
 import { useDICOMStore } from '@/src/store/datasets-dicom';
 import { useViewStore } from '@/src/store/views';
 import { useDatasetStore } from '@/src/store/datasets';
-import {
-  DataSelection,
-  makeDICOMSelection,
-  makeImageSelection,
-} from '@/src/utils/dataSelection';
 import {
   makeDefaultSegmentGroupName,
   useSegmentGroupStore,
@@ -344,10 +339,7 @@ async function restoreDatasets(
   return stateIDToStoreID;
 }
 
-const restoreStateFile: ImportHandler = async (
-  dataSource,
-  { done, extra, execute }
-) => {
+const restoreStateFile: ImportHandler = async (dataSource, pipelineContext) => {
   const { fileSrc } = dataSource;
   if (fileSrc && (await isStateFile(fileSrc.file))) {
     const stateFileContents = await extractFilesFromZip(fileSrc.file);
@@ -369,24 +361,17 @@ const restoreStateFile: ImportHandler = async (
     // in the views as the data is loaded
     useViewStore().setLayout(manifest.layout);
 
-    const stateIDToStoreID = await restoreDatasets(manifest, restOfStateFile, {
-      extra,
-      execute,
-      done,
-    });
+    const stateIDToStoreID = await restoreDatasets(
+      manifest,
+      restOfStateFile,
+      pipelineContext
+    );
 
     // Restore the primary selection
     if (manifest.primarySelection !== undefined) {
       const selectedID = stateIDToStoreID[manifest.primarySelection];
-      let dataSelection: DataSelection | undefined;
-
-      if (selectedID in useDICOMStore().volumeInfo) {
-        dataSelection = makeDICOMSelection(selectedID);
-      } else {
-        dataSelection = makeImageSelection(selectedID);
-      }
 
-      useDatasetStore().setPrimarySelection(dataSelection);
+      useDatasetStore().setPrimarySelection(selectedID);
     }
 
     // Restore the views
@@ -404,7 +389,7 @@ const restoreStateFile: ImportHandler = async (
 
     useLayersStore().deserialize(manifest, stateIDToStoreID);
 
-    return done();
+    return pipelineContext.done();
   }
   return dataSource;
 };
diff --git a/src/io/state-file/schema.ts b/src/io/state-file/schema.ts
index e3608e65..65a8cbc9 100644
--- a/src/io/state-file/schema.ts
+++ b/src/io/state-file/schema.ts
@@ -1,30 +1,31 @@
 import JSZip from 'jszip';
 import { z } from 'zod';
 import type { Vector3 } from '@kitware/vtk.js/types';
-import vtkPiecewiseFunctionProxy, {
+import vtkPiecewiseFunctionProxy from '@kitware/vtk.js/Proxy/Core/PiecewiseFunctionProxy';
+import type {
   PiecewiseGaussian,
   PiecewiseNode,
 } from '@kitware/vtk.js/Proxy/Core/PiecewiseFunctionProxy';
 
 import type { AnnotationTool, ToolID } from '@/src/types/annotation-tool';
 import { Tools as ToolsEnum } from '@/src/store/tools/types';
-import { Ruler } from '@/src/types/ruler';
-import { Rectangle } from '@/src/types/rectangle';
-import { Polygon } from '@/src/types/polygon';
-import { LPSCroppingPlanes } from '@/src/types/crop';
-import { FrameOfReference } from '@/src/utils/frameOfReference';
-import { Optional } from '@/src/types';
-
-import {
+import type { Ruler } from '@/src/types/ruler';
+import type { Rectangle } from '@/src/types/rectangle';
+import type { Polygon } from '@/src/types/polygon';
+import type { LPSCroppingPlanes } from '@/src/types/crop';
+import type { FrameOfReference } from '@/src/utils/frameOfReference';
+import type { Optional } from '@/src/types';
+
+import type {
   CameraConfig,
   SliceConfig,
   WindowLevelConfig,
   LayersConfig,
   VolumeColorConfig,
 } from '../../store/view-configs/types';
-import { LPSAxisDir, LPSAxis } from '../../types/lps';
+import type { LPSAxisDir, LPSAxis } from '../../types/lps';
 import { LayoutDirection } from '../../types/layout';
-import {
+import type {
   ColorBy,
   ColorTransferFunction,
   OpacityFunction,
diff --git a/src/store/datasets-dicom.ts b/src/store/datasets-dicom.ts
index 3917c031..3a3c244c 100644
--- a/src/store/datasets-dicom.ts
+++ b/src/store/datasets-dicom.ts
@@ -54,11 +54,6 @@ interface State {
   // volumeKey -> imageCacheMultiKey -> ITKImage
   sliceData: Record<string, Record<string, Image>>;
 
-  // volumeKey -> imageID
-  volumeToImageID: Record<string, string>;
-  // imageID -> volumeKey
-  imageIDToVolumeKey: Record<string, string>;
-
   // volume invalidation information
   needsRebuild: Record<string, boolean>;
 
@@ -155,8 +150,6 @@ const constructImage = async (dicomIO: DICOMIO, volumeKey: string) => {
 export const useDICOMStore = defineStore('dicom', {
   state: (): State => ({
     sliceData: {},
-    volumeToImageID: {},
-    imageIDToVolumeKey: {},
     volumeImageData: {},
     patientInfo: {},
     patientStudies: {},
@@ -236,7 +229,7 @@ export const useDICOMStore = defineStore('dicom', {
           }
 
           // invalidate any existing volume
-          if (volumeKey in this.volumeToImageID) {
+          if (volumeKey in useImageStore().dataIndex) {
             // buildVolume requestor uses this as a rebuild hint
             this.needsRebuild[volumeKey] = true;
           }
@@ -284,12 +277,6 @@ export const useDICOMStore = defineStore('dicom', {
         delete this.sliceData[volumeKey];
         delete this.volumeStudy[volumeKey];
 
-        if (volumeKey in this.volumeToImageID) {
-          const imageID = this.volumeToImageID[volumeKey]!;
-          delete this.volumeToImageID[volumeKey];
-          delete this.imageIDToVolumeKey[imageID];
-        }
-
         if (volumeKey in this.volumeImageData) {
           delete this.volumeImageData[volumeKey];
         }
@@ -415,18 +402,14 @@ export const useDICOMStore = defineStore('dicom', {
       const [image] = await Promise.all([newImagePromise, ...oldImagePromise]);
 
       // update image store
-      const existingImageID = this.volumeToImageID[volumeKey];
-      const imageExists =
-        existingImageID && imageStore.dataIndex[existingImageID];
+      const imageExists = volumeKey && imageStore.dataIndex[volumeKey];
       if (imageExists) {
         // was a rebuild
-        imageStore.updateData(existingImageID, image);
+        imageStore.updateData(volumeKey, image);
       } else {
         const info = this.volumeInfo[volumeKey];
         const name = getDisplayName(info);
-        const newImageID = imageStore.addVTKImageData(name, image);
-        this.imageIDToVolumeKey[newImageID] = volumeKey;
-        this.volumeToImageID[volumeKey] = newImageID;
+        imageStore.addVTKImageData(name, image, volumeKey);
       }
 
       return image;
diff --git a/src/store/datasets-images.ts b/src/store/datasets-images.ts
index 5d18ea73..817a7c06 100644
--- a/src/store/datasets-images.ts
+++ b/src/store/datasets-images.ts
@@ -36,8 +36,12 @@ export const useImageStore = defineStore('images', {
     metadata: Object.create(null),
   }),
   actions: {
-    addVTKImageData(name: string, imageData: vtkImageData) {
-      const id = useIdStore().nextId();
+    addVTKImageData(name: string, imageData: vtkImageData, useId?: string) {
+      if (useId && useId in this.dataIndex) {
+        throw new Error('ID already exists');
+      }
+
+      const id = useId || useIdStore().nextId();
 
       this.idList.push(id);
       this.dataIndex[id] = imageData;
diff --git a/src/store/datasets-layers.ts b/src/store/datasets-layers.ts
index 6293cb54..75b4b33a 100644
--- a/src/store/datasets-layers.ts
+++ b/src/store/datasets-layers.ts
@@ -2,19 +2,13 @@ import { ref } from 'vue';
 import vtkImageData from '@kitware/vtk.js/Common/DataModel/ImageData';
 import vtkBoundingBox from '@kitware/vtk.js/Common/DataModel/BoundingBox';
 import { defineStore } from 'pinia';
-import {
-  DataSelection,
-  getImage,
-  makeDICOMSelection,
-  makeImageSelection,
-  selectionEquals,
-} from '@/src/utils/dataSelection';
+import { type DataSelection, getImage } from '@/src/utils/dataSelection';
+import { Maybe } from '@/src/types';
 import { ensureSameSpace } from '@/src/io/resample/resample';
 import { useErrorMessage } from '../composables/useErrorMessage';
 import { Manifest, StateFile } from '../io/state-file/schema';
 
 // differ from Image/Volume IDs with a branded type
-type DataSelectionKey = string & { __type: 'DataSelectionKey' };
 export type LayerID = string & { __type: 'LayerID' };
 
 export type Layer = {
@@ -22,34 +16,10 @@ export type Layer = {
   id: LayerID;
 };
 
-const assertNeverDataSelection = (selection: never): never => {
-  throw new Error(`Unknown DataSelection: ${selection}`);
-};
-
-const getID = (selection: DataSelection) => {
-  if (selection.type === 'dicom') return selection.volumeKey;
-  if (selection.type === 'image') return selection.dataID;
-  return assertNeverDataSelection(selection);
-};
-
-const toDataSelectionKey = (selection: DataSelection) => {
-  const id = getID(selection);
-  return `${selection.type}::${id}` as DataSelectionKey;
-};
-
-const toDataSelectionFromKey = (key: DataSelectionKey) => {
-  const [type, id] = key.split('::') as [DataSelection['type'], string];
-
-  if (type === 'dicom') return makeDICOMSelection(id);
-  if (type === 'image') return makeImageSelection(id);
-
-  return assertNeverDataSelection(type);
-};
-
 export const useLayersStore = defineStore('layer', () => {
   type _This = ReturnType<typeof useLayersStore>;
 
-  const parentToLayers = ref<Record<DataSelectionKey, Layer[]>>({});
+  const parentToLayers = ref<Record<string, Layer[]>>({});
   const layerImages = ref<Record<LayerID, vtkImageData>>({});
 
   async function _addLayer(
@@ -61,10 +31,9 @@ export const useLayersStore = defineStore('layer', () => {
       throw new Error('Tried to addLayer without parent data selection');
     }
 
-    const parentKey = toDataSelectionKey(parent);
-    const id = `${parentKey}::${toDataSelectionKey(source)}` as LayerID;
-    this.parentToLayers[parentKey] = [
-      ...(this.parentToLayers[parentKey] ?? []),
+    const id = `${parent}::${source}` as LayerID;
+    this.parentToLayers[parent] = [
+      ...(this.parentToLayers[parent] ?? []),
       { selection: source, id } as Layer,
     ];
 
@@ -102,9 +71,8 @@ export const useLayersStore = defineStore('layer', () => {
         await this._addLayer(parent, source);
       } catch (error) {
         // remove failed layer from parent's layer list
-        const parentKey = toDataSelectionKey(parent);
-        this.parentToLayers[parentKey] = this.parentToLayers[parentKey]?.filter(
-          ({ selection }) => !selectionEquals(selection, source)
+        this.parentToLayers[parent] = this.parentToLayers[parent]?.filter(
+          ({ selection }) => selection !== source
         );
         throw error;
       }
@@ -120,25 +88,21 @@ export const useLayersStore = defineStore('layer', () => {
       throw new Error('Tried to deleteLayer without parent data selection');
     }
 
-    const parentKey = toDataSelectionKey(parent);
-    const layers = this.parentToLayers[parentKey] ?? [];
+    const layers = this.parentToLayers[parent] ?? [];
 
-    const layerToDelete = layers.find(({ selection }) =>
-      selectionEquals(selection, source)
-    );
+    const layerToDelete = layers.find(({ selection }) => selection === source);
     if (!layerToDelete) return;
 
-    this.parentToLayers[parentKey] = layers.filter(
+    this.parentToLayers[parent] = layers.filter(
       (layer) => layer !== layerToDelete
     );
 
     delete this.layerImages[layerToDelete.id];
   }
 
-  function getLayers(key: DataSelection | null | undefined) {
+  function getLayers(key: Maybe<DataSelection>) {
     if (!key) return [];
-    const dataKey = toDataSelectionKey(key);
-    return parentToLayers.value[dataKey] ?? [];
+    return parentToLayers.value[key] ?? [];
   }
 
   const getLayer = (layerID: LayerID) =>
@@ -154,18 +118,16 @@ export const useLayersStore = defineStore('layer', () => {
       .getLayers(selectionToRemove)
       .forEach(({ selection }) => layerStore.deleteLayer(selection, selection));
     // delete from layer lists
-    Object.keys(layerStore.parentToLayers)
-      .map((key) => toDataSelectionFromKey(key as DataSelectionKey))
-      .forEach((parent) => layerStore.deleteLayer(parent, selectionToRemove));
+    Object.keys(layerStore.parentToLayers).forEach((parent) =>
+      layerStore.deleteLayer(parent, selectionToRemove)
+    );
   };
 
   function serialize(this: _This, state: StateFile) {
     state.manifest.parentToLayers = Object.entries(this.parentToLayers).map(
       ([selectionKey, layers]) => ({
         selectionKey,
-        sourceSelectionKeys: layers.map(({ selection }) =>
-          toDataSelectionKey(selection)
-        ),
+        sourceSelectionKeys: layers.map(({ selection }) => selection),
       })
     );
   }
@@ -176,25 +138,15 @@ export const useLayersStore = defineStore('layer', () => {
     dataIDMap: Record<string, string>
   ) {
     const remapSelection = (selection: DataSelection) => {
-      if (selection.type === 'dicom')
-        return makeDICOMSelection(dataIDMap[selection.volumeKey]);
-      if (selection.type === 'image')
-        return makeImageSelection(dataIDMap[selection.dataID]);
-
-      const _exhaustiveCheck: never = selection;
-      throw new Error(`invalid selection type ${_exhaustiveCheck}`);
+      return dataIDMap[selection];
     };
 
     const { parentToLayers: parentToLayersSerialized } = manifest;
     parentToLayersSerialized.forEach(
       ({ selectionKey, sourceSelectionKeys }) => {
-        const parent = remapSelection(
-          toDataSelectionFromKey(selectionKey as DataSelectionKey)
-        );
+        const parent = remapSelection(selectionKey);
         sourceSelectionKeys.forEach((sourceKey) => {
-          const source = remapSelection(
-            toDataSelectionFromKey(sourceKey as DataSelectionKey)
-          );
+          const source = remapSelection(sourceKey);
           this.addLayer(parent, source);
         });
       }
diff --git a/src/store/datasets.ts b/src/store/datasets.ts
index ee70539e..e8f7e387 100644
--- a/src/store/datasets.ts
+++ b/src/store/datasets.ts
@@ -2,10 +2,9 @@ import vtkImageData from '@kitware/vtk.js/Common/DataModel/ImageData';
 import { defineStore } from 'pinia';
 import { computed, ref } from 'vue';
 import {
-  DataSelection,
-  getDataSelection,
-  getImageID,
-  selectionEquals,
+  isDicomImage,
+  isRegularImage,
+  type DataSelection,
 } from '@/src/utils/dataSelection';
 import { useDICOMStore } from './datasets-dicom';
 import { useImageStore } from './datasets-images';
@@ -31,10 +30,7 @@ export const useDatasetStore = defineStore('dataset', () => {
 
   // --- getters --- //
 
-  const primaryImageID = computed(() => {
-    if (primarySelection.value) return getImageID(primarySelection.value);
-    return undefined;
-  });
+  const primaryImageID = primarySelection;
 
   const primaryDataset = computed<vtkImageData | null>(() => {
     const { dataIndex } = imageStore;
@@ -43,25 +39,20 @@ export const useDatasetStore = defineStore('dataset', () => {
 
   const idsAsSelections = computed(() => {
     const volumeKeys = Object.keys(dicomStore.volumeInfo);
-    const images = imageStore.idList.filter(
-      (id) => !(id in dicomStore.imageIDToVolumeKey)
-    );
-    return [...volumeKeys, ...images].map(getDataSelection);
+    const images = imageStore.idList.filter((id) => isRegularImage(id));
+    return [...volumeKeys, ...images];
   });
 
   // --- actions --- //
 
   function setPrimarySelection(sel: DataSelection | null) {
     primarySelection.value = sel;
-
-    if (sel === null) {
-      return;
-    }
+    if (!sel) return;
 
     // if selection is dicom, call buildVolume
-    if (sel.type === 'dicom') {
+    if (isDicomImage(sel)) {
       useErrorMessage('Failed to build volume', () =>
-        dicomStore.buildVolume(sel.volumeKey)
+        dicomStore.buildVolume(sel)
       );
     }
   }
@@ -70,39 +61,24 @@ export const useDatasetStore = defineStore('dataset', () => {
     await dicomStore.serialize(stateFile);
     await imageStore.serialize(stateFile);
 
-    if (primarySelection.value !== null) {
-      let id = null;
-      if (primarySelection.value.type === 'dicom') {
-        id = primarySelection.value.volumeKey;
-      } else {
-        id = primarySelection.value.dataID;
-      }
-
+    if (primarySelection.value) {
       const { manifest } = stateFile;
-      manifest.primarySelection = id;
+      manifest.primarySelection = primarySelection.value;
     }
   }
 
   const remove = (id: string) => {
-    const sel = getDataSelection(id);
-    if (
-      primarySelection.value &&
-      selectionEquals(sel, primarySelection.value)
-    ) {
+    if (id === primarySelection.value) {
       primarySelection.value = null;
     }
 
-    if (sel.type === 'dicom') {
-      if (sel.volumeKey in dicomStore.volumeToImageID) {
-        imageStore.deleteData(dicomStore.volumeToImageID[sel.volumeKey]);
-      }
-      dicomStore.deleteVolume(sel.volumeKey);
-    } else if (sel.type === 'image') {
-      imageStore.deleteData(id);
+    if (isDicomImage(id)) {
+      dicomStore.deleteVolume(id);
     }
+    imageStore.deleteData(id);
 
     fileStore.remove(id);
-    layersStore.remove(sel);
+    layersStore.remove(id);
   };
 
   return {
diff --git a/src/store/segmentGroups.ts b/src/store/segmentGroups.ts
index 312d7c7c..53e928bd 100644
--- a/src/store/segmentGroups.ts
+++ b/src/store/segmentGroups.ts
@@ -13,12 +13,9 @@ import { SegmentMask } from '@/src/types/segment';
 import { DEFAULT_SEGMENT_MASKS } from '@/src/config';
 import { readImage, writeImage } from '@/src/io/readWriteImage';
 import {
-  DataSelection,
+  type DataSelection,
   getImage,
-  selectionEquals,
-  findImageID,
-  getImageID,
-  getDataID,
+  isRegularImage,
 } from '@/src/utils/dataSelection';
 import vtkLabelMap from '../vtk/LabelMap';
 import {
@@ -214,12 +211,12 @@ export const useSegmentGroupStore = defineStore('segmentGroup', () => {
   }
 
   function decodeSegments(image: DataSelection) {
-    if (image.type === 'image') {
+    if (isRegularImage(image)) {
       return structuredClone(DEFAULT_SEGMENT_MASKS);
     }
 
     const dicomStore = useDICOMStore();
-    const volumeInfo = dicomStore.volumeInfo[image.volumeKey];
+    const volumeInfo = dicomStore.volumeInfo[image];
     const segmentSequence = undefined; // volumeInfo.SegmentSequence;
     if (!segmentSequence) {
       return [
@@ -245,20 +242,17 @@ export const useSegmentGroupStore = defineStore('segmentGroup', () => {
    * Converts an image to a labelmap.
    */
   async function convertImageToLabelmap(
-    image: DataSelection,
-    parent: DataSelection
+    imageID: DataSelection,
+    parentID: DataSelection
   ) {
-    if (selectionEquals(image, parent))
+    if (imageID === parentID)
       throw new Error('Cannot convert an image to be a labelmap of itself');
 
     // Build vtkImageData for DICOMs
     const [childImage, parentImage] = await Promise.all(
-      [image, parent].map(getImage)
+      [imageID, parentID].map(getImage)
     );
 
-    const imageID = getImageID(image);
-    const parentID = getImageID(parent);
-
     if (!imageID || !parentID)
       throw new Error('Image and/or parent datasets do not exist');
 
@@ -276,7 +270,7 @@ export const useSegmentGroupStore = defineStore('segmentGroup', () => {
 
     const name = imageStore.metadata[imageID].name;
     // Don't remove image if DICOM as user may have selected child image as primary selection by now
-    const deleteImage = image.type !== 'dicom';
+    const deleteImage = isRegularImage(imageID);
     if (deleteImage) {
       imageStore.deleteData(imageID);
     }
@@ -288,7 +282,7 @@ export const useSegmentGroupStore = defineStore('segmentGroup', () => {
       : resampled;
     const labelmapImage = toLabelMap(ownedMemoryImage);
 
-    const segments = decodeSegments(image);
+    const segments = decodeSegments(imageID);
     const { order, byKey } = normalizeForStore(segments, 'value');
     const segmentGroupStore = useSegmentGroupStore();
     segmentGroupStore.addLabelmap(labelmapImage, {
@@ -409,7 +403,7 @@ export const useSegmentGroupStore = defineStore('segmentGroup', () => {
           path: `labels/${id}.${saveFormat.value}`,
           metadata: {
             ...metadata,
-            parentImage: getDataID(metadata.parentImage),
+            parentImage: metadata.parentImage,
           },
         };
       });
@@ -465,7 +459,7 @@ export const useSegmentGroupStore = defineStore('segmentGroup', () => {
     labelMaps.forEach((labelMap, index) => {
       const { metadata } = labelMap;
       // map parent id to new id
-      const parentImage = findImageID(dataIDMap[metadata.parentImage]);
+      const parentImage = dataIDMap[metadata.parentImage];
       metadata.parentImage = parentImage;
 
       const newID = newLabelmapIDs[index];
diff --git a/src/store/tools/useAnnotationTool.ts b/src/store/tools/useAnnotationTool.ts
index def14ea9..1524d6dc 100644
--- a/src/store/tools/useAnnotationTool.ts
+++ b/src/store/tools/useAnnotationTool.ts
@@ -13,7 +13,6 @@ import { useViewStore } from '@/src/store/views';
 import { getLPSAxisFromDir } from '@/src/utils/lps';
 import { LPSAxisDir } from '@/src/types/lps';
 import { AnnotationTool, ToolID } from '@/src/types/annotation-tool';
-import { findImageID, getDataID } from '@/src/utils/dataSelection';
 import { useIdStore } from '@/src/store/id';
 import { useToolSelectionStore } from '@/src/store/tools/toolSelection';
 import type { IToolStore } from '@/src/store/tools/types';
@@ -171,8 +170,7 @@ export const useAnnotationTool = <
       .map((toolID) => toolByID.value[toolID])
       .filter((tool) => !tool.placing)
       .map(({ imageID, ...rest }) => ({
-        // If parent image is DICOM, save VolumeKey
-        imageID: getDataID(imageID),
+        imageID,
         ...rest,
       }));
 
@@ -205,7 +203,7 @@ export const useAnnotationTool = <
         ({ imageID, label, ...rest }) =>
           ({
             ...rest,
-            imageID: findImageID(dataIDMap[imageID]),
+            imageID: dataIDMap[imageID],
             label: (label && labelIDMap[label]) || '',
           } as ToolPatch)
       )
diff --git a/src/store/view-configs/layers.ts b/src/store/view-configs/layers.ts
index d24bc481..66507e2b 100644
--- a/src/store/view-configs/layers.ts
+++ b/src/store/view-configs/layers.ts
@@ -15,6 +15,7 @@ import {
 import { Maybe } from '@/src/types';
 import { identity } from '@/src/utils';
 import { LAYER_PRESET_BY_MODALITY, LAYER_PRESET_DEFAULT } from '@/src/config';
+import { isDicomImage } from '@/src/utils/dataSelection';
 import { createViewConfigSerializer } from './common';
 import { ViewConfig } from '../../io/state-file/schema';
 import { LayersConfig } from './types';
@@ -28,10 +29,9 @@ function getPreset(id: LayerID) {
     throw new Error(`Layer ${id} not found`);
   }
 
-  if (layer.selection.type === 'dicom') {
+  if (isDicomImage(layer.selection)) {
     const dicomStore = useDICOMStore();
-    const { Modality = undefined } =
-      dicomStore.volumeInfo[layer.selection.volumeKey];
+    const { Modality = undefined } = dicomStore.volumeInfo[layer.selection];
     return (
       (Modality && LAYER_PRESET_BY_MODALITY[Modality]) || LAYER_PRESET_DEFAULT
     );
diff --git a/src/store/view-configs/volume-coloring.ts b/src/store/view-configs/volume-coloring.ts
index 24a8e749..ed0922dd 100644
--- a/src/store/view-configs/volume-coloring.ts
+++ b/src/store/view-configs/volume-coloring.ts
@@ -16,6 +16,7 @@ import {
 } from '@/src/utils/doubleKeyRecord';
 import { DeepPartial, Maybe } from '@/src/types';
 import { identity } from '@/src/utils';
+import { isDicomImage } from '@/src/utils/dataSelection';
 import { createViewConfigSerializer } from './common';
 import { ViewConfig } from '../../io/state-file/schema';
 import { VolumeColorConfig } from './types';
@@ -30,8 +31,8 @@ export const DEFAULT_SAMPLING_DISTANCE = 0.2;
 
 function getPresetFromImageModality(imageID: string) {
   const dicomStore = useDICOMStore();
-  if (imageID in dicomStore.imageIDToVolumeKey) {
-    const volKey = dicomStore.imageIDToVolumeKey[imageID];
+  if (isDicomImage(imageID)) {
+    const volKey = imageID;
     const { Modality } = dicomStore.volumeInfo[volKey];
     if (Modality in DEFAULT_PRESET_BY_MODALITY) {
       return DEFAULT_PRESET_BY_MODALITY[Modality];
diff --git a/src/utils/dataSelection.ts b/src/utils/dataSelection.ts
index 15a41b47..27b12d40 100644
--- a/src/utils/dataSelection.ts
+++ b/src/utils/dataSelection.ts
@@ -1,95 +1,42 @@
 import { getDisplayName, useDICOMStore } from '@/src/store/datasets-dicom';
 import { useImageStore } from '@/src/store/datasets-images';
 import { useErrorMessage } from '@/src/composables/useErrorMessage';
+import { Maybe } from '@/src/types';
 
-export const makeDICOMSelection = (volumeKey: string) =>
-  ({
-    type: 'dicom',
-    volumeKey,
-  } as const);
+export type DataSelection = string;
 
-export type DICOMSelection = ReturnType<typeof makeDICOMSelection>;
+export const selectionEquals = (a: DataSelection, b: DataSelection) => a === b;
 
-export const makeImageSelection = (imageID: string) =>
-  ({
-    type: 'image',
-    dataID: imageID,
-  } as const);
-
-export type ImageSelection = ReturnType<typeof makeImageSelection>;
-
-export type DataSelection = DICOMSelection | ImageSelection;
-
-export const getImageID = (selection: DataSelection) => {
-  if (selection.type === 'image') return selection.dataID;
-  if (selection.type === 'dicom') {
-    // possibly undefined because image may not have been made yet
-    return useDICOMStore().volumeToImageID[selection.volumeKey];
-  }
+export const isDicomImage = (imageID: Maybe<string>) => {
+  if (!imageID) return false;
+  const store = useDICOMStore();
+  return imageID in store.volumeInfo;
+};
 
-  const _exhaustiveCheck: never = selection;
-  throw new Error(`invalid selection type ${_exhaustiveCheck}`);
+export const isRegularImage = (imageID: Maybe<string>) => {
+  if (!imageID) return false;
+  return !isDicomImage(imageID);
 };
 
-export const getImage = async (selection: DataSelection) => {
+export const getImage = async (imageID: string) => {
   const images = useImageStore();
   const dicoms = useDICOMStore();
-  if (selection.type === 'dicom') {
+  if (isDicomImage(imageID)) {
     // ensure image data exists
     await useErrorMessage('Failed to build volume', () =>
-      dicoms.buildVolume(selection.volumeKey)
+      dicoms.buildVolume(imageID)
     );
-    return images.dataIndex[getImageID(selection)!];
   }
-  // just an image that should be in dataIndex
-  return images.dataIndex[selection.dataID];
-};
-
-// Converts imageID to VolumeKey if exists, else return input imageID
-export const getDataID = (imageID: string) => {
-  const dicomStore = useDICOMStore();
-  return dicomStore.imageIDToVolumeKey[imageID] ?? imageID;
+  return images.dataIndex[imageID];
 };
 
-// @param id - VolumeKey or ImageID
-export const getDataSelection = (id: string) => {
-  const dicomStore = useDICOMStore();
-  const volumeKey =
-    dicomStore.imageIDToVolumeKey[id] ??
-    (id in dicomStore.volumeInfo ? id : undefined);
-  if (volumeKey) {
-    return makeDICOMSelection(volumeKey);
-  }
-  return makeImageSelection(id);
-};
-
-// Pass VolumeKey or ImageID and get ImageID
-export const findImageID = (dataID: string) => {
-  const dicomStore = useDICOMStore();
-  return dicomStore.volumeToImageID[dataID] ?? dataID;
-};
-
-export function selectionEquals(s1: DataSelection, s2: DataSelection) {
-  if (s1.type === 'dicom' && s2.type === 'dicom') {
-    return s1.volumeKey === s2.volumeKey;
-  }
-  if (s1.type === 'image' && s2.type === 'image') {
-    return s1.dataID === s2.dataID;
-  }
-  return false;
-}
-
 const getImageName = (imageID: string) => {
   return useImageStore().metadata[imageID].name;
 };
 
-export const getSelectionName = (selection: DataSelection) => {
-  if (selection.type === 'image') return getImageName(selection.dataID);
-  if (selection.type === 'dicom') {
-    const imageID = getImageID(selection);
-    if (imageID) return getImageName(imageID);
-    return getDisplayName(useDICOMStore().volumeInfo[selection.volumeKey]);
+export const getSelectionName = (selection: string) => {
+  if (isDicomImage(selection)) {
+    return getDisplayName(useDICOMStore().volumeInfo[selection]);
   }
-  const _exhaustiveCheck: never = selection;
-  throw new Error(`invalid selection type ${_exhaustiveCheck}`);
+  return getImageName(selection);
 };