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/docs/loading_data.md b/docs/loading_data.md
index c9a0c0a04..b67ed18d3 100644
--- a/docs/loading_data.md
+++ b/docs/loading_data.md
@@ -67,3 +67,7 @@ To layer images:
 1. Under the Rendering tab, an opacity slider changes the transparency of the upper layer.
 
 ![Add Layer](./assets/add-layer.jpg)
+
+## State Files
+
+Load preconfigured scenes with annotations, segment groups, and view settings via [state files](./state_files.md). State files can embed data (`*.volview.zip`) or reference remote data via URIs (`*.volview.json`).
diff --git a/docs/state_files.md b/docs/state_files.md
index 396fe37cb..0f7f9972a 100644
--- a/docs/state_files.md
+++ b/docs/state_files.md
@@ -1,11 +1,69 @@
 # State Files
 
-VolView state files are a great way to save your scene and data to either be used later, or for distributing to collaborators and other users. These files store all of the information you need to restore the state of VolView: your data, annotations, camera positions, background colors, colormaps, multi-view layouts, and more.
+VolView state files save your scene configuration: annotations, camera positions, colormaps, layouts, and more. There are two formats:
 
-State files can be saved by clicking on "Disk" icon in the top of the toolbar. This button will generate a `*.volview.zip` file that can then be re-opened in VolView at any time.
+## Zip State Files (`*.volview.zip`)
 
-When saving VolView state, your data is saved along with the application state. This way, when you send a state file to a collaborator, they too can open the state file and load the previously saved data. However, this means that your state file will be as large as your dataset(s) and may contain patient identifying information. Please follow your institutes HIPAA, IRB and other regulatory and confidentiality requirements.
+Save by clicking the "Disk" icon in the toolbar. This embeds your image data that was loaded from local files alongside the application state. Useful for sharing annotations with collaborators.
 
-State files are loaded by clicking on the "Folder" icon immediately below the save-state Disk icon. This will bring up a file browser for you to select and load your state file.
+## Sparse Manifest Files (`*.volview.json`)
 
-TIP: State files are a great way for developers to transfer data into / out of VolView for integration with other systems. For example, they can be used to integrate VolView with access control systems, to streamline workflows, or to ingest results from AI systems.
+JSON files that reference remote data via URIs instead of embedding it. Useful for:
+
+- Linking to data hosted on servers
+- Sharing annotations without duplicating large datasets
+- Integrating with external systems (AI pipelines, access control, etc.)
+
+Example manifest:
+
+```json
+{
+  "version": "6.2.0",
+  "dataSources": [
+    { "id": 0, "type": "uri", "uri": "https://example.com/scan.zip" },
+    { "id": 1, "type": "uri", "uri": "https://example.com/segmentation.nii.gz" }
+  ],
+  "segmentGroups": [
+    {
+      "id": "seg-1",
+      "dataSourceId": 1,
+      "metadata": {
+        "name": "Tumor Segmentation",
+        "parentImage": "0",
+        "segments": {
+          "order": [1],
+          "byValue": {
+            "1": { "value": 1, "name": "Tumor", "color": [255, 0, 0, 255] }
+          }
+        }
+      }
+    }
+  ],
+  "tools": {
+    "rectangles": {
+      "tools": [
+        {
+          "imageID": "0",
+          "frameOfReference": {
+            "planeNormal": [0, 0, 1],
+            "planeOrigin": [0, 0, 50]
+          },
+          "slice": 50,
+          "firstPoint": [-20, -20, 50],
+          "secondPoint": [20, 20, 50],
+          "label": "lesion"
+        }
+      ],
+      "labels": {
+        "lesion": { "color": "red" }
+      }
+    }
+  }
+}
+```
+
+## Loading State Files
+
+- **Drag and drop** onto VolView
+- **File browser** via the "Folder" icon below the save button
+- **URL parameter**: `?urls=[https://example.com/session.volview.json]`
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/SelectTool.vue b/src/components/tools/SelectTool.vue
index f54d6d305..61bd80b33 100644
--- a/src/components/tools/SelectTool.vue
+++ b/src/components/tools/SelectTool.vue
@@ -2,6 +2,8 @@
 import { onVTKEvent } from '@/src/composables/onVTKEvent';
 import { WIDGET_PRIORITY } from '@kitware/vtk.js/Widgets/Core/AbstractWidget/Constants';
 import { useToolSelectionStore } from '@/src/store/tools/toolSelection';
