diff --git a/.github/workflows/e2e.yml b/.github/workflows/e2e.yml
index 07b530e8d..a580e1895 100644
--- a/.github/workflows/e2e.yml
+++ b/.github/workflows/e2e.yml
@@ -10,7 +10,7 @@ jobs:
     name: E2E Testing on ${{ matrix.os }}
     runs-on: ${{ matrix.os }}
     env:
-      DOWNLOAD_TIMEOUT: 220000
+      DOWNLOAD_TIMEOUT: 60000
       VITE_SHOW_SAMPLE_DATA: true
     steps:
       - uses: actions/checkout@v4
diff --git a/package-lock.json b/package-lock.json
index 1073f59f4..f94312dd7 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -14132,19 +14132,20 @@
       }
     },
     "node_modules/express": {
-      "version": "5.1.0",
-      "resolved": "https://registry.npmjs.org/express/-/express-5.1.0.tgz",
-      "integrity": "sha512-DT9ck5YIRU+8GYzzU5kT3eHGA5iL+1Zd0EutOmTE9Dtk+Tvuzd23VBU+ec7HPNSTxXYO55gPV/hq4pSBJDjFpA==",
+      "version": "5.2.1",
+      "resolved": "https://registry.npmjs.org/express/-/express-5.2.1.tgz",
+      "integrity": "sha512-hIS4idWWai69NezIdRt2xFVofaF4j+6INOpJlVOLDO8zXGpUVEVzIYk12UUi2JzjEzWL3IOAxcTubgz9Po0yXw==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
         "accepts": "^2.0.0",
-        "body-parser": "^2.2.0",
+        "body-parser": "^2.2.1",
         "content-disposition": "^1.0.0",
         "content-type": "^1.0.5",
         "cookie": "^0.7.1",
         "cookie-signature": "^1.2.1",
         "debug": "^4.4.0",
+        "depd": "^2.0.0",
         "encodeurl": "^2.0.0",
         "escape-html": "^1.0.3",
         "etag": "^1.8.1",
diff --git a/src/components/EditableChipList.vue b/src/components/EditableChipList.vue
index 9c3cc045f..fb48041c8 100644
--- a/src/components/EditableChipList.vue
+++ b/src/components/EditableChipList.vue
@@ -39,7 +39,11 @@ const itemsToRender = computed(() =>
     mandatory
   >
     <v-row dense>
-      <v-col cols="6" v-for="({ key, title }, idx) in itemsToRender" :key="key">
+      <v-col
+        cols="12"
+        v-for="({ key, title }, idx) in itemsToRender"
+        :key="key"
+      >
         <v-item v-slot="{ selectedClass, toggle }" :value="key">
           <v-chip
             variant="tonal"
@@ -59,7 +63,7 @@ const itemsToRender = computed(() =>
       </v-col>
 
       <!-- Add Label button -->
-      <v-col cols="6">
+      <v-col cols="12">
         <v-chip variant="outlined" class="w-100" @click="$emit('create')">
           <v-icon class="mr-2">mdi-plus</v-icon>
           {{ createLabelText }}
diff --git a/src/components/ModulePanel.vue b/src/components/ModulePanel.vue
index cbc8172d2..a5fe429d3 100644
--- a/src/components/ModulePanel.vue
+++ b/src/components/ModulePanel.vue
@@ -149,6 +149,7 @@ export default defineComponent({
   position: relative;
   flex: 2;
   overflow: auto;
+  scrollbar-gutter: stable;
 }
 
 .module-text {
diff --git a/src/components/SaveSession.vue b/src/components/SaveSession.vue
index 33c1973d6..291933cc9 100644
--- a/src/components/SaveSession.vue
+++ b/src/components/SaveSession.vue
@@ -35,7 +35,7 @@ import { defineComponent, onMounted, ref } from 'vue';
 import { saveAs } from 'file-saver';
 import { onKeyDown } from '@vueuse/core';
 
-import { serialize } from '../io/state-file';
+import { serialize } from '../io/state-file/serialize';
 
 const DEFAULT_FILENAME = 'session.volview.zip';
 
diff --git a/src/components/tools/ScalarProbe.vue b/src/components/tools/ScalarProbe.vue
index 32c9d585a..fcffe6a6c 100644
--- a/src/components/tools/ScalarProbe.vue
+++ b/src/components/tools/ScalarProbe.vue
@@ -1,7 +1,9 @@
 <script setup lang="ts">
 import { inject, watch, computed, toRefs } from 'vue';
 import type { ReadonlyVec3 } from 'gl-matrix';
+import { vec3 } from 'gl-matrix';
 import { onVTKEvent } from '@/src/composables/onVTKEvent';
+import { worldPointToIndex } from '@/src/utils/imageSpace';
 import { VtkViewContext } from '@/src/components/vtk/context';
 import { useCurrentImage } from '@/src/composables/useCurrentImage';
 import vtkPointPicker from '@kitware/vtk.js/Rendering/Core/PointPicker';
@@ -110,29 +112,54 @@ const getImageSamples = (x: number, y: number) => {
   pointPicker.pick([x, y, 1.0], view.renderer);
   if (pointPicker.getActors().length === 0) return undefined;
 
-  const ijk = pointPicker.getPointIJK() as unknown as ReadonlyVec3;
-  const samples = sampleSet.value.map((item: any) => {
-    const dims = item.image.getDimensions();
-    const scalarData = item.image.getPointData().getScalars();
-    const index = dims[0] * dims[1] * ijk[2] + dims[0] * ijk[1] + ijk[0];
-    const scalars = scalarData.getTuple(index) as number[];
-    const baseInfo = { id: item.id, name: item.name };
-
-    if (item.type === 'segmentGroup') {
-      return {
-        ...baseInfo,
-        displayValues: scalars.map(
-          (v) => item.segments.byValue[v]?.name || 'Background'
-        ),
-      };
-    }
-    return { ...baseInfo, displayValues: scalars };
-  });
-
-  const position = firstToSample.image.indexToWorld(ijk);
+  // Get world position from the picked point
+  const pickedIjk = pointPicker.getPointIJK() as unknown as ReadonlyVec3;
+  const worldPosition = vec3.clone(
+    firstToSample.image.indexToWorld(pickedIjk) as vec3
+  );
+
+  const samples = sampleSet.value
+    .map((item: any) => {
+      // Convert world position to this specific image's IJK
+      const itemIjk = worldPointToIndex(item.image, worldPosition);
+      const dims = item.image.getDimensions();
+      const scalarData = item.image.getPointData().getScalars();
+
+      // Round to nearest integer indices
+      const i = Math.round(itemIjk[0]);
+      const j = Math.round(itemIjk[1]);
+      const k = Math.round(itemIjk[2]);
+
+      // Check bounds
+      if (
+        i < 0 ||
+        j < 0 ||
+        k < 0 ||
+        i >= dims[0] ||
+        j >= dims[1] ||
+        k >= dims[2]
+      ) {
+        return null;
+      }
+
+      const index = dims[0] * dims[1] * k + dims[0] * j + i;
+      const scalars = scalarData.getTuple(index) as number[];
+      const baseInfo = { id: item.id, name: item.name };
+
+      if (item.type === 'segmentGroup') {
+        return {
+          ...baseInfo,
+          displayValues: scalars.map(
+            (v) => item.segments.byValue[v]?.name || 'Background'
+          ),
+        };
+      }
+      return { ...baseInfo, displayValues: scalars };
+    })
+    .filter((s): s is NonNullable<typeof s> => s !== null);
 
   return {
-    pos: position,
+    pos: worldPosition,
     samples,
   };
 };
diff --git a/src/components/tools/paint/PaintWidget2D.vue b/src/components/tools/paint/PaintWidget2D.vue
index 4f7ae225b..368d9723d 100644
--- a/src/components/tools/paint/PaintWidget2D.vue
+++ b/src/components/tools/paint/PaintWidget2D.vue
@@ -16,8 +16,10 @@ import { getLPSAxisFromDir } from '@/src/utils/lps';
 import { useImage } from '@/src/composables/useCurrentImage';
 import { updatePlaneManipulatorFor2DView } from '@/src/utils/manipulators';
 import { usePaintToolStore } from '@/src/store/tools/paint';
+import { useSegmentGroupStore } from '@/src/store/segmentGroups';
 import { vtkPaintViewWidget } from '@/src/vtk/PaintWidget';
 import { LPSAxisDir } from '@/src/types/lps';
+import { getLPSDirections } from '@/src/utils/lps';
 import { onVTKEvent } from '@/src/composables/onVTKEvent';
 import { useSliceInfo } from '@/src/composables/useSliceInfo';
 import { VtkViewContext } from '@/src/components/vtk/context';
@@ -48,6 +50,7 @@ export default defineComponent({
     const slice = computed(() => sliceInfo.value?.slice);
 
     const paintStore = usePaintToolStore();
+    const segmentGroupStore = useSegmentGroupStore();
     const widgetFactory = paintStore.getWidgetFactory();
     const widgetState = widgetFactory.getWidgetState();
 
@@ -57,32 +60,34 @@ export default defineComponent({
       () => imageMetadata.value.lpsOrientation[viewAxis.value]
     );
 
-    const worldPointToIndex = (worldPoint: vec3) => {
-      const { worldToIndex } = imageMetadata.value;
-      const indexPoint = vec3.create();
-      vec3.transformMat4(indexPoint, worldPoint, worldToIndex);
-      return indexPoint;
-    };
+    // Get the active labelmap for coordinate transforms
+    const activeLabelmap = computed(() => {
+      const groupId = paintStore.activeSegmentGroupID;
+      if (!groupId) return null;
+      return segmentGroupStore.dataIndex[groupId] ?? null;
+    });
 
     const widget = view.widgetManager.addWidget(
       widgetFactory
     ) as vtkPaintViewWidget;
 
-    onMounted(() => {
-      view.widgetManager.renderWidgets();
-      view.widgetManager.grabFocus(widget);
-    });
-
-    onUnmounted(() => {
-      view.widgetManager.removeWidget(widgetFactory);
-    });
-
     // --- widget representation config --- //
 
     watchEffect(() => {
-      const metadata = imageMetadata.value;
-      const slicingIndex = metadata.lpsOrientation[viewAxis.value];
-      if (widget) {
+      if (!widget) return;
+
+      const labelmap = activeLabelmap.value;
+      if (labelmap) {
+        // Use labelmap's transforms so brush preview matches where paint appears
+        const labelmapLps = getLPSDirections(labelmap.getDirection());
+        const slicingIndex = labelmapLps[viewAxis.value];
+        widget.setSlicingIndex(slicingIndex);
+        widget.setIndexToWorld(labelmap.getIndexToWorld());
+        widget.setWorldToIndex(labelmap.getWorldToIndex());
+      } else {
+        // Fall back to parent image transforms
+        const metadata = imageMetadata.value;
+        const slicingIndex = metadata.lpsOrientation[viewAxis.value];
         widget.setSlicingIndex(slicingIndex);
         widget.setIndexToWorld(metadata.indexToWorld);
         widget.setWorldToIndex(metadata.worldToIndex);
@@ -95,17 +100,19 @@ export default defineComponent({
       if (!imageId.value) return;
       paintStore.setSliceAxis(viewAxisIndex.value, imageId.value);
       const origin = widgetState.getBrush().getOrigin()!;
-      const indexPoint = worldPointToIndex(origin);
-      paintStore.startStroke(indexPoint, viewAxisIndex.value, imageId.value);
+      paintStore.startStroke(
+        vec3.clone(origin),
+        viewAxisIndex.value,
+        imageId.value
+      );
       paintStore.updatePaintPosition(origin, viewId.value);
     });
 
     onVTKEvent(widget, 'onInteractionEvent', () => {
       if (!imageId.value) return;
       const origin = widgetState.getBrush().getOrigin()!;
-      const indexPoint = worldPointToIndex(origin);
       paintStore.placeStrokePoint(
-        indexPoint,
+        vec3.clone(origin),
         viewAxisIndex.value,
         imageId.value
       );
@@ -114,8 +121,11 @@ export default defineComponent({
 
     onVTKEvent(widget, 'onEndInteractionEvent', () => {
       if (!imageId.value) return;
-      const indexPoint = worldPointToIndex(widgetState.getBrush().getOrigin()!);
-      paintStore.endStroke(indexPoint, viewAxisIndex.value, imageId.value);
+      paintStore.endStroke(
+        vec3.clone(widgetState.getBrush().getOrigin()!),
+        viewAxisIndex.value,
+        imageId.value
+      );
     });
 
     // --- manipulator --- //
@@ -137,19 +147,10 @@ export default defineComponent({
 
     let checkIfPointerInView = false;
 
-    onMounted(() => {
-      widget.setVisibility(false);
-      checkIfPointerInView = true;
-    });
-
-    // Turn on widget visibility and update stencil
-    // if mouse starts within view
+    // Turn on widget visibility and update stencil if mouse starts within view
     onVTKEvent(view.interactor, 'onMouseMove', () => {
-      if (!checkIfPointerInView) {
-        return;
-      }
+      if (!checkIfPointerInView) return;
       checkIfPointerInView = false;
-
       widget.setVisibility(true);
       if (imageId.value) {
         paintStore.setSliceAxis(viewAxisIndex.value, imageId.value);
@@ -186,12 +187,17 @@ export default defineComponent({
     };
 
     onMounted(() => {
+      view.widgetManager.renderWidgets();
+      view.widgetManager.grabFocus(widget);
+      widget.setVisibility(false);
+      checkIfPointerInView = true;
       view.renderWindowView
         .getContainer()
         ?.addEventListener('wheel', handleWheelEvent, { passive: false });
     });
 
     onUnmounted(() => {
+      view.widgetManager.removeWidget(widgetFactory);
       view.renderWindowView
         .getContainer()
         ?.removeEventListener('wheel', handleWheelEvent);
diff --git a/src/components/tools/polygon/PolygonTool.vue b/src/components/tools/polygon/PolygonTool.vue
index 9ec1d4de5..e639ff3c4 100644
--- a/src/components/tools/polygon/PolygonTool.vue
+++ b/src/components/tools/polygon/PolygonTool.vue
@@ -110,6 +110,8 @@ import type { IGrid2D } from '@thi.ng/api';
 import vtkImageData from '@kitware/vtk.js/Common/DataModel/ImageData';
 import type { Vector2, Vector3 } from '@kitware/vtk.js/types';
 import { containsPoint } from '@kitware/vtk.js/Common/DataModel/BoundingBox';
+import { convertSliceIndex } from '@/src/utils/imageSpace';
+import { getLPSDirections } from '@/src/utils/lps';
 import { type ToolID } from '@/src/types/annotation-tool';
 import PolygonWidget2D from '@/src/components/tools/polygon/PolygonWidget2D.vue';
 import { usePaintToolStore } from '@/src/store/tools/paint';
@@ -177,7 +179,6 @@ export default defineComponent({
 
     const sliceInfo = useSliceInfo(viewId, imageId);
     const slice = computed(() => sliceInfo.value?.slice ?? 0);
-    const sliceAxis = computed(() => sliceInfo.value?.axisIndex ?? 0);
 
     const { metadata: imageMetadata } = useImage(imageId);
     const isToolActive = computed(() => toolStore.currentTool === toolType);
@@ -279,25 +280,41 @@ export default defineComponent({
         paintStore.setActiveSegment(segment.value);
       }
 
-      const image = segmentGroupStore.dataIndex[segmentGroupID];
-      if (!image) {
+      const segmentGroup = segmentGroupStore.dataIndex[segmentGroupID];
+      if (!segmentGroup) {
         throw new Error(
-          `Failed to get labelmap for segment group ${segmentGroupID}`
+          `Failed to get segment group data for ${segmentGroupID}`
         );
       }
 
+      // Convert parent slice index to segment group slice index
+      const parentMeta = imageMetadata.value;
+      const segmentGroupSlice = convertSliceIndex(
+        slice.value,
+        parentMeta.lpsOrientation,
+        parentMeta.indexToWorld,
+        segmentGroup,
+        viewAxis.value
+      );
+
       const points = activeToolStore.getPoints(toolId);
-      const axis = sliceAxis.value;
+      const segmentGroupIjkIndex = getLPSDirections(
+        segmentGroup.getDirection()
+      )[viewAxis.value];
 
       const indexSpacePoints2D = points.map((pt) => {
-        const output = [...image.worldToIndex(pt)];
-        output.splice(axis, 1);
+        const output = [...segmentGroup.worldToIndex(pt)];
+        output.splice(segmentGroupIjkIndex, 1);
         return output as Vector2;
       });
 
-      const grid = createGridAccessor(image, slice.value, axis);
+      const grid = createGridAccessor(
+        segmentGroup,
+        segmentGroupSlice,
+        segmentGroupIjkIndex
+      );
       fillPoly(grid, indexSpacePoints2D, segment.value);
-      image.modified();
+      segmentGroup.modified();
     }
 
     return {
diff --git a/src/components/vtk/VtkSegmentationSliceRepresentation.vue b/src/components/vtk/VtkSegmentationSliceRepresentation.vue
index 4a0e5d81f..033920fe4 100644
--- a/src/components/vtk/VtkSegmentationSliceRepresentation.vue
+++ b/src/components/vtk/VtkSegmentationSliceRepresentation.vue
@@ -14,7 +14,9 @@ import { InterpolationType } from '@kitware/vtk.js/Rendering/Core/ImageProperty/
 import vtkColorTransferFunction from '@kitware/vtk.js/Rendering/Core/ColorTransferFunction';
 import vtkPiecewiseFunction from '@kitware/vtk.js/Common/DataModel/PiecewiseFunction';
 import { vtkFieldRef } from '@/src/core/vtk/vtkFieldRef';
-import { syncRef } from '@vueuse/core';
+import { watchImmediate } from '@vueuse/core';
+import { convertSliceIndex } from '@/src/utils/imageSpace';
+import { getLPSDirections } from '@/src/utils/lps';
 import { useSliceConfig } from '@/src/composables/useSliceConfig';
 import useLayerColoringStore from '@/src/store/view-configs/layers';
 import { useSegmentGroupConfigStore } from '@/src/store/view-configs/segmentGroups';
@@ -47,6 +49,9 @@ onVTKEvent(imageData, 'onModified', () => {
 // setup slice rep
 const sliceRep = useSliceRepresentation(view, imageData);
 
+// Let widget fill representations be picked through the segment overlay
+sliceRep.actor.setPickable(false);
+
 sliceRep.property.setRGBTransferFunction(
   0,
   vtkColorTransferFunction.newInstance()
@@ -86,17 +91,42 @@ watchEffect(() => {
 const parentImageId = computed(() => metadata.value?.parentImage);
 const { metadata: parentMetadata } = useImage(parentImageId);
 
+// Compute segment group's LPS orientation from its direction matrix
+const segmentGroupLpsOrientation = computed(() => {
+  const segmentGroup = imageData.value;
+  if (!segmentGroup) return null;
+  return getLPSDirections(segmentGroup.getDirection());
+});
+
+// Set slicing mode based on segment group's own orientation
 watchEffect(() => {
-  const { lpsOrientation } = parentMetadata.value;
+  const lpsOrientation = segmentGroupLpsOrientation.value;
+  if (!lpsOrientation) return;
   const ijkIndex = lpsOrientation[axis.value];
   const mode = [SlicingMode.I, SlicingMode.J, SlicingMode.K][ijkIndex];
   sliceRep.mapper.setSlicingMode(mode);
 });
 
-// sync slicing
+// sync slicing - convert parent slice to segment group slice via world coordinates
 const slice = vtkFieldRef(sliceRep.mapper, 'slice');
 const { slice: storedSlice } = useSliceConfig(viewId, parentImageId);
-syncRef(storedSlice, slice, { immediate: true });
+
+watchImmediate(
+  [storedSlice, segmentGroupLpsOrientation, parentMetadata],
+  () => {
+    const parentImage = parentMetadata.value;
+    const segmentGroup = imageData.value;
+    if (!parentImage || !segmentGroup || storedSlice.value == null) return;
+
+    slice.value = convertSliceIndex(
+      storedSlice.value,
+      parentImage.lpsOrientation,
+      parentImage.indexToWorld,
+      segmentGroup,
+      axis.value
+    );
+  }
+);
 
 // set coloring properties
 const applySegmentColoring = () => {
diff --git a/src/composables/annotationTool.ts b/src/composables/annotationTool.ts
index 1dfb0ef04..616dff996 100644
--- a/src/composables/annotationTool.ts
+++ b/src/composables/annotationTool.ts
@@ -191,20 +191,21 @@ export const useHover = (
 
   watch(synchronousOverlayInfo, resetOverlay);
 
-  const overlayInfo = computed(() =>
-    showOverlay.value
-      ? synchronousOverlayInfo.value
-      : ({ visible: false } as Info)
-  );
-
   const toolStore = useToolStore();
-  const noInfoWithoutSelect = computed(() => {
-    if (toolStore.currentTool !== Tools.Select)
+  const TOOLS_WITH_HOVER = [
+    Tools.Select,
+    Tools.Ruler,
+    Tools.Rectangle,
+    Tools.Polygon,
+  ];
+  const overlayInfo = computed(() => {
+    if (!showOverlay.value) return { visible: false } as Info;
+    if (!TOOLS_WITH_HOVER.includes(toolStore.currentTool))
       return { visible: false } as Info;
-    return overlayInfo.value;
+    return synchronousOverlayInfo.value;
   });
 
-  return { overlayInfo: noInfoWithoutSelect, onHover };
+  return { overlayInfo, onHover };
 };
 
 export const usePlacingAnnotationTool = (
diff --git a/src/io/import/__tests__/configJson.spec.ts b/src/io/import/__tests__/configJson.spec.ts
new file mode 100644
index 000000000..5fc90a620
--- /dev/null
+++ b/src/io/import/__tests__/configJson.spec.ts
@@ -0,0 +1,45 @@
+import { describe, it, expect } from 'vitest';
+import { config } from '@/src/io/import/configJson';
+
+describe('config schema', () => {
+  describe('shortcuts', () => {
+    it('should accept partial shortcuts', () => {
+      const result = config.safeParse({
+        shortcuts: {
+          polygon: 'Ctrl+p',
+          rectangle: 'b',
+        },
+      });
+
+      expect(result.success).to.be.true;
+      expect(result.data?.shortcuts).to.deep.equal({
+        polygon: 'Ctrl+p',
+        rectangle: 'b',
+      });
+    });
+
+    it('should reject invalid shortcut keys', () => {
+      const result = config.safeParse({
+        shortcuts: {
+          invalidKey: 'Ctrl+x',
+        },
+      });
+
+      expect(result.success).to.be.false;
+    });
+
+    it('should accept empty shortcuts', () => {
+      const result = config.safeParse({
+        shortcuts: {},
+      });
+
+      expect(result.success).to.be.true;
+    });
+
+    it('should accept config without shortcuts', () => {
+      const result = config.safeParse({});
+
+      expect(result.success).to.be.true;
+    });
+  });
+});
diff --git a/src/io/import/common.ts b/src/io/import/common.ts
index ce6599adf..206450806 100644
--- a/src/io/import/common.ts
+++ b/src/io/import/common.ts
@@ -4,48 +4,58 @@ import { ARCHIVE_FILE_TYPES } from '@/src/io/mimeTypes';
 import { Awaitable } from '@vueuse/core';
 import { Config } from '@/src/io/import/configJson';
 import { ChainHandler } from '@/src/utils/evaluateChain';
+import type { Manifest } from '@/src/io/state-file/schema';
+import type { FileEntry } from '@/src/io/types';
 
-export interface LoadableResult {
+export type LoadableResult = {
   type: 'data';
   dataID: string;
   dataSource: DataSource;
   dataType: 'image' | 'model';
-}
+};
 
-export interface LoadableVolumeResult extends LoadableResult {
+export type LoadableVolumeResult = LoadableResult & {
   dataType: 'image';
-}
+};
 
-export interface LoadableModelResult extends LoadableResult {
+export type LoadableModelResult = LoadableResult & {
   dataType: 'model';
-}
+};
 
-export interface ConfigResult {
+export type ConfigResult = {
   type: 'config';
   config: Config;
   dataSource: DataSource;
-}
+};
 
-export interface OkayResult {
+export type OkayResult = {
   type: 'ok';
   dataSource: DataSource;
-}
+};
 
-export interface IntermediateResult {
+export type IntermediateResult = {
   type: 'intermediate';
   dataSources: DataSource[];
-}
+};
+
+export type StateFileSetupResult = {
+  type: 'stateFileSetup';
+  dataSources: DataSource[];
+  manifest: Manifest;
+  stateFiles: FileEntry[];
+};
 
-export interface ErrorResult {
+export type ErrorResult = {
   type: 'error';
   error: Error;
   dataSource: DataSource;
-}
+};
 
 export type ImportResult =
   | LoadableResult
   | ConfigResult
   | IntermediateResult
+  | StateFileSetupResult
   | OkayResult
   | ErrorResult;
 
@@ -99,21 +109,15 @@ export const asOkayResult = (dataSource: DataSource): OkayResult => ({
 export type ArchiveContents = Record<string, File>;
 export type ArchiveCache = Map<File, Awaitable<ArchiveContents>>;
 
-export interface ImportContext {
-  // Caches URL responses
+export type ImportContext = {
   fetchFileCache?: FetchCache<File>;
-  // Caches archives. ArchiveFile -> { [archivePath]: File }
   archiveCache?: ArchiveCache;
-  // Records dicom files
   dicomDataSources?: DataSource[];
   onCleanup?: (fn: () => void) => void;
-  /**
-   * A reference to importDataSources for nested imports.
-   */
   importDataSources?: (
     dataSources: DataSource[]
   ) => Promise<ImportDataSourcesResult[]>;
-}
+};
 
 export type ImportHandler = ChainHandler<
   DataSource,
diff --git a/src/io/import/configJson.ts b/src/io/import/configJson.ts
index f4706aa83..4900573da 100644
--- a/src/io/import/configJson.ts
+++ b/src/io/import/configJson.ts
@@ -21,7 +21,9 @@ const layouts = z.record(z.string(), layoutConfig).optional();
 // --------------------------------------------------------------------------
 // Keyboard shortcuts
 
-const shortcuts = z.record(zodEnumFromObjKeys(ACTIONS), z.string()).optional();
+const shortcuts = z
+  .partialRecord(zodEnumFromObjKeys(ACTIONS), z.string())
+  .optional();
 
 // --------------------------------------------------------------------------
 // Labels
diff --git a/src/io/import/dataSource.ts b/src/io/import/dataSource.ts
index aa4d233dd..28d8af2af 100644
--- a/src/io/import/dataSource.ts
+++ b/src/io/import/dataSource.ts
@@ -5,32 +5,31 @@ import { Maybe } from '@/src/types';
 /**
  * Represents a URI source with a file name for the downloaded resource.
  */
-export interface UriSource {
+export type UriSource = {
   type: 'uri';
   uri: string;
   name: string;
   mime?: string;
   fetcher?: Fetcher;
-}
+};
 
 /**
  * Represents a user-specified file.
  */
-export interface FileSource {
+export type FileSource = {
   type: 'file';
   file: File;
   fileType: string;
-}
+};
 
 /**
  * Represents an archive member. The parent should exist and be a FileSource.
  */
-export interface ArchiveSource {
+export type ArchiveSource = {
   type: 'archive';
-  // Full path + filename inside the archive
   path: string;
   parent: FileSource;
-}
+};
 
 /**
  * Represents a collection of data sources.
@@ -38,33 +37,36 @@ export interface ArchiveSource {
  * This is used for data that is derived from a collection of data sources,
  * e.g. reconstructed DICOM.
  */
-export interface CollectionSource {
+export type CollectionSource = {
   type: 'collection';
-
   sources: DataSource[];
-}
+};
 
 /**
  * Represents a data chunk for further processing and import.
  */
-export interface ChunkSource {
+export type ChunkSource = {
   type: 'chunk';
   chunk: Chunk;
   mime: string;
-}
+};
+
+/**
+ * Used to map DICOM volumes back to state file datasets.
+ */
+export type StateFileLeaf = {
+  stateID: string;
+};
 
 /**
  * Represents a source of data.
  *
  * The parent chain denotes the provenance for each step of the data source resolution.
  */
-export type DataSource = { parent?: DataSource } & (
-  | FileSource
-  | UriSource
-  | ArchiveSource
-  | ChunkSource
-  | CollectionSource
-);
+export type DataSource = {
+  parent?: DataSource;
+  stateFileLeaf?: StateFileLeaf;
+} & (FileSource | UriSource | ArchiveSource | ChunkSource | CollectionSource);
 
 /**
  * Creates a DataSource from a single file.
diff --git a/src/io/import/importDataSources.ts b/src/io/import/importDataSources.ts
index 72d7c11da..a00c6ff18 100644
--- a/src/io/import/importDataSources.ts
+++ b/src/io/import/importDataSources.ts
@@ -9,6 +9,7 @@ import {
   ErrorResult,
   ImportDataSourcesResult,
   asIntermediateResult,
+  StateFileSetupResult,
 } from '@/src/io/import/common';
 import { DataSource, ChunkSource } from '@/src/io/import/dataSource';
 import handleDicomFile from '@/src/io/import/processors/handleDicomFile';
@@ -18,7 +19,10 @@ import handleAmazonS3 from '@/src/io/import/processors/handleAmazonS3';
 import handleGoogleCloudStorage from '@/src/io/import/processors/handleGoogleCloudStorage';
 import importSingleFile from '@/src/io/import/processors/importSingleFile';
 import handleRemoteManifest from '@/src/io/import/processors/remoteManifest';
-import restoreStateFile from '@/src/io/import/processors/restoreStateFile';
+import {
+  restoreStateFile,
+  completeStateFileRestore,
+} from '@/src/io/import/processors/restoreStateFile';
 import updateFileMimeType from '@/src/io/import/processors/updateFileMimeType';
 import handleConfig from '@/src/io/import/processors/handleConfig';
 import {
@@ -43,7 +47,14 @@ const unhandledResource: ImportHandler = (dataSource) => {
 
 const handleCollections: ImportHandler = (dataSource) => {
   if (dataSource.type !== 'collection') return Skip;
-  return asIntermediateResult(dataSource.sources);
+  // Propagate stateFileLeaf to sources so DICOM volumes can be mapped back to state file datasets
+  const sources = dataSource.stateFileLeaf
+    ? dataSource.sources.map((src) => ({
+        ...src,
+        stateFileLeaf: dataSource.stateFileLeaf,
+      }))
+    : dataSource.sources;
+  return asIntermediateResult(sources);
 };
 
 function isSelectable(result: ImportResult): result is LoadableVolumeResult {
@@ -62,6 +73,18 @@ const applyConfigsPostState = (
     }
   });
 
+function findStateFileLeaf(dataSource: DataSource) {
+  let current: DataSource | undefined = dataSource;
+  while (current) {
+    if (current.stateFileLeaf) return current.stateFileLeaf;
+    current = current.parent;
+  }
+  if (dataSource.type === 'collection' && dataSource.sources.length > 0) {
+    return findStateFileLeaf(dataSource.sources[0]);
+  }
+  return undefined;
+}
+
 async function importDicomChunkSources(sources: ChunkSource[]) {
   if (sources.length === 0) return [];
 
@@ -135,6 +158,7 @@ export async function importDataSources(
 
   const chunkSources: DataSource[] = [];
   const configResults: ConfigResult[] = [];
+  const stateFileSetups: StateFileSetupResult[] = [];
   const results: ImportDataSourcesResult[] = [];
 
   let queue = dataSources.map((src) => ({
@@ -149,6 +173,9 @@ export async function importDataSources(
     queue = queue.filter((_, i) => i !== index);
 
     switch (result.type) {
+      case 'stateFileSetup':
+        stateFileSetups.push(result);
+      // fallthrough to handle dataSources
       case 'intermediate': {
         const [chunks, otherSources] = partition(
           (ds) => ds.type === 'chunk',
@@ -156,7 +183,6 @@ export async function importDataSources(
         );
         chunkSources.push(...chunks);
 
-        // try loading intermediate results
         queue.push(
           ...otherSources.map((src) => ({
             promise: evaluateChain(src, handlers, importContext),
@@ -174,8 +200,8 @@ export async function importDataSources(
         }
         break;
       case 'ok':
-      case 'data':
       case 'error':
+      case 'data':
         results.push(result);
         break;
       default:
@@ -193,7 +219,8 @@ export async function importDataSources(
   );
 
   try {
-    results.push(...(await importDicomChunkSources(dicomChunkSources)));
+    const dicomResults = await importDicomChunkSources(dicomChunkSources);
+    results.push(...dicomResults);
   } catch (err) {
     const errorSource =
       dicomChunkSources.length === 1
@@ -202,11 +229,27 @@ export async function importDataSources(
     results.push(asErrorResult(ensureError(err), errorSource));
   }
 
-  // save data sources
-  useDatasetStore().addDataSources(
-    results.filter((result): result is LoadableResult => result.type === 'data')
+  const loadableResults = results.filter(
+    (r): r is LoadableResult => r.type === 'data'
   );
 
+  useDatasetStore().addDataSources(loadableResults);
+
+  for (const setup of stateFileSetups) {
+    const stateIDToStoreID: Record<string, string> = {};
+    for (const loadable of loadableResults) {
+      const leaf = findStateFileLeaf(loadable.dataSource);
+      if (leaf) {
+        stateIDToStoreID[leaf.stateID] = loadable.dataID;
+      }
+    }
+    await completeStateFileRestore(
+      setup.manifest,
+      setup.stateFiles,
+      stateIDToStoreID
+    );
+  }
+
   return results;
 }
 
diff --git a/src/io/import/processors/restoreStateFile.ts b/src/io/import/processors/restoreStateFile.ts
index 2d19359bd..15414a8e1 100644
--- a/src/io/import/processors/restoreStateFile.ts
+++ b/src/io/import/processors/restoreStateFile.ts
@@ -5,508 +5,177 @@ import {
 } from '@/src/io/state-file/schema';
 import {
   asErrorResult,
-  asOkayResult,
-  ImportContext,
   ImportHandler,
-  ImportResult,
+  StateFileSetupResult,
 } from '@/src/io/import/common';
-import { DataSource } from '@/src/io/import/dataSource';
-import { MANIFEST, isStateFile } from '@/src/io/state-file';
-import { partition } from '@/src/utils';
-import { pipe } from '@/src/utils/functional';
-import {
-  makeDefaultSegmentGroupName,
-  useSegmentGroupStore,
-} from '@/src/store/segmentGroups';
+import { MANIFEST, isStateFile } from '@/src/io/state-file/serialize';
+import { partition, getURLBasename } from '@/src/utils';
+import { useSegmentGroupStore } from '@/src/store/segmentGroups';
 import { useToolStore } from '@/src/store/tools';
 import { useLayersStore } from '@/src/store/datasets-layers';
 import { extractFilesFromZip } from '@/src/io/zip';
-import updateFileMimeType from '@/src/io/import/processors/updateFileMimeType';
-import extractArchiveTarget from '@/src/io/import/processors/extractArchiveTarget';
-import { ChainHandler, evaluateChain, Skip } from '@/src/utils/evaluateChain';
-import openUriStream from '@/src/io/import/processors/openUriStream';
-import updateUriType from '@/src/io/import/processors/updateUriType';
-import handleDicomStream from '@/src/io/import/processors/handleDicomStream';
-import downloadStream from '@/src/io/import/processors/downloadStream';
-import { FileEntry } from '@/src/io/types';
+import type { FileEntry } from '@/src/io/types';
+import { Skip } from '@/src/utils/evaluateChain';
 import { useViewStore } from '@/src/store/views';
 import { useViewConfigStore } from '@/src/store/view-configs';
-
-const LABELMAP_PALETTE_2_1_0 = {
-  '1': {
-    value: 1,
-    name: 'Segment 1',
-    color: [153, 153, 0, 255],
-  },
-  '2': {
-    value: 2,
-    name: 'Segment 2',
-    color: [76, 76, 0, 255],
-  },
-  '3': {
-    value: 3,
-    name: 'Segment 3',
-    color: [255, 255, 0, 255],
-  },
-  '4': {
-    value: 4,
-    name: 'Segment 4',
-    color: [0, 76, 0, 255],
-  },
-  '5': {
-    value: 5,
-    name: 'Segment 5',
-    color: [0, 153, 0, 255],
-  },
-  '6': {
-    value: 6,
-    name: 'Segment 6',
-    color: [0, 255, 0, 255],
-  },
-  '7': {
-    value: 7,
-    name: 'Segment 7',
-    color: [76, 0, 0, 255],
-  },
-  '8': {
-    value: 8,
-    name: 'Segment 8',
-    color: [153, 0, 0, 255],
-  },
-  '9': {
-    value: 9,
-    name: 'Segment 9',
-    color: [255, 0, 0, 255],
-  },
-  '10': {
-    value: 10,
-    name: 'Segment 10',
-    color: [0, 76, 76, 255],
-  },
-  '11': {
-    value: 11,
-    name: 'Segment 11',
-    color: [0, 153, 153, 255],
-  },
-  '12': {
-    value: 12,
-    name: 'Segment 12',
-    color: [0, 255, 255, 255],
-  },
-  '13': {
-    value: 13,
-    name: 'Segment 13',
-    color: [0, 0, 76, 255],
-  },
-  '14': {
-    value: 14,
-    name: 'Segment 14',
-    color: [0, 0, 153, 255],
-  },
-};
-
-const migrateOrPass =
-  (versions: Array<string>, migrationFunc: (manifest: any) => any) =>
-  (inputManifest: any) => {
-    if (versions.includes(inputManifest.version)) {
-      return migrationFunc(inputManifest);
-    }
-    return inputManifest;
-  };
-
-const migrateBefore210 = (inputManifest: any) => {
-  const manifest = JSON.parse(JSON.stringify(inputManifest));
-  manifest.version = '2.1.0';
-  return manifest;
-};
-
-const migrate210To300 = (inputManifest: any) => {
-  const manifest = JSON.parse(JSON.stringify(inputManifest));
-  manifest.tools.paint.activeSegmentGroupID =
-    inputManifest.tools.paint.activeLabelmapID;
-  delete manifest.tools.paint.activeLabelmapID;
-
-  const order = Object.keys(LABELMAP_PALETTE_2_1_0).map((key) => Number(key));
-  manifest.labelMaps = inputManifest.labelMaps.map(
-    (labelMap: any, index: number) => ({
-      id: labelMap.id,
-      path: labelMap.path,
-      metadata: {
-        parentImage: labelMap.parent,
-        name: makeDefaultSegmentGroupName('My Image', index),
-        segments: {
-          order,
-          byValue: LABELMAP_PALETTE_2_1_0,
+import { migrateManifest } from '@/src/io/state-file/migrations';
+import { useMessageStore } from '@/src/store/messages';
+
+type LeafSource =
+  | { type: 'uri'; uri: string; name: string; mime?: string }
+  | { type: 'file'; file: File; fileType: string };
+
+function resolveToLeafSources(
+  id: number,
+  byId: Record<number, DataSourceType>,
+  datasetFilePath: Record<string, string> | undefined,
+  pathToFile: Record<string, File>
+): LeafSource[] {
+  const src = byId[id];
+  if (!src) return [];
+
+  switch (src.type) {
+    case 'uri':
+      return [
+        {
+          type: 'uri',
+          uri: src.uri,
+          name: src.name ?? getURLBasename(src.uri) ?? src.uri,
+          mime: src.mime,
         },
-      },
-    })
-  );
-
-  manifest.version = '3.0.0';
-  return manifest;
-};
-
-const migrate501To600 = (inputManifest: any) => {
-  const manifest = JSON.parse(JSON.stringify(inputManifest));
+      ];
 
-  // Convert views array to viewByID object
-  if (manifest.views && Array.isArray(manifest.views)) {
-    manifest.viewByID = {};
-    manifest.views.forEach((view: any) => {
-      const migratedView = { ...view };
-
-      // Add required 'name' field if missing
-      if (!migratedView.name) {
-        migratedView.name = migratedView.id;
-      }
-
-      // Convert 'props' to 'options' if present
-      if (migratedView.props) {
-        // Convert any non-string values in props to strings for options
-        migratedView.options = {};
-        Object.entries(migratedView.props).forEach(([key, value]) => {
-          if (typeof value === 'string') {
-            migratedView.options[key] = value;
-          } else {
-            // Convert arrays and objects to JSON strings
-            migratedView.options[key] = JSON.stringify(value);
-          }
-        });
-        delete migratedView.props;
+    case 'file': {
+      const filePath = datasetFilePath?.[src.fileId];
+      const file = filePath ? pathToFile[filePath] : undefined;
+      if (file) {
+        return [{ type: 'file', file, fileType: src.fileType }];
       }
-
-      // Add orientation for 2D views based on the view ID
-      if (migratedView.type === '2D' && !migratedView.options) {
-        migratedView.options = {};
-      }
-      if (migratedView.type === '2D') {
-        // Set orientation based on view ID (Coronal, Sagittal, Axial)
-        if (['Coronal', 'Sagittal', 'Axial'].includes(migratedView.id)) {
-          migratedView.options.orientation = migratedView.id;
-        }
-      }
-
-      // Handle type conversion for Oblique views
-      if (migratedView.type === 'Oblique3D') {
-        migratedView.type = 'Oblique';
-      }
-
-      const configKeys = Object.keys(migratedView.config || {});
-      const primarySelection = manifest.primarySelection;
-
-      migratedView.dataID = null;
-      if (configKeys.length > 0) {
-        migratedView.dataID =
-          primarySelection && configKeys.includes(primarySelection)
-            ? primarySelection
-            : configKeys[0];
-      }
-
-      manifest.viewByID[migratedView.id] = migratedView;
-    });
-    delete manifest.views;
-  }
-
-  // Add missing fields with proper defaults
-  if (manifest.isActiveViewMaximized === undefined) {
-    manifest.isActiveViewMaximized = false;
-  }
-
-  if (manifest.activeView === undefined) {
-    manifest.activeView = null;
-  }
-
-  // Convert layout to layoutSlots and update layout structure
-  if (manifest.layout && !manifest.layoutSlots) {
-    const slots: string[] = [];
-
-    // Extract all slot names and convert layout to new format
-    const convertLayoutItem = (item: any): any => {
-      if (typeof item === 'string') {
-        // This is a view name like "Coronal", "3D", etc.
-        const slotIndex = slots.length;
-        slots.push(item);
-        return {
-          type: 'slot',
-          slotIndex,
-        };
-      }
-      if (item.direction && item.items) {
-        // This is a nested layout
-        return {
-          type: 'layout',
-          direction: item.direction,
-          items: item.items.map(convertLayoutItem),
-        };
-      }
-      return item;
-    };
-
-    // Convert the root layout
-    if (manifest.layout.direction && manifest.layout.items) {
-      manifest.layout = {
-        direction: manifest.layout.direction,
-        items: manifest.layout.items.map(convertLayoutItem),
-      };
-    }
-
-    manifest.layoutSlots = slots;
-  }
-
-  // Ensure parentToLayers exists as an array
-  if (!manifest.parentToLayers) {
-    manifest.parentToLayers = [];
-  }
-
-  manifest.version = '6.0.0';
-  return manifest;
-};
-
-const migrate600To610 = (inputManifest: any) => {
-  const manifest = JSON.parse(JSON.stringify(inputManifest));
-
-  const migrateDirection = (dir: 'H' | 'V'): 'row' | 'column' => {
-    return dir === 'H' ? 'column' : 'row';
-  };
-
-  const migrateLayout = (layout: any): any => {
-    if (!layout || typeof layout !== 'object') return layout;
-
-    const migratedLayout = { ...layout };
-
-    if (layout.direction) {
-      migratedLayout.direction = migrateDirection(layout.direction);
+      const missingFile = filePath ?? String(src.fileId);
+      useMessageStore().addError(
+        'State file missing expected file',
+        missingFile
+      );
+      return [];
     }
 
-    if (layout.items && Array.isArray(layout.items)) {
-      migratedLayout.items = layout.items.map((item: any) => {
-        if (item.type === 'layout') {
-          return migrateLayout(item);
-        }
-        return item;
-      });
-    }
+    case 'archive':
+      return resolveToLeafSources(
+        src.parent,
+        byId,
+        datasetFilePath,
+        pathToFile
+      );
 
-    return migratedLayout;
-  };
+    case 'collection':
+      return src.sources.flatMap((sourceId) =>
+        resolveToLeafSources(sourceId, byId, datasetFilePath, pathToFile)
+      );
 
-  if (manifest.layout) {
-    manifest.layout = migrateLayout(manifest.layout);
+    default:
+      return [];
   }
+}
 
-  manifest.version = '6.1.0';
-  return manifest;
-};
-
-const migrateManifest = (manifestString: string) => {
-  const inputManifest = JSON.parse(manifestString);
-  return pipe(
-    inputManifest,
-    migrateOrPass(['1.1.0', '1.0.0', '0.5.0'], migrateBefore210),
-    migrateOrPass(['2.1.0'], migrate210To300),
-    migrateOrPass(['5.0.1'], migrate501To600),
-    migrateOrPass(['6.0.0'], migrate600To610)
+function prepareLeafDataSources(manifest: Manifest, datasetFiles: FileEntry[]) {
+  const byId: Record<number, DataSourceType> = Object.fromEntries(
+    manifest.dataSources.map((ds) => [ds.id, ds])
   );
-};
-
-type ResolvedResult = {
-  type: 'resolved';
-  dataSource: DataSource;
-};
-
-type ResolvingImportHandler = ChainHandler<
-  DataSource,
-  ImportResult | ResolvedResult,
-  ImportContext
->;
 
-const resolvingHandlers: ResolvingImportHandler[] = [
-  openUriStream,
-
-  // updating the file/uri type should be first step in the pipeline
-  updateFileMimeType,
-  updateUriType,
+  const pathToFile: Record<string, File> = Object.fromEntries(
+    datasetFiles.map((f) => [f.archivePath, f.file])
+  );
 
-  // stream handling
-  handleDicomStream,
-  downloadStream,
+  const datasets =
+    manifest.datasets ??
+    manifest.dataSources
+      .filter((ds) => ds.type === 'uri')
+      .map((ds) => ({ id: String(ds.id), dataSourceId: ds.id }));
+
+  return datasets.flatMap((ds) => {
+    const sources = resolveToLeafSources(
+      ds.dataSourceId,
+      byId,
+      manifest.datasetFilePath,
+      pathToFile
+    );
 
-  extractArchiveTarget,
+    const seen = new Set<string>();
+    const uniqueSources = sources.filter((src) => {
+      if (src.type !== 'uri') return true;
+      if (seen.has(src.uri)) return false;
+      seen.add(src.uri);
+      return true;
+    });
 
-  (dataSource) => {
-    return { type: 'resolved', dataSource };
-  },
-];
+    return uniqueSources.map((src) => ({
+      ...src,
+      stateFileLeaf: { stateID: ds.id },
+    }));
+  });
+}
 
-async function rebuildDataSources(
-  serializedDataSources: DataSourceType[],
-  fileIDToFile: Record<number, File>
+export async function completeStateFileRestore(
+  manifest: Manifest,
+  stateFiles: FileEntry[],
+  stateIDToStoreID: Record<string, string>
 ) {
-  const dataSourceCache: Record<string, DataSource> = {};
-  const byId: Record<string, DataSourceType> = {};
-  const leaves = new Set<number>();
+  const viewStore = useViewStore();
 
-  serializedDataSources.forEach((serializedSrc) => {
-    byId[serializedSrc.id] = serializedSrc;
-    leaves.add(serializedSrc.id);
+  Object.entries(stateIDToStoreID).forEach(([stateID, storeID]) => {
+    viewStore.bindViewsToData(stateID, storeID, manifest);
   });
 
-  const deserialize = (
-    serialized: (typeof serializedDataSources)[number]
-  ): DataSource => {
-    const { type } = serialized;
-    switch (type) {
-      case 'file':
-        return {
-          type: 'file',
-          file: fileIDToFile[serialized.fileId],
-          fileType: serialized.fileType,
-        };
-      case 'archive': {
-        const parent = dataSourceCache[serialized.parent];
-        if (!parent)
-          throw new Error('Could not find the parent of an archive source');
-        if (parent.type !== 'file')
-          throw new Error('Archive source parent is not a file');
-        return {
-          type: 'archive',
-          path: serialized.path,
-          parent,
-        };
-      }
-      case 'uri':
-        return {
-          type: 'uri',
-          uri: serialized.uri,
-          name: serialized.name,
-          mime: serialized.mime,
-        };
-      case 'collection': {
-        // these sources are no longer leaves
-        serialized.sources.forEach((id) => {
-          leaves.delete(id);
-        });
-        const sources = serialized.sources.map((id) => dataSourceCache[id]);
-        if (sources.some((src) => !src))
-          throw new Error('Could not deserialize a collection source');
-        return {
-          type: 'collection',
-          sources,
-        };
-      }
-      default:
-        throw new Error(
-          `Encountered an invalid serialized data source: ${type}`
-        );
+  if (!manifest.viewByID) {
+    const storeID = manifest.primarySelection
+      ? stateIDToStoreID[manifest.primarySelection]
+      : Object.values(stateIDToStoreID)[0];
+    if (storeID) {
+      viewStore.setDataForAllViews(storeID);
     }
-  };
-
-  // serializedDataSources should be topologically ordered by ancestors first
-  // and descendants last. This is established in
-  // datasets.ts/serializeDataSource()
-  for (let i = 0; i < serializedDataSources.length; i++) {
-    const serializedSrc = serializedDataSources[i];
-
-    if (serializedSrc.id in dataSourceCache) {
-      continue;
-    }
-
-    let dataSource = deserialize(serializedSrc);
-
-    if (serializedSrc.parent) {
-      dataSource.parent = dataSourceCache[serializedSrc.parent];
-      leaves.delete(serializedSrc.parent);
-    }
-
-    let stillResolving = true;
-    while (stillResolving) {
-      const result = await evaluateChain(dataSource, resolvingHandlers);
-
-      stillResolving = result.type !== 'resolved';
-      if (!stillResolving) break;
+  }
 
-      if (result.type !== 'intermediate') {
-        throw new Error(
-          'Resolving pipeline does not produce intermediate results!'
-        );
-      }
+  useViewConfigStore().deserializeAll(manifest, stateIDToStoreID);
 
-      dataSource = result.dataSources[0];
-    }
+  const segmentGroupIDMap = await useSegmentGroupStore().deserialize(
+    manifest,
+    stateFiles,
+    stateIDToStoreID
+  );
 
-    dataSourceCache[serializedSrc.id] = dataSource;
-  }
+  useLayersStore().deserialize(manifest, stateIDToStoreID);
 
-  return { dataSourceCache, leaves };
+  useToolStore().deserialize(manifest, segmentGroupIDMap, stateIDToStoreID);
 }
 
-async function restoreDatasets(
-  manifest: Manifest,
-  datasetFiles: FileEntry[],
-  context?: ImportContext
-) {
-  const { datasets, dataSources, datasetFilePath } = manifest;
-  const dataSourceIDToStateID = datasets.reduce<Record<number, string>>(
-    (acc, ds) =>
-      Object.assign(acc, {
-        [ds.dataSourceId]: ds.id,
-      }),
-    {}
-  );
-  const pathToFile = datasetFiles.reduce<Record<string, File>>(
-    (acc, datasetFile) =>
-      Object.assign(acc, {
-        [datasetFile.archivePath]: datasetFile.file,
-      }),
-    {}
-  );
-  const fileIDToFile = Object.entries(datasetFilePath).reduce<
-    Record<number, File>
-  >(
-    (acc, [fileId, filePath]) =>
-      Object.assign(acc, {
-        [fileId]: pathToFile[filePath],
-      }),
-    {}
-  );
+async function parseManifestFromZip(file: File) {
+  const stateFileContents = await extractFilesFromZip(file);
 
-  const { dataSourceCache, leaves } = await rebuildDataSources(
-    dataSources,
-    fileIDToFile
+  const [manifests, restOfStateFile] = partition(
+    (dataFile) => dataFile.file.name === MANIFEST,
+    stateFileContents
   );
 
-  const stateIDToStoreID: Record<string, string> = {};
-
-  await Promise.all(
-    [...leaves].map(async (leafId) => {
-      const dataSource = dataSourceCache[leafId];
-      const importResult =
-        (await context?.importDataSources?.([dataSource])) ?? [];
-      const [result] = importResult;
-      if (result?.type !== 'data' || importResult.length !== 1)
-        throw new Error('Expected a single dataset');
+  if (manifests.length !== 1) {
+    throw new Error('State file does not have exactly 1 manifest');
+  }
 
-      stateIDToStoreID[dataSourceIDToStateID[leafId]] = result.dataID;
-    })
-  );
+  const manifestString = await manifests[0].file.text();
+  return { manifestString, stateFiles: restOfStateFile };
+}
 
-  return stateIDToStoreID;
+async function parseManifestFromJson(file: File) {
+  const manifestString = await file.text();
+  return { manifestString, stateFiles: [] as FileEntry[] };
 }
 
-const restoreStateFile: ImportHandler = async (dataSource, context) => {
+export const restoreStateFile: ImportHandler = async (dataSource) => {
   if (dataSource.type === 'file' && (await isStateFile(dataSource.file))) {
-    const stateFileContents = await extractFilesFromZip(dataSource.file);
-
-    const [manifests, restOfStateFile] = partition(
-      (dataFile) => dataFile.file.name === MANIFEST,
-      stateFileContents
-    );
-
-    if (manifests.length !== 1) {
-      throw new Error('State file does not have exactly 1 manifest');
-    }
+    const isJson = dataSource.fileType === 'application/json';
+    const { manifestString, stateFiles } = isJson
+      ? await parseManifestFromJson(dataSource.file)
+      : await parseManifestFromZip(dataSource.file);
 
-    const manifestString = await manifests[0].file.text();
     const migrated = migrateManifest(manifestString);
     let manifest: Manifest;
     try {
@@ -518,37 +187,14 @@ const restoreStateFile: ImportHandler = async (dataSource, context) => {
       );
     }
 
-    // We restore the view first, so that the appropriate watchers are triggered
-    // in the views as the data is loaded
-    useViewStore().setLayout(manifest.layout);
+    useViewStore().deserializeLayout(manifest);
 
-    const stateIDToStoreID = await restoreDatasets(
+    return {
+      type: 'stateFileSetup',
+      dataSources: prepareLeafDataSources(manifest, stateFiles),
       manifest,
-      restOfStateFile,
-      context
-    );
-
-    // Restore the views
-    useViewStore().deserialize(manifest, stateIDToStoreID);
-
-    // Restore view configs
-    useViewConfigStore().deserializeAll(manifest, stateIDToStoreID);
-
-    // Restore the labelmaps
-    const segmentGroupIDMap = await useSegmentGroupStore().deserialize(
-      manifest,
-      restOfStateFile,
-      stateIDToStoreID
-    );
-
-    // Restore the tools
-    useToolStore().deserialize(manifest, segmentGroupIDMap, stateIDToStoreID);
-
-    useLayersStore().deserialize(manifest, stateIDToStoreID);
-
-    return asOkayResult(dataSource);
+      stateFiles,
+    } as StateFileSetupResult;
   }
   return Skip;
 };
-
-export default restoreStateFile;
diff --git a/src/io/state-file/migrations.ts b/src/io/state-file/migrations.ts
new file mode 100644
index 000000000..d6e225a1f
--- /dev/null
+++ b/src/io/state-file/migrations.ts
@@ -0,0 +1,165 @@
+import { pipe } from '@/src/utils/functional';
+
+const migrateOrPass =
+  (versions: Array<string>, migrationFunc: (manifest: any) => any) =>
+  (inputManifest: any) => {
+    if (versions.includes(inputManifest.version)) {
+      return migrationFunc(inputManifest);
+    }
+    return inputManifest;
+  };
+
+const migrate501To600 = (inputManifest: any) => {
+  const manifest = JSON.parse(JSON.stringify(inputManifest));
+
+  if (manifest.views && Array.isArray(manifest.views)) {
+    manifest.viewByID = {};
+    manifest.views.forEach((view: any) => {
+      const migratedView = { ...view };
+
+      if (!migratedView.name) {
+        migratedView.name = migratedView.id;
+      }
+
+      if (migratedView.props) {
+        migratedView.options = {};
+        Object.entries(migratedView.props).forEach(([key, value]) => {
+          if (typeof value === 'string') {
+            migratedView.options[key] = value;
+          } else {
+            migratedView.options[key] = JSON.stringify(value);
+          }
+        });
+        delete migratedView.props;
+      }
+
+      if (migratedView.type === '2D' && !migratedView.options) {
+        migratedView.options = {};
+      }
+      if (migratedView.type === '2D') {
+        if (['Coronal', 'Sagittal', 'Axial'].includes(migratedView.id)) {
+          migratedView.options.orientation = migratedView.id;
+        }
+      }
+
+      if (migratedView.type === 'Oblique3D') {
+        migratedView.type = 'Oblique';
+      }
+
+      const configKeys = Object.keys(migratedView.config || {});
+      const primarySelection = manifest.primarySelection;
+
+      migratedView.dataID = null;
+      if (configKeys.length > 0) {
+        migratedView.dataID =
+          primarySelection && configKeys.includes(primarySelection)
+            ? primarySelection
+            : configKeys[0];
+      }
+
+      manifest.viewByID[migratedView.id] = migratedView;
+    });
+    delete manifest.views;
+  }
+
+  if (manifest.isActiveViewMaximized === undefined) {
+    manifest.isActiveViewMaximized = false;
+  }
+
+  if (manifest.activeView === undefined) {
+    manifest.activeView = null;
+  }
+
+  if (manifest.layout && !manifest.layoutSlots) {
+    const slots: string[] = [];
+
+    const convertLayoutItem = (item: any): any => {
+      if (typeof item === 'string') {
+        const slotIndex = slots.length;
+        slots.push(item);
+        return {
+          type: 'slot',
+          slotIndex,
+        };
+      }
+      if (item.direction && item.items) {
+        return {
+          type: 'layout',
+          direction: item.direction,
+          items: item.items.map(convertLayoutItem),
+        };
+      }
+      return item;
+    };
+
+    if (manifest.layout.direction && manifest.layout.items) {
+      manifest.layout = {
+        direction: manifest.layout.direction,
+        items: manifest.layout.items.map(convertLayoutItem),
+      };
+    }
+
+    manifest.layoutSlots = slots;
+  }
+
+  if (!manifest.parentToLayers) {
+    manifest.parentToLayers = [];
+  }
+
+  manifest.version = '6.0.0';
+  return manifest;
+};
+
+const migrate600To610 = (inputManifest: any) => {
+  const manifest = JSON.parse(JSON.stringify(inputManifest));
+
+  const migrateDirection = (dir: 'H' | 'V'): 'row' | 'column' => {
+    return dir === 'H' ? 'column' : 'row';
+  };
+
+  const migrateLayout = (layout: any): any => {
+    if (!layout || typeof layout !== 'object') return layout;
+
+    const migratedLayout = { ...layout };
+
+    if (layout.direction) {
+      migratedLayout.direction = migrateDirection(layout.direction);
+    }
+
+    if (layout.items && Array.isArray(layout.items)) {
+      migratedLayout.items = layout.items.map((item: any) => {
+        if (item.type === 'layout') {
+          return migrateLayout(item);
+        }
+        return item;
+      });
+    }
+
+    return migratedLayout;
+  };
+
+  if (manifest.layout) {
+    manifest.layout = migrateLayout(manifest.layout);
+  }
+
+  manifest.version = '6.1.0';
+  return manifest;
+};
+
+const migrate610To620 = (inputManifest: any) => {
+  const manifest = JSON.parse(JSON.stringify(inputManifest));
+  manifest.segmentGroups = inputManifest.labelMaps;
+  delete manifest.labelMaps;
+  manifest.version = '6.2.0';
+  return manifest;
+};
+
+export const migrateManifest = (manifestString: string) => {
+  const inputManifest = JSON.parse(manifestString);
+  return pipe(
+    inputManifest,
+    migrateOrPass(['5.0.1'], migrate501To600),
+    migrateOrPass(['6.0.0'], migrate600To610),
+    migrateOrPass(['6.1.0', '6.1.1'], migrate610To620)
+  );
+};
diff --git a/src/io/state-file/schema.ts b/src/io/state-file/schema.ts
index c3081bae2..ef20aac44 100644
--- a/src/io/state-file/schema.ts
+++ b/src/io/state-file/schema.ts
@@ -7,7 +7,7 @@ import type {
   PiecewiseNode,
 } from '@kitware/vtk.js/Proxy/Core/PiecewiseFunctionProxy';
 
-import type { AnnotationTool, ToolID } from '@/src/types/annotation-tool';
+import type { ToolID } from '@/src/types/annotation-tool';
 import { Tools as ToolsEnum } from '@/src/store/tools/types';
 import type { Ruler } from '@/src/types/ruler';
 import type { Rectangle } from '@/src/types/rectangle';
@@ -54,7 +54,7 @@ const UriSource = z.object({
   id: z.number(),
   type: z.literal('uri'),
   uri: z.string(),
-  name: z.string(),
+  name: z.string().optional(),
   mime: z.string().optional(),
   parent: z.number().optional(),
 });
@@ -310,13 +310,21 @@ export const SegmentGroupMetadata = z.object({
   }),
 });
 
-export const LabelMap = z.object({
-  id: z.string(),
-  path: z.string(),
-  metadata: SegmentGroupMetadata,
-});
+export const SegmentGroup = z
+  .object({
+    id: z.string(),
+    path: z.string().optional(),
+    dataSourceId: z.number().optional(),
+    metadata: SegmentGroupMetadata,
+  })
+  .refine(
+    (data) => data.path !== undefined || data.dataSourceId !== undefined,
+    {
+      message: 'Either path or dataSourceId is required',
+    }
+  );
 
-export type LabelMap = z.infer<typeof LabelMap>;
+export type SegmentGroup = z.infer<typeof SegmentGroup>;
 
 const LPSAxis = z.union([
   z.literal('Axial'),
@@ -329,20 +337,18 @@ const FrameOfReference = z.object({
   planeNormal: Vector3,
 }) satisfies z.ZodType<FrameOfReference>;
 
-type SerializedAnnotationTool = Omit<AnnotationTool, 'placing' | 'hidden'>;
-
 const annotationTool = z.object({
   imageID: z.string(),
   frameOfReference: FrameOfReference,
   slice: z.number(),
-  id: z.string() as unknown as z.ZodType<ToolID>,
-  name: z.string(),
-  color: z.string(),
+  id: z.string().optional() as unknown as z.ZodType<ToolID | undefined>,
+  name: z.string().optional(),
+  color: z.string().optional(),
   strokeWidth: z.number().optional(),
   label: z.string().optional(),
   labelName: z.string().optional(),
   metadata: z.record(z.string(), z.string()).optional(),
-}) satisfies z.ZodType<SerializedAnnotationTool>;
+});
 
 const makeToolEntry = <T extends z.ZodRawShape>(tool: z.ZodObject<T>) =>
   z.object({
@@ -350,35 +356,27 @@ const makeToolEntry = <T extends z.ZodRawShape>(tool: z.ZodObject<T>) =>
     labels: z.record(z.string(), tool.partial()),
   });
 
-type SerializedRuler = Omit<Ruler, 'placing' | 'hidden'>;
-
 const Ruler = annotationTool.extend({
   firstPoint: Vector3,
   secondPoint: Vector3,
-}) satisfies z.ZodType<SerializedRuler>;
+});
 
 const Rulers = makeToolEntry(Ruler);
 
-type SerializedRectangle = Omit<Rectangle, 'placing' | 'hidden' | 'fillColor'> &
-  Partial<Pick<Rectangle, 'fillColor'>>;
-
 const Rectangle = Ruler.extend({
   fillColor: z.string().optional(),
-}) satisfies z.ZodType<SerializedRectangle>;
+});
 
 const Rectangles = makeToolEntry(Rectangle);
 
-type SerializedPolygon = Omit<Polygon, 'placing' | 'hidden'>;
-
 const Polygon = annotationTool.extend({
-  id: z.string() as unknown as z.ZodType<ToolID>,
   points: z.array(Vector3),
-}) satisfies z.ZodType<SerializedPolygon>;
+});
 
 const Polygons = makeToolEntry(Polygon);
 
 const Crosshairs = z.object({
-  position: Vector3,
+  position: Vector3.optional(),
 });
 
 export type Crosshairs = z.infer<typeof Crosshairs>;
@@ -386,11 +384,11 @@ export type Crosshairs = z.infer<typeof Crosshairs>;
 const ToolsEnumNative = z.nativeEnum(ToolsEnum);
 
 const Paint = z.object({
-  activeSegmentGroupID: z.string().nullable(),
+  activeSegmentGroupID: z.string().nullable().optional(),
   activeSegment: z.number().nullish(),
-  brushSize: z.number(),
-  crossPlaneSync: z.boolean().default(false),
-  labelmapOpacity: z.number().optional(), // labelmapOpacity now ignored.  Opacity per segment group via layerColoring store.
+  brushSize: z.number().optional(),
+  crossPlaneSync: z.boolean().optional(),
+  labelmapOpacity: z.number().optional(),
 });
 
 const LPSCroppingPlanes = z.object({
@@ -405,10 +403,10 @@ const Tools = z.object({
   rulers: Rulers.optional(),
   rectangles: Rectangles.optional(),
   polygons: Polygons.optional(),
-  crosshairs: Crosshairs,
-  paint: Paint,
-  crop: Cropping,
-  current: ToolsEnumNative,
+  crosshairs: Crosshairs.optional(),
+  paint: Paint.optional(),
+  crop: Cropping.optional(),
+  current: ToolsEnumNative.optional(),
 });
 
 export type Tools = z.infer<typeof Tools>;
@@ -424,18 +422,18 @@ export type ParentToLayers = z.infer<typeof ParentToLayers>;
 
 export const ManifestSchema = z.object({
   version: z.string(),
-  datasets: Dataset.array(),
+  datasets: Dataset.array().optional(),
   dataSources: DataSource.array(),
-  datasetFilePath: z.record(z.string(), z.string()),
-  labelMaps: LabelMap.array(),
-  tools: Tools,
+  datasetFilePath: z.record(z.string(), z.string()).optional(),
+  segmentGroups: SegmentGroup.array().optional(),
+  tools: Tools.optional(),
   activeView: z.string().optional().nullable(),
-  isActiveViewMaximized: z.boolean(),
-  viewByID: z.record(z.string(), View),
+  isActiveViewMaximized: z.boolean().optional(),
+  viewByID: z.record(z.string(), View).optional(),
   primarySelection: z.string().optional(),
-  layout: Layout,
-  layoutSlots: z.array(z.string()),
-  parentToLayers: ParentToLayers,
+  layout: Layout.optional(),
+  layoutSlots: z.array(z.string()).optional(),
+  parentToLayers: ParentToLayers.optional(),
 });
 
 export type Manifest = z.infer<typeof ManifestSchema>;
diff --git a/src/io/state-file/index.ts b/src/io/state-file/serialize.ts
similarity index 82%
rename from src/io/state-file/index.ts
rename to src/io/state-file/serialize.ts
index 0d32b105f..b6f8bd774 100644
--- a/src/io/state-file/index.ts
+++ b/src/io/state-file/serialize.ts
@@ -5,14 +5,15 @@ import { useLayersStore } from '@/src/store/datasets-layers';
 import { useToolStore } from '@/src/store/tools';
 import { Tools } from '@/src/store/tools/types';
 import { useViewStore } from '@/src/store/views';
-import { Manifest } from '@/src/io/state-file/schema';
+import { Manifest, ManifestSchema } from '@/src/io/state-file/schema';
 
 import { retypeFile } from '@/src/io';
 import { ARCHIVE_FILE_TYPES } from '@/src/io/mimeTypes';
+import { migrateManifest } from '@/src/io/state-file/migrations';
 import { useViewConfigStore } from '@/src/store/view-configs';
 
 export const MANIFEST = 'manifest.json';
-export const MANIFEST_VERSION = '6.1.0';
+export const MANIFEST_VERSION = '6.2.0';
 
 export async function serialize() {
   const datasetStore = useDatasetStore();
@@ -27,7 +28,7 @@ export async function serialize() {
     datasets: [],
     dataSources: [],
     datasetFilePath: {},
-    labelMaps: [],
+    segmentGroups: [],
     tools: {
       crosshairs: {
         position: [0, 0, 0],
@@ -70,11 +71,22 @@ export async function serialize() {
 
 export async function isStateFile(file: File) {
   const typedFile = await retypeFile(file);
+
   if (ARCHIVE_FILE_TYPES.has(typedFile.type)) {
     const zip = await JSZip.loadAsync(typedFile);
-
     return zip.file(MANIFEST) !== null;
   }
 
+  if (typedFile.type === 'application/json') {
+    try {
+      const text = await file.text();
+      const migrated = migrateManifest(text);
+      ManifestSchema.parse(migrated);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
   return false;
 }
diff --git a/src/store/datasets-layers.ts b/src/store/datasets-layers.ts
index c444f251d..5e1a35561 100644
--- a/src/store/datasets-layers.ts
+++ b/src/store/datasets-layers.ts
@@ -124,11 +124,13 @@ export const useLayersStore = defineStore('layer', () => {
   }
 
   function deserialize(manifest: Manifest, dataIDMap: Record<string, string>) {
+    const parentToLayersSerialized = manifest.parentToLayers;
+    if (!parentToLayersSerialized) return;
+
     const remapSelection = (selection: DataSelection) => {
       return dataIDMap[selection];
     };
 
-    const { parentToLayers: parentToLayersSerialized } = manifest;
     parentToLayersSerialized.forEach(
       ({ selectionKey, sourceSelectionKeys }) => {
         const parent = remapSelection(selectionKey);
diff --git a/src/store/datasets.ts b/src/store/datasets.ts
index 95c39e247..05a257f76 100644
--- a/src/store/datasets.ts
+++ b/src/store/datasets.ts
@@ -157,12 +157,14 @@ export const useDatasetStore = defineStore('dataset', () => {
     manifest.dataSources = serializedDependencies;
 
     // add any locally loaded files
-    manifest.datasetFilePath = {};
-    Object.entries(files).forEach(([fileId, file]) => {
-      const filePath = `data/${fileId}/${file.name}`;
-      zip.file(filePath, file);
-      manifest.datasetFilePath[fileId] = filePath;
-    });
+    if (Object.keys(files).length > 0) {
+      manifest.datasetFilePath = {};
+      Object.entries(files).forEach(([fileId, file]) => {
+        const filePath = `data/${fileId}/${file.name}`;
+        zip.file(filePath, file);
+        manifest.datasetFilePath![fileId] = filePath;
+      });
+    }
   }
 
   const remove = (id: string | null) => {
diff --git a/src/store/image-cache.ts b/src/store/image-cache.ts
index 01e99e9e8..829b24e12 100644
--- a/src/store/image-cache.ts
+++ b/src/store/image-cache.ts
@@ -26,7 +26,13 @@ export const useImageCacheStore = defineStore('image-cache', () => {
 
   function getVtkImageData(id: Maybe<string>): Maybe<vtkImageData> {
     if (!id) return null;
-    return imageById[id]?.getVtkImageData() ?? null;
+    const image = imageById[id];
+    if (!image) return null;
+    const data = image.getVtkImageData();
+    // ProgressiveImage initializes with empty vtkImageData before actual data loads.
+    // VTK.js volume renderer crashes on empty data (null scalar texture).
+    if (!data.getPointData().getScalars()?.getData()?.length) return null;
+    return data;
   }
 
   function getImageMetadata(id: Maybe<string>): Maybe<ImageMetadata> {
diff --git a/src/store/remote-save-state.ts b/src/store/remote-save-state.ts
index c6c7ff118..aa7a671d0 100644
--- a/src/store/remote-save-state.ts
+++ b/src/store/remote-save-state.ts
@@ -1,4 +1,4 @@
-import { serialize } from '@/src/io/state-file';
+import { serialize } from '@/src/io/state-file/serialize';
 import { useMessageStore } from '@/src/store/messages';
 import { $fetch } from '@/src/utils/fetch';
 import { defineStore } from 'pinia';
diff --git a/src/store/segmentGroups.ts b/src/store/segmentGroups.ts
index e8c1959fc..e3b232adb 100644
--- a/src/store/segmentGroups.ts
+++ b/src/store/segmentGroups.ts
@@ -24,10 +24,12 @@ import {
   StateFile,
   Manifest,
   SegmentGroupMetadata,
+  SegmentGroup,
 } from '../io/state-file/schema';
 import { FileEntry } from '../io/types';
 import { ensureSameSpace } from '../io/resample/resample';
 import { untilLoaded } from '../composables/untilLoaded';
+import { useDatasetStore } from './datasets';
 
 const LabelmapArrayType = Uint8Array;
 export type LabelmapArrayType = Uint8Array;
@@ -476,7 +478,7 @@ export const useSegmentGroupStore = defineStore('segmentGroup', () => {
       });
     });
 
-    state.manifest.labelMaps = serialized;
+    state.manifest.segmentGroups = serialized;
 
     // save labelmap images
     await Promise.all(
@@ -497,40 +499,61 @@ export const useSegmentGroupStore = defineStore('segmentGroup', () => {
     stateFiles: FileEntry[],
     dataIDMap: Record<string, string>
   ) {
-    const { labelMaps } = manifest;
+    const { segmentGroups } = manifest;
+    const datasetStore = useDatasetStore();
 
     const segmentGroupIDMap: Record<string, string> = {};
 
+    if (!segmentGroups || segmentGroups.length === 0) {
+      return segmentGroupIDMap;
+    }
+
     // First restore the data, then restore the store.
     // This preserves ordering from orderByParent.
 
-    const newLabelmapIDs = await Promise.all(
-      labelMaps.map(async (labelMap) => {
-        const [file] = stateFiles
-          .filter((entry) => entry.archivePath === normalize(labelMap.path))
-          .map((entry) => entry.file);
+    async function loadSegmentGroupImage(segmentGroup: SegmentGroup) {
+      if (segmentGroup.dataSourceId !== undefined) {
+        const storeId = dataIDMap[String(segmentGroup.dataSourceId)];
+        await untilLoaded(storeId);
+        const image = imageCacheStore.getVtkImageData(storeId);
+        if (!image) {
+          throw new Error(
+            `Could not get image data for dataSourceId ${segmentGroup.dataSourceId}`
+          );
+        }
+        return { image, storeIdToRemove: storeId };
+      }
+
+      const file = stateFiles.find(
+        (entry) => entry.archivePath === normalize(segmentGroup.path!)
+      )?.file;
+      return { image: await readImage(file!) };
+    }
 
-        const vtkImage = await readImage(file);
-        const labelmapImage = toLabelMap(vtkImage);
+    const labelmapResults = await Promise.all(
+      segmentGroups.map(async (segmentGroup) => {
+        const { image, storeIdToRemove } =
+          await loadSegmentGroupImage(segmentGroup);
+        const labelmapImage = toLabelMap(image);
 
         const id = useIdStore().nextId();
         dataIndex[id] = labelmapImage;
-        return id;
+        return { id, storeIdToRemove };
       })
     );
 
-    labelMaps.forEach((labelMap, index) => {
-      const { metadata } = labelMap;
-      // map parent id to new id
-      const parentImage = dataIDMap[metadata.parentImage];
-      metadata.parentImage = parentImage;
-
-      const newID = newLabelmapIDs[index];
-      segmentGroupIDMap[labelMap.id] = newID;
+    segmentGroups.forEach((segmentGroup, index) => {
+      const { id: newID, storeIdToRemove } = labelmapResults[index];
+      segmentGroupIDMap[segmentGroup.id] = newID;
 
-      metadataByID[newID] = metadata;
+      const parentImage = dataIDMap[segmentGroup.metadata.parentImage];
+      metadataByID[newID] = { ...segmentGroup.metadata, parentImage };
       orderByParent.value[parentImage] ??= [];
       orderByParent.value[parentImage].push(newID);
+
+      if (storeIdToRemove) {
+        datasetStore.remove(storeIdToRemove);
+      }
     });
 
     return segmentGroupIDMap;
diff --git a/src/store/tools/crop.ts b/src/store/tools/crop.ts
index 771f9b986..f85b009e3 100644
--- a/src/store/tools/crop.ts
+++ b/src/store/tools/crop.ts
@@ -162,11 +162,13 @@ export const useCropStore = defineStore('crop', () => {
 
   function serialize(stateFile: StateFile) {
     const { tools } = stateFile.manifest;
+    if (!tools) return;
     tools.crop = state.croppingByImageID;
   }
 
   function deserialize(manifest: Manifest, dataIDMap: Record<string, string>) {
-    const cropping = manifest.tools.crop;
+    const cropping = manifest.tools?.crop;
+    if (!cropping) return;
 
     Object.entries(cropping).forEach(([imageID, planes]) => {
       const newImageID = dataIDMap[imageID];
diff --git a/src/store/tools/crosshairs.ts b/src/store/tools/crosshairs.ts
index 3e495aae2..6c6c861bc 100644
--- a/src/store/tools/crosshairs.ts
+++ b/src/store/tools/crosshairs.ts
@@ -111,13 +111,16 @@ export const useCrosshairsToolStore = defineStore('crosshairs', () => {
   }
 
   function serialize(state: StateFile) {
-    const { crosshairs } = state.manifest.tools;
+    const crosshairs = state.manifest.tools?.crosshairs;
+    if (!crosshairs) return;
     crosshairs.position = position.value;
   }
 
   function deserialize(manifest: Manifest) {
-    const { crosshairs } = manifest.tools;
-    position.value = crosshairs.position;
+    const crosshairsPosition = manifest.tools?.crosshairs?.position;
+    if (crosshairsPosition) {
+      position.value = crosshairsPosition;
+    }
   }
 
   return {
diff --git a/src/store/tools/index.ts b/src/store/tools/index.ts
index a60b2f073..0a95073b0 100644
--- a/src/store/tools/index.ts
+++ b/src/store/tools/index.ts
@@ -89,6 +89,7 @@ export const useToolStore = defineStore('tool', () => {
 
   function serialize(state: StateFile) {
     const { tools } = state.manifest;
+    if (!tools) return;
 
     Object.values(ToolStoreMap)
       .map((useStore) => useStore?.())
@@ -105,8 +106,6 @@ export const useToolStore = defineStore('tool', () => {
     segmentGroupIDMap: Record<string, string>,
     dataIDMap: Record<string, string>
   ) {
-    const { tools } = manifest;
-
     usePaintToolStore().deserialize(manifest, segmentGroupIDMap);
 
     Object.values(ToolStoreMap)
@@ -118,7 +117,9 @@ export const useToolStore = defineStore('tool', () => {
         store.deserialize?.(manifest, dataIDMap);
       });
 
-    currentTool.value = tools.current;
+    if (manifest.tools?.current) {
+      currentTool.value = manifest.tools.current;
+    }
   }
 
   return {
diff --git a/src/store/tools/paint.ts b/src/store/tools/paint.ts
index 1a6dae776..22070873e 100644
--- a/src/store/tools/paint.ts
+++ b/src/store/tools/paint.ts
@@ -10,6 +10,7 @@ import { defineStore } from 'pinia';
 import { PaintMode } from '@/src/core/tools/paint';
 import { getLPSAxisFromDir } from '@/src/utils/lps';
 import { get2DViewingVectors } from '@/src/utils/getViewingVectors';
+import { worldPointToIndex } from '@/src/utils/imageSpace';
 import { Tools } from './types';
 import { useSegmentGroupStore } from '../segmentGroups';
 import useViewSliceStore from '../view-configs/slicing';
@@ -196,14 +197,20 @@ export const usePaintToolStore = defineStore('paint', () => {
 
     const lastIndex = strokePoints.value.length - 1;
     if (lastIndex >= 0) {
-      const lastPoint = strokePoints.value[lastIndex];
-      const prevPoint =
+      const lastWorldPoint = strokePoints.value[lastIndex];
+      const prevWorldPoint =
         lastIndex >= 1 ? strokePoints.value[lastIndex - 1] : undefined;
+
+      const lastIndexPoint = worldPointToIndex(labelmap, lastWorldPoint);
+      const prevIndexPoint = prevWorldPoint
+        ? worldPointToIndex(labelmap, prevWorldPoint)
+        : undefined;
+
       this.$paint.paintLabelmap(
         labelmap,
         axisIndex,
-        lastPoint,
-        prevPoint,
+        lastIndexPoint,
+        prevIndexPoint,
         shouldPaint
       );
     }
@@ -250,32 +257,32 @@ export const usePaintToolStore = defineStore('paint', () => {
 
   function startStroke(
     this: _This,
-    indexPoint: vec3,
+    worldPoint: vec3,
     axisIndex: 0 | 1 | 2,
     imageID: string
   ) {
     switchToSegmentGroupForImage.call(this, imageID);
-    strokePoints.value = [vec3.clone(indexPoint)];
+    strokePoints.value = [vec3.clone(worldPoint)];
     doPaintStroke.call(this, axisIndex, imageID);
   }
 
   function placeStrokePoint(
     this: _This,
-    indexPoint: vec3,
+    worldPoint: vec3,
     axisIndex: 0 | 1 | 2,
     imageID: string
   ) {
-    strokePoints.value.push(indexPoint);
+    strokePoints.value.push(worldPoint);
     doPaintStroke.call(this, axisIndex, imageID);
   }
 
   function endStroke(
     this: _This,
-    indexPoint: vec3,
+    worldPoint: vec3,
     axisIndex: 0 | 1 | 2,
     imageID: string
   ) {
-    strokePoints.value.push(indexPoint);
+    strokePoints.value.push(worldPoint);
     doPaintStroke.call(this, axisIndex, imageID);
   }
 
@@ -370,7 +377,8 @@ export const usePaintToolStore = defineStore('paint', () => {
   }
 
   function serialize(state: StateFile) {
-    const { paint } = state.manifest.tools;
+    const paint = state.manifest.tools?.paint;
+    if (!paint) return;
 
     paint.activeSegmentGroupID = activeSegmentGroupID.value ?? null;
     paint.brushSize = brushSize.value;
@@ -383,11 +391,15 @@ export const usePaintToolStore = defineStore('paint', () => {
     manifest: Manifest,
     segmentGroupIDMap: Record<string, string>
   ) {
-    const { paint } = manifest.tools;
-    setBrushSize.call(this, paint.brushSize);
-    isActive.value = manifest.tools.current === Tools.Paint;
+    const paint = manifest.tools?.paint;
+    if (!paint) return;
+
+    if (paint.brushSize !== undefined) {
+      setBrushSize.call(this, paint.brushSize);
+    }
+    isActive.value = manifest.tools?.current === Tools.Paint;
 
-    if (paint.activeSegmentGroupID !== null) {
+    if (paint.activeSegmentGroupID) {
       activeSegmentGroupID.value =
         segmentGroupIDMap[paint.activeSegmentGroupID];
       setActiveSegmentGroup(activeSegmentGroupID.value);
diff --git a/src/store/tools/polygons.ts b/src/store/tools/polygons.ts
index 66300a4df..813d17e9c 100644
--- a/src/store/tools/polygons.ts
+++ b/src/store/tools/polygons.ts
@@ -184,11 +184,12 @@ export const usePolygonStore = defineAnnotationToolStore('polygon', () => {
   // --- serialization --- //
 
   function serialize(state: StateFile) {
+    if (!state.manifest.tools) return;
     state.manifest.tools.polygons = toolAPI.serializeTools();
   }
 
   function deserialize(manifest: Manifest, dataIDMap: Record<string, string>) {
-    toolAPI.deserializeTools(manifest.tools.polygons, dataIDMap);
+    toolAPI.deserializeTools(manifest.tools?.polygons, dataIDMap);
   }
 
   return {
diff --git a/src/store/tools/rectangles.ts b/src/store/tools/rectangles.ts
index adbb98a9d..ddf934b1b 100644
--- a/src/store/tools/rectangles.ts
+++ b/src/store/tools/rectangles.ts
@@ -33,11 +33,12 @@ export const useRectangleStore = defineAnnotationToolStore('rectangles', () => {
   // --- serialization --- //
 
   function serialize(state: StateFile) {
+    if (!state.manifest.tools) return;
     state.manifest.tools.rectangles = toolAPI.serializeTools();
   }
 
   function deserialize(manifest: Manifest, dataIDMap: Record<string, string>) {
-    toolAPI.deserializeTools(manifest.tools.rectangles, dataIDMap);
+    toolAPI.deserializeTools(manifest.tools?.rectangles, dataIDMap);
   }
 
   return {
diff --git a/src/store/tools/rulers.ts b/src/store/tools/rulers.ts
index f12a82cc4..b752e2d94 100644
--- a/src/store/tools/rulers.ts
+++ b/src/store/tools/rulers.ts
@@ -53,11 +53,12 @@ export const useRulerStore = defineAnnotationToolStore('ruler', () => {
   // --- serialization --- //
 
   function serialize(state: StateFile) {
+    if (!state.manifest.tools) return;
     state.manifest.tools.rulers = serializeTools();
   }
 
   function deserialize(manifest: Manifest, dataIDMap: Record<string, string>) {
-    deserializeTools(manifest.tools.rulers, dataIDMap);
+    deserializeTools(manifest.tools?.rulers, dataIDMap);
   }
 
   return {
diff --git a/src/store/view-configs.ts b/src/store/view-configs.ts
index adb60dfdb..81b6eb239 100644
--- a/src/store/view-configs.ts
+++ b/src/store/view-configs.ts
@@ -67,6 +67,8 @@ export const useViewConfigStore = defineStore('viewConfig', () => {
     manifest: StateFile['manifest'],
     dataIDMap: Record<string, string>
   ) => {
+    if (!manifest.viewByID) return;
+
     Object.entries(manifest.viewByID).forEach(([viewID, view]) => {
       if (view.config) {
         deserialize(viewID, view.config, dataIDMap);
diff --git a/src/store/view-configs/common.ts b/src/store/view-configs/common.ts
index b38495374..c4a67dc0d 100644
--- a/src/store/view-configs/common.ts
+++ b/src/store/view-configs/common.ts
@@ -12,8 +12,12 @@ const serializeViewConfig = <
   viewConfigs: DoubleKeyRecord<V>,
   viewConfigStateKey: K
 ) => {
-  const dataIDs = stateFile.manifest.datasets.map((dataset) => dataset.id);
-  const views = Object.values(stateFile.manifest.viewByID);
+  const datasets = stateFile.manifest.datasets;
+  const viewByID = stateFile.manifest.viewByID;
+  if (!datasets || !viewByID) return;
+
+  const dataIDs = datasets.map((dataset) => dataset.id);
+  const views = Object.values(viewByID);
 
   views.forEach((view) => {
     dataIDs.forEach((dataID) => {
diff --git a/src/store/views.ts b/src/store/views.ts
index 1e093695c..e6825d480 100644
--- a/src/store/views.ts
+++ b/src/store/views.ts
@@ -10,7 +10,7 @@ import {
   parseNamedLayouts,
   type LayoutConfig,
 } from '@/src/utils/layoutParsing';
-import type { StateFile } from '../io/state-file/schema';
+import type { Manifest, StateFile } from '../io/state-file/schema';
 
 const DEFAULT_VIEW_INIT: ViewInfoInit = {
   type: '2D',
@@ -307,24 +307,44 @@ export const useViewStore = defineStore('view', () => {
     manifest.viewByID = viewByID;
   }
 
-  function deserialize(
-    manifest: StateFile['manifest'],
-    dataIDMap: Record<string, string>
-  ) {
-    setLayout(manifest.layout);
+  function deserializeLayout(manifest: Manifest) {
+    if (manifest.layout) {
+      setLayout(manifest.layout);
+    }
     setActiveView(manifest.activeView);
-    isActiveViewMaximized.value = manifest.isActiveViewMaximized;
-    layoutSlots.value = manifest.layoutSlots;
+    if (manifest.isActiveViewMaximized !== undefined) {
+      isActiveViewMaximized.value = manifest.isActiveViewMaximized;
+    }
+    if (manifest.layoutSlots) {
+      layoutSlots.value = manifest.layoutSlots;
+    }
 
-    viewIDs.value.forEach((key) => {
-      delete viewByID[key];
-    });
+    if (manifest.viewByID) {
+      viewIDs.value.forEach((key) => {
+        delete viewByID[key];
+      });
+
+      Object.entries(manifest.viewByID).forEach(([id, view]) => {
+        viewByID[id] = {
+          ...view,
+          dataID: null,
+        } as unknown as ViewInfo;
+      });
+    }
+  }
+
+  function bindViewsToData(
+    stateID: string,
+    storeID: string,
+    manifest: Manifest
+  ) {
+    if (!manifest.viewByID) return;
 
     Object.entries(manifest.viewByID).forEach(([id, view]) => {
-      viewByID[id] = {
-        ...view,
-        dataID: view.dataID ? dataIDMap[view.dataID] : null,
-      } as unknown as ViewInfo;
+      if (view.dataID === stateID && viewByID[id]) {
+        viewByID[id].dataID = storeID;
+        ViewDataChangeEvent.trigger(id, storeID);
+      }
     });
   }
 
@@ -370,7 +390,8 @@ export const useViewStore = defineStore('view', () => {
     removeDataFromViews,
     toggleActiveViewMaximized,
     serialize,
-    deserialize,
+    deserializeLayout,
+    bindViewsToData,
     ViewDataChangeEvent,
     LayoutViewReplacedEvent,
   };
diff --git a/src/utils/imageSpace.ts b/src/utils/imageSpace.ts
index 11fcd57ca..370d1bbf5 100644
--- a/src/utils/imageSpace.ts
+++ b/src/utils/imageSpace.ts
@@ -1,7 +1,11 @@
 import { EPSILON } from '@/src/constants';
 import { areEquals } from '@kitware/vtk.js/Common/Core/Math';
 import vtkImageData from '@kitware/vtk.js/Common/DataModel/ImageData';
-import { Vector3 } from '@kitware/vtk.js/types';
+import type { Vector3 } from '@kitware/vtk.js/types';
+import { vec3 } from 'gl-matrix';
+import type { mat4 } from 'gl-matrix';
+import { getLPSDirections } from '@/src/utils/lps';
+import type { LPSAxis, LPSDirections } from '@/src/types/lps';
 
 // give more fp tolerance due to transforms
 const RELAXED_EPSILON = EPSILON * 1e2;
@@ -38,3 +42,46 @@ export function compareImageSpaces(
   const corners2 = getImageWorldCorners(im2);
   return corners1.every((p1) => corners2.some((p2) => areEquals(p1, p2, eps)));
 }
+
+/**
+ * Convert a world point to image index space.
+ */
+export function worldPointToIndex(image: vtkImageData, worldPoint: vec3): vec3 {
+  const indexPoint = vec3.create();
+  vec3.transformMat4(indexPoint, worldPoint, image.getWorldToIndex());
+  return indexPoint;
+}
+
+/**
+ * Convert an image index point to world space.
+ */
+export function indexPointToWorld(image: vtkImageData, indexPoint: vec3): vec3 {
+  const worldPoint = vec3.create();
+  vec3.transformMat4(worldPoint, indexPoint, image.getIndexToWorld());
+  return worldPoint;
+}
+
+/**
+ * Convert a slice index from source image space to target image space.
+ * Used when source and target have different coordinate systems.
+ */
+export function convertSliceIndex(
+  sourceSlice: number,
+  sourceLps: LPSDirections,
+  sourceIndexToWorld: mat4,
+  targetImage: vtkImageData,
+  axis: LPSAxis
+): number {
+  const sourceIjkIndex = sourceLps[axis];
+  const targetLps = getLPSDirections(targetImage.getDirection());
+  const targetIjkIndex = targetLps[axis];
+
+  const sourceIndexPoint = vec3.fromValues(0, 0, 0);
+  sourceIndexPoint[sourceIjkIndex] = sourceSlice;
+
+  const worldPoint = vec3.create();
+  vec3.transformMat4(worldPoint, sourceIndexPoint, sourceIndexToWorld);
+
+  const targetIndexPoint = worldPointToIndex(targetImage, worldPoint);
+  return Math.round(targetIndexPoint[targetIjkIndex]);
+}
diff --git a/src/utils/urlParams.test.ts b/src/utils/urlParams.test.ts
index c837fadb5..4bb977410 100644
--- a/src/utils/urlParams.test.ts
+++ b/src/utils/urlParams.test.ts
@@ -29,16 +29,6 @@ describe('normalizeUrlParams', () => {
     ]);
   });
 
-  it('handles comma-separated URLs', () => {
-    const result = normalizeUrlParams({
-      urls: 'https://example.com/file1.dcm,https://example.com/file2.dcm',
-    });
-    expect(result.urls).toEqual([
-      'https://example.com/file1.dcm',
-      'https://example.com/file2.dcm',
-    ]);
-  });
-
   it('allows relative URLs (they resolve against base URL)', () => {
     const result = normalizeUrlParams({
       urls: ['https://example.com/valid.dcm', 'relative-path', 'another/path'],
@@ -59,6 +49,15 @@ describe('normalizeUrlParams', () => {
     ]);
   });
 
+  it('preserves commas in query strings', () => {
+    const result = normalizeUrlParams({
+      urls: '/api/v1/folder/123/volview?items=id1,id2,id3',
+    });
+    expect(result.urls).toEqual([
+      '/api/v1/folder/123/volview?items=id1,id2,id3',
+    ]);
+  });
+
   it('handles config and names parameters', () => {
     const result = normalizeUrlParams({
       config: 'https://example.com/config.json',
diff --git a/src/utils/urlParams.ts b/src/utils/urlParams.ts
index a09eb6965..3146ad619 100644
--- a/src/utils/urlParams.ts
+++ b/src/utils/urlParams.ts
@@ -10,9 +10,7 @@ type ParsedUrlParams = {
 
 const isValidUrl = (str: string) => {
   try {
-    // eslint-disable-next-line no-new
-    new URL(str.trim(), window.location.href);
-    return true;
+    return !!new URL(str.trim(), window.location.href);
   } catch {
     return false;
   }
@@ -37,10 +35,6 @@ const parseUrlArray = (value: string | string[]): string[] => {
     return splitAndClean(trimmed.slice(1, -1));
   }
 
-  if (trimmed.includes(',')) {
-    return splitAndClean(trimmed);
-  }
-
   return [trimmed];
 };
 
diff --git a/src/vtk/PolygonFillRepresentation/index.js b/src/vtk/PolygonWidget/PolygonFillRepresentation.js
similarity index 100%
rename from src/vtk/PolygonFillRepresentation/index.js
rename to src/vtk/PolygonWidget/PolygonFillRepresentation.js
diff --git a/src/vtk/PolygonWidget/index.js b/src/vtk/PolygonWidget/index.js
index 9d3deb24f..fea6a3215 100644
--- a/src/vtk/PolygonWidget/index.js
+++ b/src/vtk/PolygonWidget/index.js
@@ -4,7 +4,7 @@ import vtkPlanePointManipulator from '@kitware/vtk.js/Widgets/Manipulators/Plane
 import vtkSphereHandleRepresentation from '@kitware/vtk.js/Widgets/Representations/SphereHandleRepresentation';
 import { Behavior } from '@kitware/vtk.js/Widgets/Representations/WidgetRepresentation/Constants';
 import vtkLineGlyphRepresentation from '@/src/vtk/LineGlyphRepresentation';
-import vtkPolygonFillRepresentation from '@/src/vtk/PolygonFillRepresentation';
+import vtkPolygonFillRepresentation from './PolygonFillRepresentation';
 
 import widgetBehavior from './behavior';
 import stateGenerator, { HandlesLabel, MoveHandleLabel } from './state';
diff --git a/tests/baseline/different_direction_labelmap_paint_coronal-chrome-linux-1200x800-1.png b/tests/baseline/different_direction_labelmap_paint_coronal-chrome-linux-1200x800-1.png
new file mode 100644
index 000000000..d96b80907
Binary files /dev/null and b/tests/baseline/different_direction_labelmap_paint_coronal-chrome-linux-1200x800-1.png differ
diff --git a/tests/fixtures/tools-prostate.3-0-0.volview.json b/tests/fixtures/tools-prostate.3-0-0.volview.json
deleted file mode 100644
index 40ae51e2b..000000000
--- a/tests/fixtures/tools-prostate.3-0-0.volview.json
+++ /dev/null
@@ -1,407 +0,0 @@
-{
-  "version": "3.0.0",
-  "datasets": [
-    {
-      "id": "1.3.6.1.4.1.14519.5.2.1.7311.5101.206828891270520544417996275680.5tse2d1254.538438420111018.1D000000SN0D000000S0D000000S0D000000S0D970296SN0D241922",
-      "path": "data/1.3.6.1.4.1.14519.5.2.1.7311.5101.206828891270520544417996275680.5tse2d1254.538438420111018.1D000000SN0D000000S0D000000S0D000000S0D970296SN0D241922/",
-      "type": "dicom"
-    }
-  ],
-  "remoteFiles": {
-    "1.3.6.1.4.1.14519.5.2.1.7311.5101.206828891270520544417996275680.5tse2d1254.538438420111018.1D000000SN0D000000S0D000000S0D000000S0D970296SN0D241922": [
-      {
-        "archiveSrc": { "path": "MRI-PROSTATEx-0004/1-19.dcm" },
-        "parent": {
-          "uriSrc": {
-            "uri": "https://data.kitware.com/api/v1/item/63527c7311dab8142820a338/download",
-            "name": "MRI-PROSTATEx-0004.zip"
-          }
-        }
-      },
-      {
-        "archiveSrc": { "path": "MRI-PROSTATEx-0004/1-18.dcm" },
-        "parent": {
-          "uriSrc": {
-            "uri": "https://data.kitware.com/api/v1/item/63527c7311dab8142820a338/download",
-            "name": "MRI-PROSTATEx-0004.zip"
-          }
-        }
-      },
-      {
-        "archiveSrc": { "path": "MRI-PROSTATEx-0004/1-17.dcm" },
-        "parent": {
-          "uriSrc": {
-            "uri": "https://data.kitware.com/api/v1/item/63527c7311dab8142820a338/download",
-            "name": "MRI-PROSTATEx-0004.zip"
-          }
-        }
-      },
-      {
-        "archiveSrc": { "path": "MRI-PROSTATEx-0004/1-16.dcm" },
-        "parent": {
-          "uriSrc": {
-            "uri": "https://data.kitware.com/api/v1/item/63527c7311dab8142820a338/download",
-            "name": "MRI-PROSTATEx-0004.zip"
-          }
-        }
-      },
-      {
-        "archiveSrc": { "path": "MRI-PROSTATEx-0004/1-15.dcm" },
-        "parent": {
-          "uriSrc": {
-            "uri": "https://data.kitware.com/api/v1/item/63527c7311dab8142820a338/download",
-            "name": "MRI-PROSTATEx-0004.zip"
-          }
-        }
-      },
-      {
-        "archiveSrc": { "path": "MRI-PROSTATEx-0004/1-14.dcm" },
-        "parent": {
-          "uriSrc": {
-            "uri": "https://data.kitware.com/api/v1/item/63527c7311dab8142820a338/download",
-            "name": "MRI-PROSTATEx-0004.zip"
-          }
-        }
-      },
-      {
-        "archiveSrc": { "path": "MRI-PROSTATEx-0004/1-13.dcm" },
-        "parent": {
-          "uriSrc": {
-            "uri": "https://data.kitware.com/api/v1/item/63527c7311dab8142820a338/download",
-            "name": "MRI-PROSTATEx-0004.zip"
-          }
-        }
-      },
-      {
-        "archiveSrc": { "path": "MRI-PROSTATEx-0004/1-12.dcm" },
-        "parent": {
-          "uriSrc": {
-            "uri": "https://data.kitware.com/api/v1/item/63527c7311dab8142820a338/download",
-            "name": "MRI-PROSTATEx-0004.zip"
-          }
-        }
-      },
-      {
-        "archiveSrc": { "path": "MRI-PROSTATEx-0004/1-11.dcm" },
-        "parent": {
-          "uriSrc": {
-            "uri": "https://data.kitware.com/api/v1/item/63527c7311dab8142820a338/download",
-            "name": "MRI-PROSTATEx-0004.zip"
-          }
-        }
-      },
-      {
-        "archiveSrc": { "path": "MRI-PROSTATEx-0004/1-10.dcm" },
-        "parent": {
-          "uriSrc": {
-            "uri": "https://data.kitware.com/api/v1/item/63527c7311dab8142820a338/download",
-            "name": "MRI-PROSTATEx-0004.zip"
-          }
-        }
-      },
-      {
-        "archiveSrc": { "path": "MRI-PROSTATEx-0004/1-09.dcm" },
-        "parent": {
-          "uriSrc": {
-            "uri": "https://data.kitware.com/api/v1/item/63527c7311dab8142820a338/download",
-            "name": "MRI-PROSTATEx-0004.zip"
-          }
-        }
-      },
-      {
-        "archiveSrc": { "path": "MRI-PROSTATEx-0004/1-08.dcm" },
-        "parent": {
-          "uriSrc": {
-            "uri": "https://data.kitware.com/api/v1/item/63527c7311dab8142820a338/download",
-            "name": "MRI-PROSTATEx-0004.zip"
-          }
-        }
-      },
-      {
-        "archiveSrc": { "path": "MRI-PROSTATEx-0004/1-07.dcm" },
-        "parent": {
-          "uriSrc": {
-            "uri": "https://data.kitware.com/api/v1/item/63527c7311dab8142820a338/download",
-            "name": "MRI-PROSTATEx-0004.zip"
-          }
-        }
-      },
-      {
-        "archiveSrc": { "path": "MRI-PROSTATEx-0004/1-06.dcm" },
-        "parent": {
-          "uriSrc": {
-            "uri": "https://data.kitware.com/api/v1/item/63527c7311dab8142820a338/download",
-            "name": "MRI-PROSTATEx-0004.zip"
-          }
-        }
-      },
-      {
-        "archiveSrc": { "path": "MRI-PROSTATEx-0004/1-05.dcm" },
-        "parent": {
-          "uriSrc": {
-            "uri": "https://data.kitware.com/api/v1/item/63527c7311dab8142820a338/download",
-            "name": "MRI-PROSTATEx-0004.zip"
-          }
-        }
-      },
-      {
-        "archiveSrc": { "path": "MRI-PROSTATEx-0004/1-04.dcm" },
-        "parent": {
-          "uriSrc": {
-            "uri": "https://data.kitware.com/api/v1/item/63527c7311dab8142820a338/download",
-            "name": "MRI-PROSTATEx-0004.zip"
-          }
-        }
-      },
-      {
-        "archiveSrc": { "path": "MRI-PROSTATEx-0004/1-03.dcm" },
-        "parent": {
-          "uriSrc": {
-            "uri": "https://data.kitware.com/api/v1/item/63527c7311dab8142820a338/download",
-            "name": "MRI-PROSTATEx-0004.zip"
-          }
-        }
-      },
-      {
-        "archiveSrc": { "path": "MRI-PROSTATEx-0004/1-02.dcm" },
-        "parent": {
-          "uriSrc": {
-            "uri": "https://data.kitware.com/api/v1/item/63527c7311dab8142820a338/download",
-            "name": "MRI-PROSTATEx-0004.zip"
-          }
-        }
-      },
-      {
-        "archiveSrc": { "path": "MRI-PROSTATEx-0004/1-01.dcm" },
-        "parent": {
-          "uriSrc": {
-            "uri": "https://data.kitware.com/api/v1/item/63527c7311dab8142820a338/download",
-            "name": "MRI-PROSTATEx-0004.zip"
-          }
-        }
-      }
-    ]
-  },
-  "labelMaps": [],
-  "tools": {
-    "crosshairs": { "position": [0, 0, 0] },
-    "paint": {
-      "activeSegmentGroupID": null,
-      "activeSegment": null,
-      "brushSize": 4,
-      "labelmapOpacity": 1
-    },
-    "crop": {
-      "10": {
-        "Sagittal": [-0.5, 383.5],
-        "Coronal": [-0.5, 383.5],
-        "Axial": [-0.5, 18.5]
-      }
-    },
-    "current": "Ruler",
-    "polygons": {
-      "tools": [
-        {
-          "imageID": "1.3.6.1.4.1.14519.5.2.1.7311.5101.206828891270520544417996275680.5tse2d1254.538438420111018.1D000000SN0D000000S0D000000S0D000000S0D970296SN0D241922",
-          "frameOfReference": {
-            "planeNormal": [
-              1.408073370182161e-17, 0.24192189256080032, 0.9702957270336713
-            ],
-            "planeOrigin": [
-              -117.91325380387, -75.35208161269456, 52.13696960699617
-            ]
-          },
-          "slice": 9,
-          "placing": false,
-          "color": "#ffffff",
-          "strokeWidth": 1,
-          "name": "Polygon",
-          "points": [
-            [-18.053922796672243, -55.928583890596556, 47.29414777633043],
-            [11.43659320468982, -15.117696849450404, 37.11885095186395],
-            [-31.590564517872114, -5.0322464081816385, 34.6042657691187]
-          ],
-          "id": "15",
-          "label": "9",
-          "labelName": "white",
-          "movePoint": null
-        }
-      ],
-      "labels": {
-        "7": { "labelName": "red", "color": "red", "strokeWidth": 1 },
-        "8": { "labelName": "green", "color": "#00ff00", "strokeWidth": 1 },
-        "9": { "labelName": "white", "color": "#ffffff", "strokeWidth": 1 }
-      }
-    },
-    "rectangles": {
-      "tools": [
-        {
-          "imageID": "1.3.6.1.4.1.14519.5.2.1.7311.5101.206828891270520544417996275680.5tse2d1254.538438420111018.1D000000SN0D000000S0D000000S0D000000S0D970296SN0D241922",
-          "frameOfReference": {
-            "planeNormal": [
-              1.408073370182161e-17, 0.24192189256080032, 0.9702957270336713
-            ],
-            "planeOrigin": [
-              -117.91325380387, -75.35208161269456, 52.13696960699617
-            ]
-          },
-          "slice": 9,
-          "placing": false,
-          "color": "red",
-          "strokeWidth": 1,
-          "name": "Rectangle",
-          "firstPoint": [
-            -56.7300165298934, -65.31039649940394, 49.633296345923895
-          ],
-          "secondPoint": [
-            -34.007813285594224, -51.23767954755222, 46.12457398055551
-          ],
-          "id": "11",
-          "fillColor": "transparent",
-          "label": "6",
-          "labelName": "lesion"
-        }
-      ],
-      "labels": {
-        "4": {
-          "labelName": "artifact",
-          "color": "#888888",
-          "strokeWidth": 1,
-          "fillColor": "transparent"
-        },
-        "5": {
-          "labelName": "innocuous",
-          "color": "#00ff00",
-          "strokeWidth": 1,
-          "fillColor": "transparent"
-        },
-        "6": {
-          "labelName": "lesion",
-          "color": "red",
-          "strokeWidth": 1,
-          "fillColor": "transparent"
-        }
-      }
-    },
-    "rulers": {
-      "tools": [
-        {
-          "imageID": "1.3.6.1.4.1.14519.5.2.1.7311.5101.206828891270520544417996275680.5tse2d1254.538438420111018.1D000000SN0D000000S0D000000S0D000000S0D970296SN0D241922",
-          "frameOfReference": {
-            "planeNormal": [
-              1.408073370182161e-17, 0.24192189256080032, 0.9702957270336713
-            ],
-            "planeOrigin": [
-              -117.91325380387, -75.35208161269456, 52.13696960699617
-            ]
-          },
-          "slice": 9,
-          "placing": false,
-          "color": "#ffffff",
-          "strokeWidth": 1,
-          "name": "Ruler",
-          "firstPoint": [
-            -49.23652102879336, -28.72132454079226, 40.510616230314696
-          ],
-          "secondPoint": [
-            14.579040930216323, -31.7704125712456, 41.270839249297595
-          ],
-          "id": "28",
-          "label": "3",
-          "labelName": "white"
-        },
-        {
-          "imageID": "1.3.6.1.4.1.14519.5.2.1.7311.5101.206828891270520544417996275680.5tse2d1254.538438420111018.1D000000SN0D000000S0D000000S0D000000S0D970296SN0D241922",
-          "frameOfReference": {
-            "planeNormal": [
-              1.408073370182161e-17, 0.24192189256080032, 0.9702957270336713
-            ],
-            "planeOrigin": [
-              -117.91325380387, -75.35208161269456, 52.13696960699617
-            ]
-          },
-          "slice": 9,
-          "placing": false,
-          "color": "#58f24c",
-          "strokeWidth": 3,
-          "name": "Ruler",
-          "firstPoint": [
-            -49.7199707777567, -16.29041996967262, 37.411243661415796
-          ],
-          "secondPoint": [
-            16.75455670028652, -20.043149753622366, 38.346904271174324
-          ],
-          "id": "31",
-          "label": "32",
-          "labelName": "New Label"
-        }
-      ],
-      "labels": {
-        "1": { "labelName": "red", "color": "red", "strokeWidth": 1 },
-        "2": { "labelName": "green", "color": "#00ff00", "strokeWidth": 1 },
-        "3": { "labelName": "white", "color": "#ffffff", "strokeWidth": 1 },
-        "32": { "labelName": "New Label", "color": "#58f24c", "strokeWidth": 3 }
-      }
-    }
-  },
-  "layout": {
-    "name": "Axial Primary",
-    "direction": "V",
-    "items": [
-      "Axial",
-      { "direction": "H", "items": ["3D", "Coronal", "Sagittal"] }
-    ]
-  },
-  "views": [
-    {
-      "id": "Coronal",
-      "type": "2D",
-      "props": { "viewDirection": "Posterior", "viewUp": "Superior" },
-      "config": {}
-    },
-    {
-      "id": "Sagittal",
-      "type": "2D",
-      "props": { "viewDirection": "Right", "viewUp": "Superior" },
-      "config": {}
-    },
-    {
-      "id": "Axial",
-      "type": "2D",
-      "props": { "viewDirection": "Superior", "viewUp": "Anterior" },
-      "config": {}
-    },
-    {
-      "id": "ObliqueCoronal",
-      "type": "Oblique",
-      "props": { "viewDirection": "Posterior", "viewUp": "Superior" },
-      "config": {}
-    },
-    {
-      "id": "ObliqueSagittal",
-      "type": "Oblique",
-      "props": { "viewDirection": "Right", "viewUp": "Superior" },
-      "config": {}
-    },
-    {
-      "id": "ObliqueAxial",
-      "type": "Oblique",
-      "props": { "viewDirection": "Superior", "viewUp": "Anterior" },
-      "config": {}
-    },
-    {
-      "id": "3D",
-      "type": "3D",
-      "props": { "viewDirection": "Posterior", "viewUp": "Superior" },
-      "config": {}
-    },
-    {
-      "id": "Oblique3D",
-      "type": "Oblique3D",
-      "props": { "viewDirection": "Posterior", "viewUp": "Superior" },
-      "config": {}
-    }
-  ],
-  "parentToLayers": [],
-  "primarySelection": "1.3.6.1.4.1.14519.5.2.1.7311.5101.206828891270520544417996275680.5tse2d1254.538438420111018.1D000000SN0D000000S0D000000S0D000000S0D970296SN0D241922"
-}
diff --git a/tests/specs/configTestUtils.ts b/tests/specs/configTestUtils.ts
index 9bb2759fa..2e731474e 100644
--- a/tests/specs/configTestUtils.ts
+++ b/tests/specs/configTestUtils.ts
@@ -11,6 +11,11 @@ export const MINIMAL_DICOM = {
   name: 'minimal.dcm',
 } as const;
 
+export const MINIMAL_501_SESSION = {
+  url: 'https://data.kitware.com/api/v1/file/693077d880eaefe49a4abb88/download',
+  name: 'minimal-501-session.volview.zip',
+} as const;
+
 export const ANOTHER_DICOM = {
   url: 'https://data.kitware.com/api/v1/file/655d42a694ef39bf0a4a8bb3/download',
   name: '1-001.dcm',
@@ -21,6 +26,48 @@ export const PROSTATEX_DATASET = {
   name: 'prostate.zip',
 } as const;
 
+export const PROSTATE_SEGMENT_GROUP = {
+  url: 'https://data.kitware.com/api/v1/file/692f13ed80eaefe49a4abb72/download',
+  name: 'prostate-total.seg.nii.gz',
+} as const;
+
+export const PROSTATE_610_LABELMAP_MANIFEST = {
+  version: '6.1.0',
+  dataSources: [
+    {
+      id: 0,
+      type: 'uri',
+      uri: `/tmp/${PROSTATEX_DATASET.name}`,
+    },
+    {
+      id: 1,
+      type: 'uri',
+      uri: `/tmp/${PROSTATE_SEGMENT_GROUP.name}`,
+    },
+  ],
+  labelMaps: [
+    {
+      id: 'seg-1',
+      dataSourceId: 1,
+      metadata: {
+        name: 'Prostate Segmentation',
+        parentImage: '0',
+        segments: {
+          order: [1],
+          byValue: {
+            '1': {
+              value: 1,
+              name: 'Prostate',
+              color: [255, 0, 0, 255],
+              visible: true,
+            },
+          },
+        },
+      },
+    },
+  ],
+} as const;
+
 export const MRA_HEAD_NECK_DATASET = {
   url: 'https://data.kitware.com/api/v1/item/6352a2b311dab8142820a33b/download',
   name: 'MRA-Head_and_Neck.zip',
diff --git a/tests/specs/different-direction-labelmap.e2e.ts b/tests/specs/different-direction-labelmap.e2e.ts
new file mode 100644
index 000000000..b755c0cf7
--- /dev/null
+++ b/tests/specs/different-direction-labelmap.e2e.ts
@@ -0,0 +1,115 @@
+import {
+  PROSTATEX_DATASET,
+  PROSTATE_SEGMENT_GROUP,
+  PROSTATE_610_LABELMAP_MANIFEST,
+} from './configTestUtils';
+import { downloadFile, writeManifestToFile } from './utils';
+import { volViewPage } from '../pageobjects/volview.page';
+import { DOWNLOAD_TIMEOUT, TEMP_DIR } from '../../wdio.shared.conf';
+import * as path from 'path';
+import * as fs from 'fs';
+import { cleanuptotal } from 'wdio-cleanuptotal-service';
+
+/**
+ * Regression test for labelmap with different direction matrix than parent image.
+ *
+ * The prostate DICOM and TotalSegmenter segment group have different direction matrices:
+ *   Base image:     [1, 0, 0,  0,  0.97, -0.24,  0, 0.24, 0.97]
+ *   Segment group:  [1, 0, 0,  0, -0.97,  0.24,  0, 0.24, 0.97]
+ *
+ * This caused bugs where paint tool painted at wrong location and
+ * coronal slice didn't show segment overlay.
+ */
+describe('Labelmap with different direction matrix', () => {
+  it('paint tool works on coronal view', async () => {
+    await downloadFile(PROSTATEX_DATASET.url, PROSTATEX_DATASET.name);
+    await downloadFile(PROSTATE_SEGMENT_GROUP.url, PROSTATE_SEGMENT_GROUP.name);
+
+    const config = {
+      layouts: {
+        'Coronal Only': [['coronal']],
+      },
+    };
+
+    const manifestFileName = 'different-direction-labelmap.volview.json';
+    await writeManifestToFile(PROSTATE_610_LABELMAP_MANIFEST, manifestFileName);
+
+    const configFileName = 'different-direction-labelmap-config.json';
+    const configFilePath = path.join(TEMP_DIR, configFileName);
+    await fs.promises.writeFile(configFilePath, JSON.stringify(config));
+    cleanuptotal.addCleanup(async () => {
+      fs.unlinkSync(configFilePath);
+    });
+
+    const urlParams = `?urls=[tmp/${manifestFileName}]&config=[tmp/${configFileName}]`;
+    await volViewPage.open(urlParams);
+    await volViewPage.waitForViews();
+    const notifications = await volViewPage.getNotificationsCount();
+    expect(notifications).toEqual(0);
+
+    const annotationsTab = await $(
+      'button[data-testid="module-tab-Annotations"]'
+    );
+    await annotationsTab.click();
+
+    const segmentGroupsTab = await $('button.v-tab*=Segment Groups');
+    await segmentGroupsTab.waitForClickable();
+    await segmentGroupsTab.click();
+
+    await browser.waitUntil(
+      async () => {
+        const segmentGroups = await $$('.segment-group-list .v-list-item');
+        return (await segmentGroups.length) >= 1;
+      },
+      {
+        timeout: DOWNLOAD_TIMEOUT,
+        timeoutMsg: 'Segment group not found in segment groups list',
+      }
+    );
+
+    await volViewPage.openLayoutMenu(1);
+    await volViewPage.selectLayoutOption('Coronal Only');
+    await volViewPage.waitForViewCounts(1, false);
+
+    await volViewPage.focusFirst2DView();
+    await volViewPage.advanceSliceAndWait();
+    await volViewPage.advanceSliceAndWait();
+    await volViewPage.advanceSliceAndWait();
+
+    await volViewPage.activatePaint();
+
+    const views2D = await volViewPage.getViews2D();
+    const coronalView = views2D[0];
+    const canvas = await coronalView.$('canvas');
+
+    const location = await canvas.getLocation();
+    const size = await canvas.getSize();
+    const centerX = location.x + size.width / 2;
+    const centerY = location.y + size.height / 2;
+
+    await browser
+      .action('pointer')
+      .move({ x: Math.round(centerX), y: Math.round(centerY) })
+      .down()
+      .move({ x: Math.round(centerX + 40), y: Math.round(centerY) })
+      .move({ x: Math.round(centerX + 40), y: Math.round(centerY + 40) })
+      .up()
+      .perform();
+
+    await browser.waitUntil(
+      async () => {
+        const result = await browser.checkElement(
+          coronalView,
+          'different_direction_labelmap_paint_coronal'
+        );
+        return (result as number) < 5;
+      },
+      {
+        timeout: 10000,
+        timeoutMsg:
+          'Paint stroke on coronal view with misaligned labelmap should match baseline',
+        interval: 1000,
+      }
+    );
+  });
+});
diff --git a/tests/specs/layers.e2e.ts b/tests/specs/layers-and-rendering.e2e.ts
similarity index 75%
rename from tests/specs/layers.e2e.ts
rename to tests/specs/layers-and-rendering.e2e.ts
index 6c1fd4f9d..02d5d7bdc 100644
--- a/tests/specs/layers.e2e.ts
+++ b/tests/specs/layers-and-rendering.e2e.ts
@@ -3,7 +3,35 @@ import { volViewPage } from '../pageobjects/volview.page';
 import { openUrls } from './utils';
 import { PROSTATEX_DATASET, MRA_HEAD_NECK_DATASET } from './configTestUtils';
 
-describe('Add Layer button', () => {
+describe('Layers and Rendering', () => {
+  it('should show 3D rendering controls regardless of active view', async () => {
+    await openUrls([PROSTATEX_DATASET]);
+
+    await volViewPage.waitForViews();
+
+    const renderTab = volViewPage.renderingModuleTab;
+    await renderTab.click();
+
+    const view3D = await volViewPage.getView3D();
+
+    const volumeRenderingSection =
+      await volViewPage.getVolumeRenderingSection();
+    await expect(volumeRenderingSection).toExist();
+    await expect(volumeRenderingSection).toBeDisplayed();
+
+    const pwfCanvas = await $('div.pwf-editor canvas');
+    await expect(pwfCanvas).toExist();
+
+    await view3D!.click();
+    await expect(volumeRenderingSection).toBeDisplayed();
+
+    const view2D = await volViewPage.getView2D();
+    await view2D!.click();
+
+    await expect(volumeRenderingSection).toBeDisplayed();
+    await expect(pwfCanvas).toExist();
+  });
+
   it('should create overlay with 2 DICOM images', async () => {
     await openUrls([PROSTATEX_DATASET, MRA_HEAD_NECK_DATASET]);
 
diff --git a/tests/specs/remote-manifest.e2e.ts b/tests/specs/remote-manifest.e2e.ts
index 382ea7af8..154760d19 100644
--- a/tests/specs/remote-manifest.e2e.ts
+++ b/tests/specs/remote-manifest.e2e.ts
@@ -9,7 +9,9 @@ describe('VolView loading of remoteManifest.json', () => {
     };
     const fileName = 'remoteFilesBadUrl.json';
     await writeManifestToFile(manifest, fileName);
-    await openVolViewPage(fileName);
+
+    const urlParams = `?urls=[tmp/${fileName}]`;
+    await volViewPage.open(urlParams);
 
     await volViewPage.waitForNotification();
   });
diff --git a/tests/specs/rendering-controls-3d-view.e2e.ts b/tests/specs/rendering-controls-3d-view.e2e.ts
deleted file mode 100644
index 2f15c5893..000000000
--- a/tests/specs/rendering-controls-3d-view.e2e.ts
+++ /dev/null
@@ -1,34 +0,0 @@
-import { volViewPage } from '../pageobjects/volview.page';
-import { openUrls } from './utils';
-import { PROSTATEX_DATASET } from './configTestUtils';
-
-describe('3D Rendering Controls', () => {
-  it('should show controls when 3D view exists regardless of active view', async () => {
-    await openUrls([PROSTATEX_DATASET]);
-
-    await volViewPage.waitForViews();
-
-    const renderTab = volViewPage.renderingModuleTab;
-    await renderTab.click();
-
-    const view3D = await volViewPage.getView3D();
-
-    const volumeRenderingSection =
-      await volViewPage.getVolumeRenderingSection();
-    await expect(volumeRenderingSection).toExist();
-    await expect(volumeRenderingSection).toBeDisplayed();
-
-    const pwfCanvas = await $('div.pwf-editor canvas');
-    await expect(pwfCanvas).toExist();
-
-    await view3D!.click();
-    await expect(volumeRenderingSection).toBeDisplayed();
-
-    const view2D = await volViewPage.getView2D();
-    await view2D!.click();
-
-    // Controls should still be displayed because 3D view exists (even if not active)
-    await expect(volumeRenderingSection).toBeDisplayed();
-    await expect(pwfCanvas).toExist();
-  });
-});
diff --git a/tests/specs/sample-rendering.e2e.ts b/tests/specs/sample-rendering.e2e.ts
index afea042f6..fc11c6d4d 100644
--- a/tests/specs/sample-rendering.e2e.ts
+++ b/tests/specs/sample-rendering.e2e.ts
@@ -1,22 +1,29 @@
 import AppPage from '../pageobjects/volview.page';
 
-// handle pixel jitter in 3D view
-const THRESHOLD = 12; // percent
+const THRESHOLD = 12; // percent - handle pixel jitter in 3D view
+const RENDER_STABLE_TIMEOUT = 5000;
 
 describe('VolView', () => {
   it('should load and render a sample dataset', async () => {
     await AppPage.open();
     await AppPage.downloadProstateSample();
     await AppPage.waitForViews();
-    await browser.pause(5000);
 
     const layoutContainer = await $('.layout-container');
 
-    const result = await browser.checkElement(
-      layoutContainer,
-      'prostate_sample_views'
+    await browser.waitUntil(
+      async () => {
+        const result = await browser.checkElement(
+          layoutContainer,
+          'prostate_sample_views'
+        );
+        return (result as number) < THRESHOLD;
+      },
+      {
+        timeout: RENDER_STABLE_TIMEOUT,
+        interval: 500,
+        timeoutMsg: `Visual comparison exceeded ${THRESHOLD}% threshold after ${RENDER_STABLE_TIMEOUT}ms`,
+      }
     );
-
-    await expect(result).toBeLessThan(THRESHOLD);
   });
 });
diff --git a/tests/specs/session-state-lifecycle.e2e.ts b/tests/specs/session-state-lifecycle.e2e.ts
new file mode 100644
index 000000000..ec88a95ce
--- /dev/null
+++ b/tests/specs/session-state-lifecycle.e2e.ts
@@ -0,0 +1,156 @@
+import * as path from 'path';
+import * as fs from 'fs';
+import JSZip from 'jszip';
+import { MINIMAL_501_SESSION } from './configTestUtils';
+import { downloadFile } from './utils';
+import { setValueVueInput, volViewPage } from '../pageobjects/volview.page';
+import { TEMP_DIR } from '../../wdio.shared.conf';
+
+const SESSION_SAVE_TIMEOUT = 40000;
+
+const waitForFileExists = (filePath: string, timeout: number) =>
+  new Promise<void>((resolve, reject) => {
+    const dir = path.dirname(filePath);
+    const basename = path.basename(filePath);
+
+    const watcher = fs.watch(dir, (eventType, filename) => {
+      if (eventType === 'rename' && filename === basename) {
+        clearTimeout(timerId);
+        watcher.close();
+        resolve();
+      }
+    });
+
+    const timerId = setTimeout(() => {
+      watcher.close();
+      reject(
+        new Error(
+          `File ${filePath} did not exist and was not created during timeout of ${timeout}ms`
+        )
+      );
+    }, timeout);
+
+    fs.access(filePath, fs.constants.R_OK, (err) => {
+      if (!err) {
+        clearTimeout(timerId);
+        watcher.close();
+        resolve();
+      }
+    });
+  });
+
+const saveSession = async () => {
+  const sessionFileName = await volViewPage.saveSession();
+  const downloadedPath = path.join(TEMP_DIR, sessionFileName);
+  await waitForFileExists(downloadedPath, SESSION_SAVE_TIMEOUT);
+  return sessionFileName;
+};
+
+const parseManifest = async (sessionFileName: string) => {
+  const session = fs.readFileSync(path.join(TEMP_DIR, sessionFileName));
+  const zip = await JSZip.loadAsync(session);
+  const manifestFile = await zip.files['manifest.json'].async('string');
+  return JSON.parse(manifestFile);
+};
+
+const saveAndParseManifest = async () => {
+  const session = await saveSession();
+  let manifest: Record<string, unknown> = {};
+  await browser.waitUntil(async () => {
+    try {
+      manifest = await parseManifest(session);
+      return manifest.version !== undefined;
+    } catch {
+      return false;
+    }
+  });
+  return { session, manifest };
+};
+
+const loadSession = async () => {
+  await downloadFile(MINIMAL_501_SESSION.url, MINIMAL_501_SESSION.name);
+  const urlParams = `?urls=[tmp/${MINIMAL_501_SESSION.name}]`;
+  await volViewPage.open(urlParams);
+  await volViewPage.waitForViews();
+};
+
+describe('Session state lifecycle', () => {
+  it('migrates 5.0.1 session with rectangle, polygons, and labelmap', async () => {
+    await loadSession();
+
+    const notifications = await volViewPage.getNotificationsCount();
+    expect(notifications).toEqual(0);
+
+    const annotationsTab = await $(
+      'button[data-testid="module-tab-Annotations"]'
+    );
+    await annotationsTab.click();
+
+    const measurementsTab = await $('button.v-tab*=Measurements');
+    await measurementsTab.waitForClickable();
+    await measurementsTab.click();
+
+    await browser.waitUntil(async () => {
+      const rectangleEntries = await $$(
+        '.v-list-item i.mdi-vector-square.tool-icon'
+      );
+      return (await rectangleEntries.length) >= 1;
+    });
+
+    await browser.waitUntil(async () => {
+      const polygonEntries = await $$(
+        '.v-list-item i.mdi-pentagon-outline.tool-icon'
+      );
+      return (await polygonEntries.length) >= 1;
+    });
+
+    const segmentGroupsTab = await $('button.v-tab*=Segment Groups');
+    await segmentGroupsTab.waitForClickable();
+    await segmentGroupsTab.click();
+
+    await browser.waitUntil(async () => {
+      const segmentGroups = await $$('.segment-group-list .v-list-item');
+      return (await segmentGroups.length) >= 1;
+    });
+  });
+
+  it('edited label strokeWidth persists through save/load cycle', async () => {
+    await loadSession();
+
+    const editedStrokeWidth = 9;
+
+    // Activate rectangle tool to show RectangleControls with LabelControls
+    await volViewPage.activateRectangle();
+
+    const annotationsTab = await $(
+      'button[data-testid="module-tab-Annotations"]'
+    );
+    await annotationsTab.click();
+
+    await browser.waitUntil(async () => {
+      const buttons = await volViewPage.editLabelButtons;
+      return (await buttons.length) >= 1;
+    });
+
+    const buttons = await volViewPage.editLabelButtons;
+    await buttons[0].click();
+
+    const input = await volViewPage.labelStrokeWidthInput;
+    await setValueVueInput(input, editedStrokeWidth.toString());
+
+    const done = await volViewPage.editLabelModalDoneButton;
+    await done.click();
+
+    const { session } = await saveAndParseManifest();
+
+    const sessionZip = `?urls=[tmp/${session}]`;
+    await volViewPage.open(sessionZip);
+    await volViewPage.waitForViews();
+
+    const { manifest: reloadedManifest } = await saveAndParseManifest();
+    const tools = reloadedManifest.tools as {
+      rectangles: { tools: Array<{ strokeWidth: number }> };
+    };
+    expect(tools.rectangles.tools[0].strokeWidth).toEqual(editedStrokeWidth);
+  });
+});
diff --git a/tests/specs/session-zip.e2e.ts b/tests/specs/session-zip.e2e.ts
deleted file mode 100644
index 25c2b8770..000000000
--- a/tests/specs/session-zip.e2e.ts
+++ /dev/null
@@ -1,184 +0,0 @@
-import * as path from 'path';
-import * as fs from 'fs';
-import JSZip from 'jszip';
-import type { ChainablePromiseElement } from 'webdriverio';
-import { cleanuptotal } from 'wdio-cleanuptotal-service';
-import { setValueVueInput, volViewPage } from '../pageobjects/volview.page';
-import { TEMP_DIR } from '../../wdio.shared.conf';
-
-const SESSION_SAVE_TIMEOUT = 40000;
-const SLOW_INTERACTION_TIMEOUT = 10000;
-
-// from https://stackoverflow.com/a/47764403
-function waitForFileExists(filePath: string, timeout: number) {
-  return new Promise<void>((resolve, reject) => {
-    const dir = path.dirname(filePath);
-    const basename = path.basename(filePath);
-
-    const watcher = fs.watch(dir, (eventType: any, filename: string | null) => {
-      if (eventType === 'rename' && filename === basename) {
-        clearTimeout(timerId);
-        watcher.close();
-        resolve();
-      }
-    });
-
-    const onTimeout = () => {
-      watcher.close();
-      reject(
-        new Error(
-          `File ${filePath} did not exists and was not created during the timeout of ${timeout} ms}`
-        )
-      );
-    };
-
-    const timerId = setTimeout(onTimeout, timeout);
-
-    // check if file already exists
-    fs.access(filePath, fs.constants.R_OK, (err) => {
-      if (!err) {
-        clearTimeout(timerId);
-        watcher.close();
-        resolve();
-      }
-    });
-  });
-}
-
-const saveSession = async () => {
-  const sessionFileName = await volViewPage.saveSession();
-  const downloadedPath = path.join(TEMP_DIR, sessionFileName);
-  await waitForFileExists(downloadedPath, SESSION_SAVE_TIMEOUT);
-  return sessionFileName;
-};
-
-const parseManifest = async (sessionFileName: string) => {
-  const session = fs.readFileSync(path.join(TEMP_DIR, sessionFileName));
-  const zip = await JSZip.loadAsync(session);
-  const manifestFile = await zip.files['manifest.json'].async('string');
-  return JSON.parse(manifestFile);
-};
-
-const saveGetManifest = async () => {
-  const session = await saveSession();
-  await browser.pause(1000); // wait for writing to finish before unzipping?
-  const manifest = await parseManifest(session);
-  return { session, manifest };
-};
-
-const getRectangleCount = async (view: ChainablePromiseElement) => {
-  const rectangles = await view.$$(
-    'svg[data-testid="rectangle-tool-container"] > g'
-  );
-  return rectangles.length;
-};
-
-const waitForRectangleCount = async (
-  view: ChainablePromiseElement,
-  countTarget: number
-) => {
-  await browser.waitUntil(
-    async function newRectangleExist() {
-      const toolCount = await getRectangleCount(view);
-      return toolCount >= countTarget;
-    },
-    {
-      timeoutMsg: `expected ${countTarget} rectangles to be drawn in ${SLOW_INTERACTION_TIMEOUT} ms}`,
-      timeout: SLOW_INTERACTION_TIMEOUT,
-    }
-  );
-};
-
-const clickTwice = async (view: ChainablePromiseElement) => {
-  await view.waitForClickable();
-  const origin = view;
-  await browser
-    .action('pointer')
-    .move({ duration: 10, origin, x: 0, y: 0 })
-    .down({ button: 0 }) // left button
-    .up({ button: 0 })
-    .pause(10)
-    .move({ duration: 10, origin, x: 30, y: 30 })
-    .pause(10)
-    .down({ button: 0 }) // left button
-    .pause(10)
-    .up({ button: 0 })
-    .perform();
-};
-
-const annotate = async () => {
-  await volViewPage.open();
-  await volViewPage.downloadProstateSample();
-  await volViewPage.waitForViews();
-
-  // draw rectangle
-  await volViewPage.activateRectangle();
-  const view = await volViewPage.viewTwoContainer;
-  await waitForRectangleCount(view, 1); // wait for placing tool
-  await clickTwice(view);
-  await waitForRectangleCount(view, 2); // wait for drawn tool
-};
-
-describe('VolView config and deserialization', () => {
-  it('config.json files should override label props of existing tool', async () => {
-    await annotate();
-
-    const newColor = 'green';
-
-    const { manifest, session } = await saveGetManifest();
-
-    expect(manifest.tools.rectangles.tools.length).toEqual(1);
-    expect(manifest.tools.rectangles.tools?.[0].color).not.toEqual(newColor);
-
-    const config = {
-      labels: {
-        defaultLabels: {
-          lesion: {
-            color: newColor,
-          },
-        },
-      },
-    };
-
-    // write object as json to file
-    const configFileName = 'config.json';
-    const configPath = path.join(TEMP_DIR, configFileName);
-    await fs.promises.writeFile(configPath, JSON.stringify(config));
-    cleanuptotal.addCleanup(async () => {
-      fs.unlinkSync(configPath);
-    });
-
-    const sessionZipAndConfig = `?urls=[tmp/${configFileName},tmp/${session}]`;
-    await volViewPage.open(sessionZipAndConfig);
-
-    await volViewPage.waitForViews();
-
-    const { manifest: changedManifest } = await saveGetManifest();
-    expect(changedManifest.tools.rectangles.tools?.[0].color).toEqual(newColor);
-  });
-
-  it('edited default label is serialized and deserialized', async () => {
-    await annotate();
-
-    const editedStrokeWidth = 9;
-
-    const buttons = await volViewPage.editLabelButtons;
-    await buttons[2].click();
-    const input = await volViewPage.labelStrokeWidthInput;
-    await setValueVueInput(input, editedStrokeWidth.toString());
-
-    const done = await volViewPage.editLabelModalDoneButton;
-    await done.click();
-
-    const { session } = await saveGetManifest();
-
-    const sessionZip = `?urls=[tmp/${session}]`;
-    await volViewPage.open(sessionZip);
-    await volViewPage.waitForViews();
-
-    const { manifest: changedManifest } = await saveGetManifest();
-    expect(changedManifest.tools.rectangles.tools?.[0].strokeWidth).toEqual(
-      editedStrokeWidth
-    );
-  });
-});
diff --git a/tests/specs/sparse-manifest-prostate-rectangle.e2e.ts b/tests/specs/sparse-manifest-prostate-rectangle.e2e.ts
new file mode 100644
index 000000000..5d712f6b1
--- /dev/null
+++ b/tests/specs/sparse-manifest-prostate-rectangle.e2e.ts
@@ -0,0 +1,95 @@
+import { PROSTATEX_DATASET } from './configTestUtils';
+import { downloadFile, openVolViewPage, writeManifestToZip } from './utils';
+
+describe('Sparse manifest with prostate rectangle', () => {
+  it('loads prostate dataset with lesion rectangle annotation', async () => {
+    await downloadFile(PROSTATEX_DATASET.url, PROSTATEX_DATASET.name);
+
+    const sparseManifest = {
+      version: '6.1.0',
+      dataSources: [
+        {
+          id: 0,
+          type: 'uri',
+          uri: `/tmp/${PROSTATEX_DATASET.name}`,
+        },
+      ],
+      tools: {
+        rectangles: {
+          tools: [
+            {
+              imageID: '0',
+              frameOfReference: {
+                planeNormal: [
+                  1.4080733262381892e-17, 0.24192188680171967,
+                  0.9702957272529602,
+                ],
+                planeOrigin: [
+                  -117.91325380387, -75.35208187384475, 52.136969503946816,
+                ],
+              },
+              slice: 9,
+              firstPoint: [
+                -65.36087045590452, -15.919061788109012, 37.31865385684797,
+              ],
+              secondPoint: [
+                22.78165684736155, 47.65944636974224, 21.46675198654735,
+              ],
+              label: 'lesion',
+            },
+          ],
+          labels: {
+            lesion: {
+              labelName: 'lesion',
+              color: 'red',
+              strokeWidth: 1,
+              fillColor: 'transparent',
+            },
+          },
+        },
+      },
+    };
+
+    const fileName = 'sparse-prostate-lesion-rectangle.volview.zip';
+    await writeManifestToZip(sparseManifest, fileName);
+    await openVolViewPage(fileName);
+
+    const annotationsTab = await $(
+      'button[data-testid="module-tab-Annotations"]'
+    );
+    await annotationsTab.click();
+
+    const measurementsTab = await $('button.v-tab*=Measurements');
+    await measurementsTab.waitForClickable();
+    await measurementsTab.click();
+
+    await browser.waitUntil(
+      async () => {
+        const rectangleEntries = await $$(
+          '.v-list-item i.mdi-vector-square.tool-icon'
+        );
+        const count = await rectangleEntries.length;
+        return count >= 1;
+      },
+      {
+        timeout: 10000,
+        timeoutMsg: 'Rectangle tool not found in measurements list',
+      }
+    );
+
+    await browser.waitUntil(
+      async () => {
+        const listItemTitles = await $$('.v-list-item .v-list-item-title');
+        for (const title of listItemTitles) {
+          const text = await title.getText();
+          if (text.includes('lesion')) return true;
+        }
+        return false;
+      },
+      {
+        timeout: 5000,
+        timeoutMsg: 'Lesion label not found on rectangle annotation',
+      }
+    );
+  });
+});
diff --git a/tests/specs/sparse-manifest.e2e.ts b/tests/specs/sparse-manifest.e2e.ts
new file mode 100644
index 000000000..e160cae5e
--- /dev/null
+++ b/tests/specs/sparse-manifest.e2e.ts
@@ -0,0 +1,157 @@
+import {
+  MINIMAL_DICOM,
+  PROSTATEX_DATASET,
+  PROSTATE_SEGMENT_GROUP,
+  PROSTATE_610_LABELMAP_MANIFEST,
+} from './configTestUtils';
+import {
+  downloadFile,
+  openVolViewPage,
+  writeManifestToFile,
+  writeManifestToZip,
+} from './utils';
+import { DOWNLOAD_TIMEOUT } from '../../wdio.shared.conf';
+
+describe('Sparse manifest.json', () => {
+  it('loads manifest with only URL data source', async () => {
+    await downloadFile(MINIMAL_DICOM.url, MINIMAL_DICOM.name);
+
+    const sparseManifest = {
+      version: '6.1.0',
+      dataSources: [
+        {
+          id: 0,
+          type: 'uri',
+          uri: `/tmp/${MINIMAL_DICOM.name}`,
+        },
+      ],
+    };
+
+    const fileName = 'sparse-url-only.volview.zip';
+    await writeManifestToZip(sparseManifest, fileName);
+    await openVolViewPage(fileName);
+  });
+
+  it('loads sparse manifest with tools section (rectangle)', async () => {
+    await downloadFile(MINIMAL_DICOM.url, MINIMAL_DICOM.name);
+
+    const sparseManifest = {
+      version: '6.1.0',
+      dataSources: [
+        {
+          id: 0,
+          type: 'uri',
+          uri: `/tmp/${MINIMAL_DICOM.name}`,
+        },
+      ],
+      tools: {
+        rectangles: {
+          tools: [
+            {
+              imageID: '0',
+              frameOfReference: {
+                planeOrigin: [0, 0, 0],
+                planeNormal: [0, 0, 1],
+              },
+              slice: 0,
+              firstPoint: [10, 10, 0],
+              secondPoint: [50, 50, 0],
+              label: 'default',
+            },
+          ],
+          labels: {
+            default: {
+              color: '#ff0000',
+              strokeWidth: 2,
+            },
+          },
+        },
+      },
+    };
+
+    const fileName = 'sparse-url-rectangle.volview.zip';
+    await writeManifestToZip(sparseManifest, fileName);
+    await openVolViewPage(fileName);
+
+    const annotationsTab = await $(
+      'button[data-testid="module-tab-Annotations"]'
+    );
+    await annotationsTab.click();
+
+    const measurementsTab = await $('button.v-tab*=Measurements');
+    await measurementsTab.waitForClickable();
+    await measurementsTab.click();
+
+    await browser.waitUntil(
+      async () => {
+        const rectangleEntries = await $$(
+          '.v-list-item i.mdi-vector-square.tool-icon'
+        );
+        const count = await rectangleEntries.length;
+        return count >= 1;
+      },
+      {
+        timeout: 5000,
+        timeoutMsg: 'Rectangle tool not found in measurements list',
+      }
+    );
+  });
+
+  it('loads standalone JSON state file (not zipped)', async () => {
+    await downloadFile(MINIMAL_DICOM.url, MINIMAL_DICOM.name);
+
+    const sparseManifest = {
+      version: '6.1.0',
+      dataSources: [
+        {
+          id: 0,
+          type: 'uri',
+          uri: `/tmp/${MINIMAL_DICOM.name}`,
+        },
+      ],
+    };
+
+    const fileName = 'standalone-state.volview.json';
+    await writeManifestToFile(sparseManifest, fileName);
+    await openVolViewPage(fileName);
+  });
+
+  it('loads remote segment group from URI', async () => {
+    await downloadFile(PROSTATEX_DATASET.url, PROSTATEX_DATASET.name);
+    await downloadFile(PROSTATE_SEGMENT_GROUP.url, PROSTATE_SEGMENT_GROUP.name);
+
+    const fileName = 'remote-segment-group.volview.json';
+    await writeManifestToFile(PROSTATE_610_LABELMAP_MANIFEST, fileName);
+    await openVolViewPage(fileName);
+
+    const annotationsTab = await $(
+      'button[data-testid="module-tab-Annotations"]'
+    );
+    await annotationsTab.click();
+
+    const segmentGroupsTab = await $('button.v-tab*=Segment Groups');
+    await segmentGroupsTab.waitForClickable();
+    await segmentGroupsTab.click();
+
+    await browser.waitUntil(
+      async () => {
+        const segmentGroups = await $$('.segment-group-list .v-list-item');
+        const count = await segmentGroups.length;
+        return count >= 1;
+      },
+      {
+        timeout: DOWNLOAD_TIMEOUT,
+        timeoutMsg: 'Segment group not found in segment groups list',
+      }
+    );
+
+    // Verify the segment group source image is NOT in the Anonymous section
+    const dataTab = await $('button[data-testid="module-tab-Data"]');
+    await dataTab.click();
+
+    // The Anonymous panel should not exist since the labelmap source image should be removed
+    const anonymousPanelTitle = await $('.v-expansion-panel-title*=Anonymous');
+    const exists = await anonymousPanelTitle.isExisting();
+    expect(exists).toBe(false);
+  });
+});
diff --git a/tests/specs/state-manifest.e2e.ts b/tests/specs/state-manifest.e2e.ts
index 6ab92db55..78d953e5b 100644
--- a/tests/specs/state-manifest.e2e.ts
+++ b/tests/specs/state-manifest.e2e.ts
@@ -1,53 +1,7 @@
 import * as path from 'path';
-import * as fs from 'fs';
-import { cleanuptotal } from 'wdio-cleanuptotal-service';
-import JSZip from 'jszip';
-import { FIXTURES, TEMP_DIR } from '../../wdio.shared.conf';
+import { FIXTURES, WINDOW_SIZE } from '../../wdio.shared.conf';
 import { volViewPage } from '../pageobjects/volview.page';
-
-async function writeManifestToZip(manifestPath: string, fileName: string) {
-  const filePath = path.join(TEMP_DIR, fileName);
-  const manifest = fs.readFileSync(manifestPath);
-
-  const zip = new JSZip();
-  zip.file('manifest.json', manifest);
-  const data = await zip.generateAsync({ type: 'nodebuffer' });
-
-  await fs.promises.writeFile(filePath, data);
-  cleanuptotal.addCleanup(async () => {
-    fs.unlinkSync(filePath);
-  });
-
-  return filePath;
-}
-
-async function openVolViewPage(fileName: string) {
-  const urlParams = `?urls=[tmp/${fileName}]`;
-  await volViewPage.open(urlParams);
-  await volViewPage.waitForViews();
-  const notifications = await volViewPage.getNotificationsCount();
-  expect(notifications).toEqual(0);
-
-  // Check that no placeholder overlays are visible (mdi-image-off icons)
-  // The overlays are in divs that are shown/hidden based on imageID
-  await browser.waitUntil(
-    async () => {
-      const visibleOverlayCount = await browser.execute(() => {
-        const imageOffIcons = document.querySelectorAll('i.mdi-image-off');
-        return Array.from(imageOffIcons).filter((icon) => {
-          const parent = icon.closest('div.overlay');
-          if (!parent) return false;
-          const style = window.getComputedStyle(parent);
-          return style.display !== 'none' && style.visibility !== 'hidden';
-        }).length;
-      });
-      return visibleOverlayCount === 0;
-    },
-    {
-      timeoutMsg: 'Image placeholder overlays are still visible',
-    }
-  );
-}
+import { openVolViewPage, writeManifestToZip } from './utils';
 
 describe('State file manifest.json code', () => {
   it('has no errors loading version 5.0.1 manifest.json file ', async () => {
@@ -61,24 +15,19 @@ describe('State file manifest.json code', () => {
   });
 
   it('loads 5.0.1 manifest with axial layer layout', async () => {
+    await browser.reloadSession();
+    await browser.setWindowSize(...WINDOW_SIZE);
     const manifestPath = path.join(FIXTURES, 'layer-axial.5-0-1.volview.json');
     const fileName = 'temp-layer-axial.volview.zip';
     await writeManifestToZip(manifestPath, fileName);
     await openVolViewPage(fileName);
 
-    // Switch to the Rendering tab
-    const renderingTab = await $('button[data-testid="module-tab-Rendering"]');
+    const renderingTab = volViewPage.renderingModuleTab;
     await renderingTab.click();
 
-    // Wait for and verify that the layer opacity slider is visible
-    await browser.waitUntil(
-      async () => {
-        const layerSlider = await $('[data-testid="layer-opacity-slider"]');
-        return layerSlider.isDisplayed();
-      },
-      {
-        timeoutMsg: 'Layer opacity slider is not visible in the Rendering tab',
-      }
-    );
+    const layerSlider = $('[data-testid="layer-opacity-slider"]');
+    await layerSlider.waitForDisplayed({
+      timeoutMsg: 'Layer opacity slider is not visible in the Rendering tab',
+    });
   });
 });
diff --git a/tests/specs/utils.ts b/tests/specs/utils.ts
index 41c74e57e..0c1b809de 100644
--- a/tests/specs/utils.ts
+++ b/tests/specs/utils.ts
@@ -2,6 +2,7 @@ import * as path from 'path';
 import * as fs from 'fs';
 import { z } from 'zod';
 import { cleanuptotal } from 'wdio-cleanuptotal-service';
+import JSZip from 'jszip';
 import { TEMP_DIR } from '../../wdio.shared.conf';
 import { volViewPage } from '../pageobjects/volview.page';
 import { RemoteResource } from '../../src/io/manifest';
@@ -36,7 +37,7 @@ export const downloadFile = async (url: string, fileName: string) => {
   return savePath;
 };
 
-export async function writeManifestToFile(manifest: any, fileName: string) {
+export async function writeManifestToFile(manifest: unknown, fileName: string) {
   const filePath = path.join(TEMP_DIR, fileName);
   await fs.promises.writeFile(filePath, JSON.stringify(manifest));
   cleanuptotal.addCleanup(async () => {
@@ -45,9 +46,34 @@ export async function writeManifestToFile(manifest: any, fileName: string) {
   return filePath;
 }
 
+export async function writeManifestToZip(
+  manifest: unknown | string,
+  fileName: string
+) {
+  const filePath = path.join(TEMP_DIR, fileName);
+  const manifestString =
+    typeof manifest === 'string'
+      ? fs.readFileSync(manifest)
+      : JSON.stringify(manifest, null, 2);
+
+  const zip = new JSZip();
+  zip.file('manifest.json', manifestString);
+  const data = await zip.generateAsync({ type: 'nodebuffer' });
+
+  await fs.promises.writeFile(filePath, data);
+  cleanuptotal.addCleanup(async () => {
+    fs.unlinkSync(filePath);
+  });
+
+  return filePath;
+}
+
 export async function openVolViewPage(fileName: string) {
   const urlParams = `?urls=[tmp/${fileName}]`;
   await volViewPage.open(urlParams);
+  await volViewPage.waitForViews();
+  const notifications = await volViewPage.getNotificationsCount();
+  expect(notifications).toEqual(0);
 }
 
 type RemoteResourceType = z.infer<typeof RemoteResource> & { name: string };
@@ -61,11 +87,9 @@ export async function openUrls(urlsAndNames: Array<RemoteResourceType>) {
   const manifest = {
     resources,
   };
-  // Use a unique filename to avoid race conditions when tests run in parallel
   const fileName = `openUrlsManifest_${Date.now()}_${Math.random()
     .toString(36)
     .substring(7)}.json`;
   await writeManifestToFile(manifest, fileName);
   await openVolViewPage(fileName);
-  await volViewPage.waitForViews();
 }
diff --git a/wdio.shared.conf.ts b/wdio.shared.conf.ts
index b1552078c..d84675473 100644
--- a/wdio.shared.conf.ts
+++ b/wdio.shared.conf.ts
@@ -3,11 +3,40 @@ import * as fs from 'fs';
 import type { Options, Capabilities } from '@wdio/types';
 import { projectRoot } from './tests/e2eTestUtils';
 
+const TEST_DATASETS = [
+  {
+    url: 'https://data.kitware.com/api/v1/file/6566aa81c5a2b36857ad1783/download',
+    name: 'CT000085.dcm',
+  },
+  {
+    url: 'https://data.kitware.com/api/v1/file/68e9807dbf0f869935e36481/download',
+    name: 'minimal.dcm',
+  },
+  {
+    url: 'https://data.kitware.com/api/v1/file/655d42a694ef39bf0a4a8bb3/download',
+    name: '1-001.dcm',
+  },
+  {
+    url: 'https://data.kitware.com/api/v1/item/63527c7311dab8142820a338/download',
+    name: 'prostate.zip',
+  },
+  {
+    url: 'https://data.kitware.com/api/v1/item/6352a2b311dab8142820a33b/download',
+    name: 'MRA-Head_and_Neck.zip',
+  },
+  {
+    url: 'https://data.kitware.com/api/v1/item/635679c311dab8142820a4f4/download',
+    name: 'fetus.zip',
+  },
+];
+
 export const WINDOW_SIZE = [1200, 800] as const;
 export const TEST_PORT = 4567;
 // for slow connections try:
 // DOWNLOAD_TIMEOUT=60000 && npm run test:e2e:dev
-export const DOWNLOAD_TIMEOUT = Number(process.env.DOWNLOAD_TIMEOUT ?? 60000);
+export const DOWNLOAD_TIMEOUT = Number(process.env.DOWNLOAD_TIMEOUT ?? 20000);
+
+const IS_CI = !!(process.env.CI || process.env.GITHUB_ACTIONS);
 
 const ROOT = projectRoot();
 const TMP = '.tmp/';
@@ -26,21 +55,21 @@ export const config: Options.Testrunner = {
   // ==================
   // Specify Test Files
   // ==================
-  specs: ['./tests/specs/**/*.ts'],
-  exclude: ['./tests/specs/session-zip.e2e.ts'],
+  specs: ['./tests/specs/**/*.e2e.ts'],
+  exclude: [],
   //
   // ============
   // Capabilities
   // ============
-  maxInstances: 1,
+  maxInstances: IS_CI ? 1 : 6,
   //
   // ===================
   // Test Configurations
   // ===================
   logLevel: 'warn',
   bail: 0,
-  waitforTimeout: 30000,
-  connectionRetryTimeout: 120000,
+  waitforTimeout: 10000,
+  connectionRetryTimeout: 30000,
   connectionRetryCount: 3,
   services: [
     [
@@ -72,15 +101,26 @@ export const config: Options.Testrunner = {
   reporters: ['spec', 'html-nice'],
   mochaOpts: {
     ui: 'bdd',
-    timeout: 160 * 1000,
+    timeout: 60000,
   },
 
   //
   // Hooks
   //
 
-  onPrepare() {
+  async onPrepare() {
     fs.mkdirSync(TEMP_DIR, { recursive: true });
+
+    const downloads = TEST_DATASETS.map(async ({ url, name }) => {
+      const savePath = path.join(TEMP_DIR, name);
+      if (fs.existsSync(savePath)) {
+        return;
+      }
+      const response = await fetch(url);
+      const data = await response.arrayBuffer();
+      fs.writeFileSync(savePath, Buffer.from(data));
+    });
+    await Promise.all(downloads);
   },
 
   async before(