+import { useToolStore } from '@/src/store/tools';
+import { Tools } from '@/src/store/tools/types';
 import { vtkAnnotationToolWidget } from '@/src/vtk/ToolWidgetUtils/types';
 import { inject } from 'vue';
 import { VtkViewContext } from '@/src/components/vtk/context';
@@ -10,11 +12,19 @@ const view = inject(VtkViewContext);
 if (!view) throw new Error('No VtkView');
 
 const selectionStore = useToolSelectionStore();
+const toolStore = useToolStore();
+
+const PLACING_TOOLS = [Tools.Ruler, Tools.Rectangle, Tools.Polygon];
 
 onVTKEvent(
   view.interactor,
   'onLeftButtonPress',
   (event: any) => {
+    if (PLACING_TOOLS.includes(toolStore.currentTool)) {
+      // avoid bugs when starting a placing tool on an existing tool and right clicking and deleting existing tools
+      return;
+    }
+
     const withModifiers = !!(event.shiftKey || event.controlKey);
     const selectedData = view.widgetManager.getSelectedData();
     if ('widget' in selectedData) {
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/PolygonWidget/PolygonFillRepresentation.js b/src/vtk/PolygonWidget/PolygonFillRepresentation.js
new file mode 100644
index 000000000..02c476f13
--- /dev/null
+++ b/src/vtk/PolygonWidget/PolygonFillRepresentation.js
@@ -0,0 +1,75 @@
+import macro from '@kitware/vtk.js/macros';
+import vtkActor from '@kitware/vtk.js/Rendering/Core/Actor';
+import vtkMapper from '@kitware/vtk.js/Rendering/Core/Mapper';
+import vtkPolyData from '@kitware/vtk.js/Common/DataModel/PolyData';
+import vtkWidgetRepresentation from '@kitware/vtk.js/Widgets/Representations/WidgetRepresentation';
+import { Behavior } from '@kitware/vtk.js/Widgets/Representations/WidgetRepresentation/Constants';
+
+function vtkPolygonFillRepresentation(publicAPI, model) {
+  model.classHierarchy.push('vtkPolygonFillRepresentation');
+
+  model.internalPolyData = vtkPolyData.newInstance();
+
+  model._pipeline = {
+    source: publicAPI,
+    mapper: vtkMapper.newInstance(),
+    actor: vtkActor.newInstance({ pickable: true }),
+  };
+
+  model._pipeline.actor.setMapper(model._pipeline.mapper);
+
+  vtkWidgetRepresentation.connectPipeline(model._pipeline);
+  publicAPI.addActor(model._pipeline.actor);
+
+  publicAPI.getSelectedState = () => model.inputData[0];
+
+  publicAPI.requestData = (inData, outData) => {
+    const states = publicAPI.getRepresentationStates(inData[0]);
+
+    if (states.length < 3) {
+      model.internalPolyData.getPoints().setData(new Float32Array(0));
+      model.internalPolyData.getPolys().setData(new Uint32Array(0));
+      model.internalPolyData.modified();
+      outData[0] = model.internalPolyData;
+      return;
+    }
+
+    const points = new Float32Array(states.length * 3);
+    states.forEach((state, i) => {
+      const origin = state.getOrigin();
+      points[i * 3] = origin[0];
+      points[i * 3 + 1] = origin[1];
+      points[i * 3 + 2] = origin[2];
+    });
+
+    const polys = new Uint32Array(states.length + 1);
+    polys[0] = states.length;
+    for (let i = 0; i < states.length; i++) {
+      polys[i + 1] = i;
+    }
+
+    model.internalPolyData.getPoints().setData(points);
+    model.internalPolyData.getPolys().setData(polys);
+    model.internalPolyData.modified();
+
+    outData[0] = model.internalPolyData;
+  };
+}
+
+const DEFAULT_VALUES = {
+  behavior: Behavior.HANDLE,
+};
+
+export function extend(publicAPI, model, initialValues = {}) {
+  Object.assign(model, DEFAULT_VALUES, initialValues);
+  vtkWidgetRepresentation.extend(publicAPI, model, initialValues);
+  macro.get(publicAPI, model._pipeline, ['mapper', 'actor']);
+  vtkPolygonFillRepresentation(publicAPI, model);
+}
+
+export const newInstance = macro.newInstance(
+  extend,
+  'vtkPolygonFillRepresentation'
+);
+
+export default { newInstance, extend };
diff --git a/src/vtk/PolygonWidget/behavior.ts b/src/vtk/PolygonWidget/behavior.ts
index 842566f20..bd11d34ef 100644
--- a/src/vtk/PolygonWidget/behavior.ts
+++ b/src/vtk/PolygonWidget/behavior.ts
@@ -51,6 +51,16 @@ export default function widgetBehavior(publicAPI: any, model: any) {
     return overSegment && !overUnselectedHandle;
   };
 
+  // Check if mouse is over fill representation (for hover but not interaction)
+  const checkOverFill = () => {
+    const selections = model._widgetManager.getSelections();
+    return (
+      model.representations[2] &&
+      selections?.[0]?.getProperties().prop ===
+        model.representations[2].getActors()[0]
+    );
+  };
+
   // support setting per-view widget manipulators
   macro.setGet(publicAPI, model, ['manipulator']);
 
@@ -156,17 +166,23 @@ export default function widgetBehavior(publicAPI: any, model: any) {
   // --------------------------------------------------------------------------
 
   publicAPI.handleLeftButtonPress = (event: vtkMouseEvent) => {
+    if (!model.manipulator) {
+      return macro.VOID;
+    }
+
     const activeWidget = model._widgetManager.getActiveWidget();
 
+    // If not placing and hovering over another widget, don't consume event.
     if (
-      !model.manipulator ||
-      // If hovering over another widget, don't consume event.
-      (activeWidget && activeWidget !== publicAPI)
+      !model.widgetState.getPlacing() &&
+      activeWidget &&
+      activeWidget !== publicAPI
     ) {
       return macro.VOID;
     }
 
-    if (checkOverSegment()) {
+    // Ignore clicks on this widget's segment or fill
+    if (checkOverSegment() || checkOverFill()) {
       return macro.VOID;
     }
 
@@ -194,7 +210,12 @@ export default function widgetBehavior(publicAPI: any, model: any) {
       return macro.EVENT_ABORT;
     }
 
-    if (model.activeState?.getActive() && model.pickable && model.dragable) {
+    if (
+      model.activeState?.getActive() &&
+      model.activeState?.setOrigin &&
+      model.pickable &&
+      model.dragable
+    ) {
       setDragging(true);
       model._apiSpecificRenderWindow.setCursor('grabbing');
       model._interactor.requestAnimation(publicAPI);
@@ -233,7 +254,7 @@ export default function widgetBehavior(publicAPI: any, model: any) {
 
     publicAPI.invokeHoverEvent({
       ...event,
-      hovering: !!model.activeState,
+      hovering: !!model.activeState || checkOverFill(),
     });
 
     return macro.VOID;
diff --git a/src/vtk/PolygonWidget/index.js b/src/vtk/PolygonWidget/index.js
index e6eb9ab51..fea6a3215 100644
--- a/src/vtk/PolygonWidget/index.js
+++ b/src/vtk/PolygonWidget/index.js
@@ -4,6 +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 './PolygonFillRepresentation';
 
 import widgetBehavior from './behavior';
 import stateGenerator, { HandlesLabel, MoveHandleLabel } from './state';
@@ -34,6 +35,13 @@ function vtkPolygonWidget(publicAPI, model) {
         behavior: Behavior.HANDLE, // make pickable even if not visible
       },
     },
+    {
+      builder: vtkPolygonFillRepresentation,
+      labels: [HandlesLabel],
+      initialValues: {
+        behavior: Behavior.HANDLE,
+      },
+    },
   ];
 
   // Default manipulator
diff --git a/src/vtk/RectangleWidget/RectangleFillRepresentation.js b/src/vtk/RectangleWidget/RectangleFillRepresentation.js
new file mode 100644
index 000000000..9e3d35c01
--- /dev/null
+++ b/src/vtk/RectangleWidget/RectangleFillRepresentation.js
@@ -0,0 +1,116 @@
+import macro from '@kitware/vtk.js/macros';
+import vtkBoundingBox from '@kitware/vtk.js/Common/DataModel/BoundingBox';
+import vtkActor from '@kitware/vtk.js/Rendering/Core/Actor';
+import vtkMapper from '@kitware/vtk.js/Rendering/Core/Mapper';
+import vtkPolyData from '@kitware/vtk.js/Common/DataModel/PolyData';
+import vtkWidgetRepresentation from '@kitware/vtk.js/Widgets/Representations/WidgetRepresentation';
+import { Behavior } from '@kitware/vtk.js/Widgets/Representations/WidgetRepresentation/Constants';
+import * as vtkMath from '@kitware/vtk.js/Common/Core/Math';
+
+function vtkRectangleFillRepresentation(publicAPI, model) {
+  model.classHierarchy.push('vtkRectangleFillRepresentation');
+
+  model.internalPolyData = vtkPolyData.newInstance();
+
+  model._pipeline = {
+    source: publicAPI,
+    mapper: vtkMapper.newInstance(),
+    actor: vtkActor.newInstance({ pickable: true }),
+  };
+
+  model._pipeline.actor.setMapper(model._pipeline.mapper);
+
+  vtkWidgetRepresentation.connectPipeline(model._pipeline);
+  publicAPI.addActor(model._pipeline.actor);
+
+  publicAPI.getSelectedState = () => model.inputData[0];
+
+  const superBehavior = model.widgetAPI.behavior;
+  let behaviorModel;
+  model.widgetAPI.behavior = (publicAPIy, bModel) => {
+    behaviorModel = bModel;
+    return superBehavior(publicAPIy, bModel);
+  };
+
+  publicAPI.requestData = (inData, outData) => {
+    const states = publicAPI.getRepresentationStates(inData[0]);
+
+    if (states.length < 2 || !behaviorModel) {
+      model.internalPolyData.getPoints().setData(new Float32Array(0));
+      model.internalPolyData.getPolys().setData(new Uint32Array(0));
+      model.internalPolyData.modified();
+      outData[0] = model.internalPolyData;
+      return;
+    }
+
+    const box = [...vtkBoundingBox.INIT_BOUNDS];
+    states.forEach((handle) => {
+      const displayPos = behaviorModel._apiSpecificRenderWindow.worldToDisplay(
+        ...handle.getOrigin(),
+        behaviorModel._renderer
+      );
+      vtkBoundingBox.addPoint(box, ...displayPos);
+    });
+    const corners = vtkBoundingBox.getCorners(box, []);
+
+    const corners2D = corners.reduce((outCorners, corner) => {
+      const duplicate = outCorners.some((outCorner) =>
+        vtkMath.areEquals(outCorner, corner)
+      );
+      if (!duplicate) {
+        outCorners.push(corner);
+      }
+      return outCorners;
+    }, []);
+
+    if (corners2D.length < 4) {
+      model.internalPolyData.getPoints().setData(new Float32Array(0));
+      model.internalPolyData.getPolys().setData(new Uint32Array(0));
+      model.internalPolyData.modified();
+      outData[0] = model.internalPolyData;
+      return;
+    }
+
+    const worldCorners = [0, 2, 3, 1].map((cornerIndex) =>
+      behaviorModel._apiSpecificRenderWindow.displayToWorld(
+        ...corners2D[cornerIndex],
+        behaviorModel._renderer
+      )
+    );
+
+    const points = new Float32Array(12);
+    worldCorners.forEach((corner, i) => {
+      points[i * 3] = corner[0];
+      points[i * 3 + 1] = corner[1];
+      points[i * 3 + 2] = corner[2];
+    });
+
+    const polys = new Uint32Array([4, 0, 1, 2, 3]);
+
+    model.internalPolyData.getPoints().setData(points);
+    model.internalPolyData.getPolys().setData(polys);
+    model.internalPolyData.modified();
+
+    outData[0] = model.internalPolyData;
+  };
+}
+
+const DEFAULT_VALUES = {
+  behavior: Behavior.HANDLE,
+  widgetAPI: null,
+};
+
+export function extend(publicAPI, model, initialValues = {}) {
+  Object.assign(model, DEFAULT_VALUES, initialValues);
+  vtkWidgetRepresentation.extend(publicAPI, model, initialValues);
+  macro.setGet(publicAPI, model, ['widgetAPI']);
+  macro.get(publicAPI, model._pipeline, ['mapper', 'actor']);
+  vtkRectangleFillRepresentation(publicAPI, model);
+}
+
+export const newInstance = macro.newInstance(
+  extend,
+  'vtkRectangleFillRepresentation'
+);
+
+export default { newInstance, extend };
diff --git a/src/vtk/RectangleWidget/index.js b/src/vtk/RectangleWidget/index.js
index 3ab57fc3e..274b44a1d 100644
--- a/src/vtk/RectangleWidget/index.js
+++ b/src/vtk/RectangleWidget/index.js
@@ -1,8 +1,11 @@
 import macro from '@kitware/vtk.js/macro';
+import { Behavior } from '@kitware/vtk.js/Widgets/Representations/WidgetRepresentation/Constants';
 
 import { AnnotationToolType } from '@/src/store/tools/types';
 import vtkRulerWidget from '../RulerWidget';
 import vtkRectangleLineRepresentation from './RectangleLineRepresentation';
+import vtkRectangleFillRepresentation from './RectangleFillRepresentation';
+import { PointsLabel } from '../RulerWidget/state';
 
 export { InteractionState } from '../RulerWidget/behavior';
 
@@ -22,6 +25,14 @@ function vtkRectangleWidget(publicAPI, model) {
       ...reps[1].initialValues,
       widgetAPI: model,
     };
+    reps.push({
+      builder: vtkRectangleFillRepresentation,
+      labels: [PointsLabel],
+      initialValues: {
+        behavior: Behavior.HANDLE,
+        widgetAPI: model,
+      },
+    });
     return reps;
   };
 }
diff --git a/src/vtk/RulerWidget/behavior.ts b/src/vtk/RulerWidget/behavior.ts
index 6cbb2bc49..b3b03cb9e 100644
--- a/src/vtk/RulerWidget/behavior.ts
+++ b/src/vtk/RulerWidget/behavior.ts
@@ -66,6 +66,16 @@ export default function widgetBehavior(publicAPI: any, model: any) {
     return overSegment;
   };
 
+  // Check if mouse is over fill representation (for hover but not interaction)
+  const checkOverFill = () => {
+    const selections = model._widgetManager.getSelections();
+    return (
+      model.representations[2] &&
+      selections?.[0]?.getProperties().prop ===
+        model.representations[2].getActors()[0]
+    );
+  };
+
   const getWorldCoords = computeWorldCoords(model);
 
   /**
@@ -76,16 +86,26 @@ export default function widgetBehavior(publicAPI: any, model: any) {
       return macro.VOID;
     }
 
+    // Ignore clicks on fill - let them pass through
+    if (checkOverFill()) {
+      return macro.VOID;
+    }
+
     // turns off hover while dragging
     publicAPI.invokeHoverEvent({
       ...eventData,
       hovering: false,
     });
 
-    // This ruler widget is passive, so if another widget
-    // is active, we don't do anything.
+    const intState = publicAPI.getInteractionState();
+
+    // If not placing and another widget is active, don't consume event.
     const activeWidget = model._widgetManager.getActiveWidget();
-    if (activeWidget && activeWidget !== publicAPI) {
+    if (
+      intState === InteractionState.Select &&
+      activeWidget &&
+      activeWidget !== publicAPI
+    ) {
       return macro.VOID;
     }
 
@@ -94,8 +114,6 @@ export default function widgetBehavior(publicAPI: any, model: any) {
       return macro.VOID;
     }
 
-    const intState = publicAPI.getInteractionState();
-
     if (intState === InteractionState.PlacingFirst) {
       publicAPI.setFirstPoint(worldCoords);
       publicAPI.setSecondPoint(worldCoords);
@@ -123,6 +141,7 @@ export default function widgetBehavior(publicAPI: any, model: any) {
     // dragging
     if (
       model.activeState?.getActive() &&
+      model.activeState?.setOrigin &&
       model.pickable &&
       !checkOverSegment()
     ) {
@@ -167,7 +186,7 @@ export default function widgetBehavior(publicAPI: any, model: any) {
 
     publicAPI.invokeHoverEvent({
       ...eventData,
-      hovering: !!model.activeState,
+      hovering: !!model.activeState || checkOverFill(),
     });
 
     return macro.VOID;
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..3f8955476 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();
   });
@@ -23,6 +25,5 @@ describe('VolView loading of remoteManifest.json', () => {
     const fileName = 'remoteFilesRelativeURI.json';
     await writeManifestToFile(manifest, fileName);
     await openVolViewPage(fileName);
-    await volViewPage.waitForViews();
   });
 });
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..7fbcb317f 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: 90000,
   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(