diff --git a/src/components/AnnotationsModule.vue b/src/components/AnnotationsModule.vue
index 907d3e5ed..0ec626076 100644
--- a/src/components/AnnotationsModule.vue
+++ b/src/components/AnnotationsModule.vue
@@ -1,24 +1,22 @@
 <script setup lang="ts">
+import { AnnotationToolType } from '@/src/store/tools/types';
 import MeasurementsToolList from './MeasurementsToolList.vue';
 import LabelmapList from './LabelmapList.vue';
 import ToolControls from './ToolControls.vue';
-import { usePolygonStore } from '../store/tools/polygons';
-import { useRectangleStore } from '../store/tools/rectangles';
-import { useRulerStore } from '../store/tools/rulers';
 import MeasurementRulerDetails from './MeasurementRulerDetails.vue';
 
 const tools = [
   {
-    store: useRulerStore(),
+    type: AnnotationToolType.Ruler,
     icon: 'mdi-ruler',
     details: MeasurementRulerDetails,
   },
   {
-    store: useRectangleStore(),
+    type: AnnotationToolType.Rectangle,
     icon: 'mdi-vector-square',
   },
   {
-    store: usePolygonStore(),
+    type: AnnotationToolType.Polygon,
     icon: 'mdi-pentagon-outline',
   },
 ];
diff --git a/src/components/MeasurementsToolList.vue b/src/components/MeasurementsToolList.vue
index 5e7d28cca..17986e8a1 100644
--- a/src/components/MeasurementsToolList.vue
+++ b/src/components/MeasurementsToolList.vue
@@ -1,15 +1,20 @@
 <script setup lang="ts">
 import { computed } from 'vue';
 import { useCurrentImage } from '@/src/composables/useCurrentImage';
-import { AnnotationToolStore } from '@/src/store/tools/useAnnotationTool';
 import { frameOfReferenceToImageSliceAndAxis } from '@/src/utils/frameOfReference';
 import { nonNullable } from '@/src/utils/index';
+import { AnnotationToolType } from '@/src/store/tools/types';
+import { useAnnotationToolStore } from '@/src/store/tools';
+import {
+  useMultipleToolSelection,
+  MultipleSelectionState,
+} from '@/src/composables/useMultipleToolSelection';
+import { useToolSelectionStore } from '@/src/store/tools/toolSelection';
 import MeasurementToolDetails from './MeasurementToolDetails.vue';
-import { useMultiSelection } from '../composables/useMultiSelection';
 import { AnnotationTool } from '../types/annotation-tool';
 
 type AnnotationToolConfig = {
-  store: AnnotationToolStore;
+  type: AnnotationToolType;
   icon: string;
   details?: typeof MeasurementToolDetails;
 };
@@ -23,7 +28,8 @@ const props = defineProps<{
 const { currentImageID, currentImageMetadata } = useCurrentImage();
 
 // Filter and add axis for specific annotation type
-const getTools = (toolStore: AnnotationToolStore) => {
+const getTools = (type: AnnotationToolType) => {
+  const toolStore = useAnnotationToolStore(type);
   return toolStore.finishedTools
     .filter((tool) => tool.imageID === currentImageID.value)
     .map((tool) => {
@@ -44,10 +50,13 @@ const getTools = (toolStore: AnnotationToolStore) => {
 // Flatten all tool types and add actions
 const tools = computed(() => {
   return props.tools.flatMap(
-    ({ store, icon, details = MeasurementToolDetails }) => {
-      const toolsWithAxis = getTools(store);
+    ({ type, icon, details = MeasurementToolDetails }) => {
+      const store = useAnnotationToolStore(type);
+      const toolsWithAxis = getTools(type);
       return toolsWithAxis.map((tool) => ({
-        ...tool,
+        id: tool.id,
+        type,
+        toolData: tool,
         icon,
         details,
         remove: () => store.removeTool(tool.id),
@@ -66,22 +75,31 @@ const tools = computed(() => {
 
 // --- selection and batch actions  --- //
 
-const toolIds = computed(() => tools.value.map((tool) => tool.id));
+const selectionStore = useToolSelectionStore();
+
+const { selectAll, deselectAll, selected, selectionState } =
+  useMultipleToolSelection(tools);
 
-const { selected, selectedAll, selectedSome, toggleSelectAll } =
-  useMultiSelection(toolIds);
+const toggleSelectAll = (shouldSelectAll: boolean) => {
+  if (shouldSelectAll) {
+    selectAll();
+  } else {
+    deselectAll();
+  }
+};
 
 const forEachSelectedTool = (
   callback: (tool: (typeof tools.value)[number]) => void
 ) =>
-  selected.value
-    .map((id) => tools.value.find((tool) => id === tool.id))
-    .filter(nonNullable)
+  tools.value
+    .filter((tool) => selectionStore.isSelected(tool.id))
     .forEach(callback);
 
 function removeAll() {
-  forEachSelectedTool((tool) => tool.remove());
-  selected.value = [];
+  selectionStore.selection.forEach((sel) => {
+    const store = useAnnotationToolStore(sel.type);
+    store.removeTool(sel.id);
+  });
 }
 
 // If all selected tools are already hidden, it should be "show".
@@ -90,7 +108,7 @@ const allHidden = computed(() => {
   return selected.value
     .map((id) => tools.value.find((tool) => id === tool.id))
     .filter(nonNullable)
-    .every((tool) => tool.hidden);
+    .every((tool) => tool.toolData.hidden);
 });
 
 function toggleGlobalHidden() {
@@ -105,10 +123,11 @@ function toggleGlobalHidden() {
   <v-row no-gutters justify="space-between" align="center" class="mb-1">
     <v-col class="d-flex">
       <v-checkbox
-        :indeterminate="selectedSome && !selectedAll"
+        class="ml-3"
+        :indeterminate="selectionState === MultipleSelectionState.Some"
         label="Select All"
-        v-model="selectedAll"
-        @click.stop="toggleSelectAll"
+        :model-value="selectionState === MultipleSelectionState.All"
+        @update:model-value="toggleSelectAll"
         density="compact"
         hide-details
       />
@@ -123,7 +142,7 @@ function toggleGlobalHidden() {
       <v-btn
         icon
         variant="text"
-        :disabled="!selectedSome"
+        :disabled="selectionState === MultipleSelectionState.None"
         @click.stop="toggleGlobalHidden"
       >
         <v-icon v-if="allHidden">mdi-eye-off</v-icon>
@@ -135,11 +154,15 @@ function toggleGlobalHidden() {
       <v-btn
         icon
         variant="text"
-        :disabled="!selectedSome"
+        :disabled="selectionState === MultipleSelectionState.None"
         @click.stop="removeAll"
       >
         <v-icon>mdi-delete</v-icon>
-        <v-tooltip :disabled="!selectedSome" location="top" activator="parent">
+        <v-tooltip
+          :disabled="selectionState === MultipleSelectionState.None"
+          location="top"
+          activator="parent"
+        >
           Delete selected
         </v-tooltip>
       </v-btn>
@@ -163,10 +186,10 @@ function toggleGlobalHidden() {
 
         <div
           class="color-dot flex-shrink-0 mr-2"
-          :style="{ backgroundColor: tool.color }"
+          :style="{ backgroundColor: tool.toolData.color }"
         />
         <v-list-item-title v-bind="$attrs">
-          {{ tool.labelName }}
+          {{ tool.toolData.labelName }}
         </v-list-item-title>
 
         <span class="ml-auto flex-shrink-0">
@@ -177,10 +200,10 @@ function toggleGlobalHidden() {
             </v-tooltip>
           </v-btn>
           <v-btn icon variant="text" @click="tool.toggleHidden()">
-            <v-icon v-if="tool.hidden">mdi-eye-off</v-icon>
+            <v-icon v-if="tool.toolData.hidden">mdi-eye-off</v-icon>
             <v-icon v-else>mdi-eye</v-icon>
             <v-tooltip location="top" activator="parent">{{
-              tool.hidden ? 'Show' : 'Hide'
+              tool.toolData.hidden ? 'Show' : 'Hide'
             }}</v-tooltip>
           </v-btn>
           <v-btn icon variant="text" @click="tool.remove()">
@@ -192,7 +215,7 @@ function toggleGlobalHidden() {
 
       <v-row class="mt-4">
         <v-list-item-subtitle class="w-100">
-          <component :is="tool.details" :tool="tool" />
+          <component :is="tool.details" :tool="tool.toolData" />
         </v-list-item-subtitle>
       </v-row>
     </v-container>
diff --git a/src/components/VtkTwoView.vue b/src/components/VtkTwoView.vue
index 97974cc94..97e9ce0ce 100644
--- a/src/components/VtkTwoView.vue
+++ b/src/components/VtkTwoView.vue
@@ -37,10 +37,14 @@
         />
       </div>
       <div class="overlay-no-events tool-layer" ref="toolContainer">
+        <svg class="overlay-no-events">
+          <bounding-rectangle :points="selectionPoints" :view-id="viewID" />
+        </svg>
         <pan-tool :view-id="viewID" />
         <zoom-tool :view-id="viewID" />
         <slice-scroll-tool :view-id="viewID" />
         <window-level-tool :view-id="viewID" />
+        <select-tool :view-id="viewID" :widget-manager="widgetManager" />
         <ruler-tool
           :view-id="viewID"
           :widget-manager="widgetManager"
@@ -194,6 +198,11 @@ import { Mode as LookupTableProxyMode } from '@kitware/vtk.js/Proxy/Core/LookupT
 import { manageVTKSubscription } from '@/src/composables/manageVTKSubscription';
 import SliceSlider from '@/src/components/SliceSlider.vue';
 import ViewOverlayGrid from '@/src/components/ViewOverlayGrid.vue';
+import SelectTool from '@/src/components/tools/SelectTool.vue';
+import BoundingRectangle from '@/src/components/tools/BoundingRectangle.vue';
+import { useToolSelectionStore } from '@/src/store/tools/toolSelection';
+import { useAnnotationToolStore } from '@/src/store/tools';
+import { doesToolFrameMatchViewAxis } from '@/src/composables/annotationTool';
 import { useResizeObserver } from '../composables/useResizeObserver';
 import { useOrientationLabels } from '../composables/useOrientationLabels';
 import { getLPSAxisFromDir } from '../utils/lps';
@@ -256,6 +265,7 @@ export default defineComponent({
   components: {
     SliceSlider,
     ViewOverlayGrid,
+    BoundingRectangle,
     WindowLevelTool,
     SliceScrollTool,
     PanTool,
@@ -266,6 +276,7 @@ export default defineComponent({
     PaintTool,
     CrosshairsTool,
     CropTool,
+    SelectTool,
   },
   setup(props) {
     const windowingStore = useWindowingStore();
@@ -740,6 +751,25 @@ export default defineComponent({
       { immediate: true, deep: true }
     );
 
+    // --- selection points --- //
+
+    const selectionStore = useToolSelectionStore();
+    const selectionPoints = computed(() => {
+      return selectionStore.selection
+        .map((sel) => {
+          const store = useAnnotationToolStore(sel.type);
+          return { store, tool: store.toolByID[sel.id] };
+        })
+        .filter(
+          ({ tool }) =>
+            tool.slice === currentSlice.value &&
+            doesToolFrameMatchViewAxis(viewAxis, tool)
+        )
+        .flatMap(({ store, tool }) => store.getPoints(tool.id));
+    });
+
+    // --- //
+
     return {
       vtkContainerRef,
       toolContainer,
@@ -762,6 +792,7 @@ export default defineComponent({
         resizeToFit.value = true;
       },
       hover,
+      selectionPoints,
     };
   },
 });
diff --git a/src/components/tools/AnnotationContextMenu.vue b/src/components/tools/AnnotationContextMenu.vue
index 6879c5104..402fad3c7 100644
--- a/src/components/tools/AnnotationContextMenu.vue
+++ b/src/components/tools/AnnotationContextMenu.vue
@@ -1,8 +1,11 @@
 <script setup lang="ts">
 import { computed, shallowReactive } from 'vue';
 import { AnnotationToolStore } from '@/src/store/tools/useAnnotationTool';
-import { ContextMenuEvent, ToolID } from '@/src/types/annotation-tool';
-import { WidgetAction } from '@/src/vtk/ToolWidgetUtils/utils';
+import {
+  ContextMenuEvent,
+  WidgetAction,
+} from '@/src/vtk/ToolWidgetUtils/types';
+import { ToolID } from '@/src/types/annotation-tool';
 
 const props = defineProps<{
   toolStore: AnnotationToolStore;
diff --git a/src/components/tools/BoundingRectangle.vue b/src/components/tools/BoundingRectangle.vue
index 7f93eb950..ccdae15f5 100644
--- a/src/components/tools/BoundingRectangle.vue
+++ b/src/components/tools/BoundingRectangle.vue
@@ -1,6 +1,6 @@
 <script setup lang="ts">
-import { computed, ref, watch, toRefs } from 'vue';
-import { ANNOTATION_TOOL_HANDLE_RADIUS } from '@/src/constants';
+import { computed, ref, watch, toRefs, toRaw, inject } from 'vue';
+import { ANNOTATION_TOOL_HANDLE_RADIUS, ToolContainer } from '@/src/constants';
 import { useViewStore } from '@/src/store/views';
 import { worldToSVG } from '@/src/utils/vtk-helpers';
 import { nonNullable } from '@/src/utils/index';
@@ -8,11 +8,20 @@ import vtkLPSView2DProxy from '@/src/vtk/LPSView2DProxy';
 import vtkBoundingBox from '@kitware/vtk.js/Common/DataModel/BoundingBox';
 import type { Bounds, Vector3 } from '@kitware/vtk.js/types';
 import { onVTKEvent } from '@/src/composables/onVTKEvent';
+import { useResizeObserver } from '@/src/composables/useResizeObserver';
 
-const props = defineProps<{
-  points: Array<Vector3>;
-  viewId: string;
-}>();
+const DEFAULT_PADDING = 2;
+
+const props = withDefaults(
+  defineProps<{
+    points: Array<Vector3>;
+    viewId: string;
+    padding?: number;
+  }>(),
+  {
+    padding: DEFAULT_PADDING,
+  }
+);
 
 const viewStore = useViewStore();
 const viewProxy = computed(
@@ -34,7 +43,7 @@ const updateRectangle = () => {
   const viewRenderer = viewProxy.value.getRenderer();
 
   const screenBounds = [...vtkBoundingBox.INIT_BOUNDS] as Bounds;
-  props.points
+  toRaw(props.points)
     .map((point) => {
       const point2D = worldToSVG(point, viewRenderer);
       return point2D;
@@ -43,6 +52,8 @@ const updateRectangle = () => {
     .forEach(([x, y]) => {
       vtkBoundingBox.addPoint(screenBounds, x, y, 0);
     });
+
+  vtkBoundingBox.inflate(screenBounds, props.padding);
   const [x, y] = vtkBoundingBox.getMinPoint(screenBounds);
   const [maxX, maxY] = vtkBoundingBox.getMaxPoint(screenBounds);
   // Plus 2 to account for the stroke width
@@ -59,7 +70,13 @@ const updateRectangle = () => {
 const { points } = toRefs(props);
 watch(points, updateRectangle, { immediate: true, deep: true });
 
-onVTKEvent(viewProxy, 'onModified', updateRectangle);
+const camera = computed(() => viewProxy.value.getCamera());
+onVTKEvent(camera, 'onModified', updateRectangle);
+
+const containerEl = inject(ToolContainer)!;
+useResizeObserver(containerEl, () => {
+  updateRectangle();
+});
 </script>
 
 <template>
diff --git a/src/components/tools/SelectTool.vue b/src/components/tools/SelectTool.vue
new file mode 100644
index 000000000..22b55c18b
--- /dev/null
+++ b/src/components/tools/SelectTool.vue
@@ -0,0 +1,56 @@
+<script setup lang="ts">
+import { onVTKEvent } from '@/src/composables/onVTKEvent';
+import { useViewStore } from '@/src/store/views';
+import { computed, toRefs } from 'vue';
+import { WIDGET_PRIORITY } from '@kitware/vtk.js/Widgets/Core/AbstractWidget/Constants';
+import vtkWidgetManager from '@kitware/vtk.js/Widgets/Core/WidgetManager';
+import { useToolSelectionStore } from '@/src/store/tools/toolSelection';
+import { vtkAnnotationToolWidget } from '@/src/vtk/ToolWidgetUtils/types';
+
+const props = defineProps<{
+  viewId: string;
+  widgetManager: vtkWidgetManager;
+}>();
+
+const { viewId, widgetManager } = toRefs(props);
+
+const viewProxy = computed(() => useViewStore().getViewProxy(viewId.value));
+const interactor = computed(() => viewProxy.value?.getInteractor());
+const selectionStore = useToolSelectionStore();
+
+onVTKEvent(
+  interactor,
+  'onLeftButtonPress',
+  (event: any) => {
+    const withModifiers = !!(event.shiftKey || event.controlKey);
+    const selectedData = widgetManager.value.getSelectedData();
+    if ('widget' in selectedData) {
+      // clicked in empty space.
+      const widget = selectedData.widget as vtkAnnotationToolWidget;
+      const widgetState = widget.getWidgetState();
+      const id = widgetState.getId();
+      const type = widgetState.getToolType();
+      // preserve if we've used shift or ctrl
+      if (withModifiers) {
+        selectionStore.toggleSelection(id, type);
+      } else {
+        selectionStore.clearSelection();
+        selectionStore.addSelection(id, type);
+      }
+    } else if (!withModifiers) {
+      // if no modifiers, then deselect
+      selectionStore.clearSelection();
+    }
+  },
+  {
+    // capture all events by calling handler before widgets
+    priority: WIDGET_PRIORITY + 1,
+  }
+);
+
+const render = () => {};
+</script>
+
+<template>
+  <render />
+</template>
diff --git a/src/components/tools/polygon/PolygonTool.vue b/src/components/tools/polygon/PolygonTool.vue
index 190940fa3..117247609 100644
--- a/src/components/tools/polygon/PolygonTool.vue
+++ b/src/components/tools/polygon/PolygonTool.vue
@@ -1,7 +1,6 @@
 <template>
   <div class="overlay-no-events">
     <svg class="overlay-no-events">
-      <bounding-rectangle :points="points" :view-id="viewId" />
       <polygon-widget-2D
         v-for="tool in tools"
         :key="tool.id"
@@ -46,7 +45,6 @@ import {
 } from '@/src/composables/annotationTool';
 import AnnotationContextMenu from '@/src/components/tools/AnnotationContextMenu.vue';
 import AnnotationInfo from '@/src/components/tools/AnnotationInfo.vue';
-import BoundingRectangle from '@/src/components/tools/BoundingRectangle.vue';
 import { useFrameOfReference } from '@/src/composables/useFrameOfReference';
 import PolygonWidget2D from './PolygonWidget2D.vue';
 
@@ -77,7 +75,6 @@ export default defineComponent({
     PolygonWidget2D,
     AnnotationContextMenu,
     AnnotationInfo,
-    BoundingRectangle,
   },
   setup(props) {
     const { viewDirection, currentSlice } = toRefs(props);
@@ -141,12 +138,6 @@ export default defineComponent({
 
     const { onHover, overlayInfo } = useHover(currentTools, currentSlice);
 
-    const points = computed(() => {
-      if (!overlayInfo.value.visible) return [];
-      const tool = activeToolStore.toolByID[overlayInfo.value.toolID];
-      return tool.points;
-    });
-
     return {
       tools: currentTools,
       placingToolID: placingTool.id,
@@ -156,7 +147,6 @@ export default defineComponent({
       activeToolStore,
       onHover,
       overlayInfo,
-      points,
     };
   },
 });
diff --git a/src/components/tools/polygon/PolygonWidget2D.vue b/src/components/tools/polygon/PolygonWidget2D.vue
index 7de1bb3f6..c524d11ef 100644
--- a/src/components/tools/polygon/PolygonWidget2D.vue
+++ b/src/components/tools/polygon/PolygonWidget2D.vue
@@ -83,7 +83,6 @@ export default defineComponent({
 
     const widgetFactory = vtkWidgetFactory.newInstance({
       id: toolId.value,
-      store: toolStore,
     });
     const widget = ref<WidgetView | null>(null);
 
@@ -95,8 +94,8 @@ export default defineComponent({
       if (!widget.value) {
         return;
       }
+      // widgetManager calls widget.delete()
       widgetManager.value.removeWidget(widget.value);
-      widget.value.delete();
       widgetFactory.delete();
     });
 
diff --git a/src/components/tools/rectangle/RectangleTool.vue b/src/components/tools/rectangle/RectangleTool.vue
index bbba4a1ef..ca624fe13 100644
--- a/src/components/tools/rectangle/RectangleTool.vue
+++ b/src/components/tools/rectangle/RectangleTool.vue
@@ -1,7 +1,6 @@
 <template>
   <div class="overlay-no-events">
     <svg class="overlay-no-events">
-      <bounding-rectangle :points="points" :view-id="viewId" />
       <rectangle-widget-2D
         v-for="tool in tools"
         :key="tool.id"
@@ -46,7 +45,6 @@ import {
 } from '@/src/composables/annotationTool';
 import AnnotationContextMenu from '@/src/components/tools/AnnotationContextMenu.vue';
 import AnnotationInfo from '@/src/components/tools/AnnotationInfo.vue';
-import BoundingRectangle from '@/src/components/tools/BoundingRectangle.vue';
 import { useFrameOfReference } from '@/src/composables/useFrameOfReference';
 import RectangleWidget2D from './RectangleWidget2D.vue';
 
@@ -77,7 +75,6 @@ export default defineComponent({
     RectangleWidget2D,
     AnnotationContextMenu,
     AnnotationInfo,
-    BoundingRectangle,
   },
   setup(props) {
     const { viewDirection, currentSlice } = toRefs(props);
@@ -133,7 +130,7 @@ export default defineComponent({
       }
     };
 
-    // ---  //
+    // --- //
 
     const { contextMenu, openContextMenu } = useContextMenu();
 
@@ -141,12 +138,6 @@ export default defineComponent({
 
     const { onHover, overlayInfo } = useHover(currentTools, currentSlice);
 
-    const points = computed(() => {
-      if (!overlayInfo.value.visible) return [];
-      const tool = activeToolStore.toolByID[overlayInfo.value.toolID];
-      return [tool.firstPoint, tool.secondPoint];
-    });
-
     return {
       tools: currentTools,
       placingToolID: placingTool.id,
@@ -156,7 +147,6 @@ export default defineComponent({
       activeToolStore,
       onHover,
       overlayInfo,
-      points,
     };
   },
 });
diff --git a/src/components/tools/rectangle/RectangleWidget2D.vue b/src/components/tools/rectangle/RectangleWidget2D.vue
index b509a21fb..bae22c549 100644
--- a/src/components/tools/rectangle/RectangleWidget2D.vue
+++ b/src/components/tools/rectangle/RectangleWidget2D.vue
@@ -88,7 +88,6 @@ export default defineComponent({
 
     const widgetFactory = vtkWidgetFactory.newInstance({
       id: toolId.value,
-      store: toolStore,
       isPlaced: !isPlacing.value,
     });
     const widget = ref<WidgetView | null>(null);
@@ -101,8 +100,8 @@ export default defineComponent({
       if (!widget.value) {
         return;
       }
+      // widgetManager calls widget.delete()
       widgetManager.value.removeWidget(widget.value);
-      widget.value.delete();
       widgetFactory.delete();
     });
 
@@ -182,10 +181,10 @@ export default defineComponent({
     return {
       tool,
       firstPoint: computed(() => {
-        return visibleStates.firstPoint ? tool.value.firstPoint : undefined;
+        return visibleStates.firstPoint ? tool.value?.firstPoint : undefined;
       }),
       secondPoint: computed(() => {
-        return visibleStates.secondPoint ? tool.value.secondPoint : undefined;
+        return visibleStates.secondPoint ? tool.value?.secondPoint : undefined;
       }),
     };
   },
diff --git a/src/components/tools/ruler/RulerTool.vue b/src/components/tools/ruler/RulerTool.vue
index 7823c650f..b25e0f494 100644
--- a/src/components/tools/ruler/RulerTool.vue
+++ b/src/components/tools/ruler/RulerTool.vue
@@ -1,11 +1,10 @@
 <template>
   <div class="overlay-no-events">
     <svg class="overlay-no-events">
-      <bounding-rectangle :points="points" :view-id="viewId" />
       <ruler-widget-2D
         v-for="ruler in rulers"
         :key="ruler.id"
-        :ruler-id="ruler.id"
+        :tool-id="ruler.id"
         :is-placing="ruler.id === placingRulerID"
         :current-slice="currentSlice"
         :view-id="viewId"
@@ -47,7 +46,6 @@ import {
 } from '@/src/composables/annotationTool';
 import AnnotationContextMenu from '@/src/components/tools/AnnotationContextMenu.vue';
 import AnnotationInfo from '@/src/components/tools/AnnotationInfo.vue';
-import BoundingRectangle from '@/src/components/tools/BoundingRectangle.vue';
 import { useFrameOfReference } from '@/src/composables/useFrameOfReference';
 
 export default defineComponent({
@@ -74,7 +72,6 @@ export default defineComponent({
     RulerWidget2D,
     AnnotationContextMenu,
     AnnotationInfo,
-    BoundingRectangle,
   },
   setup(props) {
     const { viewDirection, currentSlice } = toRefs(props);
@@ -148,12 +145,6 @@ export default defineComponent({
 
     const { onHover, overlayInfo } = useHover(currentTools, currentSlice);
 
-    const points = computed(() => {
-      if (!overlayInfo.value.visible) return [];
-      const tool = rulerStore.toolByID[overlayInfo.value.toolID];
-      return [tool.firstPoint, tool.secondPoint];
-    });
-
     return {
       rulers: currentRulers,
       placingRulerID: placingTool.id,
@@ -163,7 +154,6 @@ export default defineComponent({
       rulerStore,
       onHover,
       overlayInfo,
-      points,
     };
   },
 });
diff --git a/src/components/tools/ruler/RulerWidget2D.vue b/src/components/tools/ruler/RulerWidget2D.vue
index 8ba83f4ae..58b7bbba1 100644
--- a/src/components/tools/ruler/RulerWidget2D.vue
+++ b/src/components/tools/ruler/RulerWidget2D.vue
@@ -38,7 +38,7 @@ export default defineComponent({
   name: 'RulerWidget2D',
   emits: ['placed', 'contextmenu', 'widgetHover'],
   props: {
-    rulerId: {
+    toolId: {
       type: String as unknown as PropType<ToolID>,
       required: true,
     },
@@ -68,7 +68,7 @@ export default defineComponent({
   },
   setup(props, { emit }) {
     const {
-      rulerId,
+      toolId,
       viewId,
       widgetManager,
       viewDirection,
@@ -77,13 +77,12 @@ export default defineComponent({
     } = toRefs(props);
 
     const rulerStore = useRulerStore();
-    const ruler = computed(() => rulerStore.rulerByID[rulerId.value]);
+    const ruler = computed(() => rulerStore.rulerByID[toolId.value]);
     const { currentImageID, currentImageMetadata } = useCurrentImage();
     const viewProxy = computed(() => useViewStore().getViewProxy(viewId.value));
 
     const widgetFactory = vtkRulerWidget.newInstance({
-      id: rulerId.value,
-      store: rulerStore,
+      id: toolId.value,
       isPlaced: !isPlacing.value,
     });
     const widget = ref<vtkRulerViewWidget | null>(null);
@@ -98,8 +97,8 @@ export default defineComponent({
       if (!widget.value) {
         return;
       }
+      // widgetManager calls widget.delete()
       widgetManager.value.removeWidget(widget.value);
-      widget.value.delete();
       widgetFactory.delete();
     });
 
@@ -181,10 +180,10 @@ export default defineComponent({
     return {
       ruler,
       firstPoint: computed(() => {
-        return visibleStates.firstPoint ? ruler.value.firstPoint : undefined;
+        return visibleStates.firstPoint ? ruler.value?.firstPoint : undefined;
       }),
       secondPoint: computed(() => {
-        return visibleStates.secondPoint ? ruler.value.secondPoint : undefined;
+        return visibleStates.secondPoint ? ruler.value?.secondPoint : undefined;
       }),
       length: computed(() => rulerStore.lengthByID[ruler.value.id]),
     };
diff --git a/src/composables/annotationTool.ts b/src/composables/annotationTool.ts
index a2a6e5795..6afa9487a 100644
--- a/src/composables/annotationTool.ts
+++ b/src/composables/annotationTool.ts
@@ -2,7 +2,6 @@ import { Ref, UnwrapRef, computed, readonly, ref, watch } from 'vue';
 import { Vector2 } from '@kitware/vtk.js/types';
 import { useCurrentImage } from '@/src/composables/useCurrentImage';
 import { frameOfReferenceToImageSliceAndAxis } from '@/src/utils/frameOfReference';
-import { vtkAnnotationToolWidget } from '@/src/vtk/ToolWidgetUtils/utils';
 import { onVTKEvent } from '@/src/composables/onVTKEvent';
 import { Maybe } from '@/src/types';
 import { useToolStore } from '@/src/store/tools';
@@ -10,22 +9,22 @@ import { Tools } from '@/src/store/tools/types';
 import { AnnotationToolStore } from '@/src/store/tools/useAnnotationTool';
 import { getCSSCoordinatesFromEvent } from '@/src//utils/vtk-helpers';
 import { LPSAxis } from '@/src/types/lps';
-import {
-  AnnotationTool,
-  ContextMenuEvent,
-  ToolID,
-} from '@/src/types/annotation-tool';
+import { AnnotationTool, ToolID } from '@/src/types/annotation-tool';
 import vtkAbstractWidget from '@kitware/vtk.js/Widgets/Core/AbstractWidget';
 import { useViewStore } from '@/src/store/views';
 import vtkWidgetManager from '@kitware/vtk.js/Widgets/Core/WidgetManager';
 import { usePopperState } from '@/src/composables/usePopperState';
 import { onViewProxyMounted } from '@/src/composables/useViewProxy';
+import {
+  ContextMenuEvent,
+  vtkAnnotationToolWidget,
+} from '@/src/vtk/ToolWidgetUtils/types';
 
 const SHOW_OVERLAY_DELAY = 250; // milliseconds
 
 // does the tools's frame of reference match
 // the view's axis
-const doesToolFrameMatchViewAxis = <Tool extends AnnotationTool>(
+export const doesToolFrameMatchViewAxis = <Tool extends AnnotationTool>(
   viewAxis: Ref<LPSAxis>,
   tool: Partial<Tool>
 ) => {
@@ -42,15 +41,16 @@ const doesToolFrameMatchViewAxis = <Tool extends AnnotationTool>(
   return !!toolAxis && toolAxis.axis === viewAxis.value;
 };
 
-export const useCurrentTools = (
-  toolStore: AnnotationToolStore,
+export const useCurrentTools = <S extends AnnotationToolStore>(
+  toolStore: S,
   viewAxis: Ref<LPSAxis>
 ) =>
   computed(() => {
     const { currentImageID } = useCurrentImage();
     const curImageID = currentImageID.value;
 
-    return toolStore.tools.filter((tool) => {
+    type ToolType = S['tools'][number];
+    return (toolStore.tools as Array<ToolType>).filter((tool) => {
       // only show tools for the current image,
       // current view axis and not hidden
       return (
diff --git a/src/composables/onVTKEvent.ts b/src/composables/onVTKEvent.ts
index 684c87823..1d08a0a7a 100644
--- a/src/composables/onVTKEvent.ts
+++ b/src/composables/onVTKEvent.ts
@@ -3,12 +3,19 @@ import { vtkObject, vtkSubscription } from '@kitware/vtk.js/interfaces';
 import { MaybeRef, computed, onBeforeUnmount, unref, watch } from 'vue';
 
 export type VTKEventHandler = (ev?: any) => any;
-export type VTKEventListener = (handler: VTKEventHandler) => vtkSubscription;
+export type VTKEventListener = (
+  handler: VTKEventHandler,
+  priority?: number
+) => vtkSubscription;
+export type OnVTKEventOptions = {
+  priority?: number;
+};
 
 export function onVTKEvent<T extends vtkObject, K extends keyof T>(
   vtkObj: MaybeRef<Maybe<T>>,
   eventHookName: T[K] extends VTKEventListener ? K : never,
-  callback: VTKEventHandler
+  callback: VTKEventHandler,
+  options?: OnVTKEventOptions
 ) {
   const listenerRef = computed(() => {
     const obj = unref(vtkObj);
@@ -26,7 +33,7 @@ export function onVTKEvent<T extends vtkObject, K extends keyof T>(
     (listener) => {
       stop();
       if (listener) {
-        subscription = listener(callback);
+        subscription = listener(callback, options?.priority ?? 0);
       }
     },
     { immediate: true }
diff --git a/src/composables/useMultipleToolSelection.ts b/src/composables/useMultipleToolSelection.ts
new file mode 100644
index 000000000..d04a92b63
--- /dev/null
+++ b/src/composables/useMultipleToolSelection.ts
@@ -0,0 +1,65 @@
+import {
+  ToolSelection,
+  useToolSelectionStore,
+} from '@/src/store/tools/toolSelection';
+import { AnnotationToolType } from '@/src/store/tools/types';
+import { ToolID } from '@/src/types/annotation-tool';
+import { MaybeRef, computed, unref } from 'vue';
+
+export enum MultipleSelectionState {
+  None,
+  Some,
+  All,
+}
+
+export const useMultipleToolSelection = (
+  collection: MaybeRef<ToolSelection[]>
+) => {
+  const store = useToolSelectionStore();
+
+  const idToType = computed(() =>
+    unref(collection).reduce(
+      (acc, { id, type }) => ({ ...acc, [id]: type }),
+      {} as Record<ToolID, AnnotationToolType>
+    )
+  );
+
+  const selected = computed<ToolID[]>({
+    get: () => store.selection.map(({ id }) => id),
+    set: (newSelection) => {
+      store.clearSelection();
+      newSelection.forEach((id) => {
+        store.addSelection(id, idToType.value[id]);
+      });
+    },
+  });
+
+  const selectionState = computed<MultipleSelectionState>(() => {
+    const coll = unref(collection);
+    const { length } = unref(coll).filter((tool) => store.isSelected(tool.id));
+    if (length === 0) {
+      return MultipleSelectionState.None;
+    }
+    if (length === coll.length) {
+      return MultipleSelectionState.All;
+    }
+    return MultipleSelectionState.Some;
+  });
+
+  const selectAll = () => {
+    unref(collection).forEach((tool) => store.addSelection(tool.id, tool.type));
+  };
+
+  const deselectAll = () => {
+    // technically correct solution is collection.forEach(remove),
+    // but this will suffice (and is faster).
+    store.clearSelection();
+  };
+
+  return {
+    selectAll,
+    deselectAll,
+    selected,
+    selectionState,
+  };
+};
diff --git a/src/shims-vtk.d.ts b/src/shims-vtk.d.ts
index 25e94e209..01d9fb028 100644
--- a/src/shims-vtk.d.ts
+++ b/src/shims-vtk.d.ts
@@ -7,11 +7,6 @@ declare module '@kitware/vtk.js/vtk' {
   export default vtk;
 }
 
-declare module '@kitware/vtk.js/interfaces-additions' {
-  import { EVENT_ABORT, VOID } from '@kitware/vtk.js/macros';
-  export type EventHandler = (...any: args[]) => EVENT_ABORT | VOID | void;
-}
-
 declare module '@kitware/vtk.js/Interaction/Style/InteractorStyleManipulator/Presets' {
   export default any;
 }
@@ -295,3 +290,7 @@ declare module '@kitware/vtk.js/Widgets/Widgets3D/ImageCroppingWidget' {
   };
   export default vtkImageCroppingWidget;
 }
+
+declare module '@kitware/vtk.js/Widgets/Core/AbstractWidget/Constants' {
+  export declare const WIDGET_PRIORITY: number;
+}
diff --git a/src/store/tools/crop.ts b/src/store/tools/crop.ts
index 81a181ec1..231fc631d 100644
--- a/src/store/tools/crop.ts
+++ b/src/store/tools/crop.ts
@@ -1,6 +1,7 @@
 import { getImageSpatialExtent } from '@/src/composables/useCurrentImage';
 import { LPSAxis } from '@/src/types/lps';
 import { getAxisBounds } from '@/src/utils/lps';
+import { NOOP } from '@/src/constants';
 import vtkPlane from '@kitware/vtk.js/Common/DataModel/Plane';
 import type { Vector2, Vector3 } from '@kitware/vtk.js/types';
 import { computed, reactive, readonly, unref } from 'vue';
@@ -135,6 +136,9 @@ export const useCropStore = defineStore('crop', () => {
     });
   }
 
+  const activateTool = () => true;
+  const deactivateTool = NOOP;
+
   return {
     croppingByImageID: readonly(state.croppingByImageID),
     getComputedVTKPlanes,
@@ -143,5 +147,7 @@ export const useCropStore = defineStore('crop', () => {
     resetCropping,
     serialize,
     deserialize,
+    activateTool,
+    deactivateTool,
   };
 });
diff --git a/src/store/tools/index.ts b/src/store/tools/index.ts
index 142f7dd2b..1ee395be9 100644
--- a/src/store/tools/index.ts
+++ b/src/store/tools/index.ts
@@ -1,36 +1,45 @@
 import { Manifest, StateFile } from '@/src/io/state-file/schema';
+import { Maybe } from '@/src/types';
+import type { AnnotationToolStore } from '@/src/store/tools/useAnnotationTool';
 import { defineStore } from 'pinia';
 import { useCropStore } from './crop';
 import { useCrosshairsToolStore } from './crosshairs';
 import { usePaintToolStore } from './paint';
 import { useRulerStore } from './rulers';
 import { useRectangleStore } from './rectangles';
-import { Tools } from './types';
+import { AnnotationToolType, IToolStore, Tools } from './types';
 import { usePolygonStore } from './polygons';
 
 interface State {
   currentTool: Tools;
 }
 
-export interface IToolStore {
-  activateTool: () => boolean;
-  deactivateTool: () => void;
-}
+// TODO move these types out
+export const AnnotationToolStoreMap: Record<
+  AnnotationToolType,
+  () => AnnotationToolStore
+> = {
+  [AnnotationToolType.Polygon]: usePolygonStore,
+  [AnnotationToolType.Rectangle]: useRectangleStore,
+  [AnnotationToolType.Ruler]: useRulerStore,
+} as const;
 
-function getStore(tool: Tools): IToolStore | null {
-  if (tool === Tools.Ruler) {
-    return useRulerStore();
-  }
-  if (tool === Tools.Rectangle) {
-    return useRectangleStore();
-  }
-  if (tool === Tools.Paint) {
-    return usePaintToolStore();
-  }
-  if (tool === Tools.Crosshairs) {
-    return useCrosshairsToolStore();
-  }
-  return null;
+export const ToolStoreMap: Record<Tools, Maybe<() => IToolStore>> = {
+  [Tools.Pan]: null,
+  [Tools.WindowLevel]: null,
+  [Tools.Zoom]: null,
+  [Tools.Select]: null,
+  [Tools.Crop]: useCropStore,
+  [Tools.Crosshairs]: useCrosshairsToolStore,
+  [Tools.Paint]: usePaintToolStore,
+  ...AnnotationToolStoreMap,
+} as const;
+
+export function useAnnotationToolStore(
+  type: AnnotationToolType
+): AnnotationToolStore {
+  const useStore = AnnotationToolStoreMap[type];
+  return useStore();
 }
 
 /**
@@ -39,17 +48,19 @@ function getStore(tool: Tools): IToolStore | null {
  * store setup() will be activated.
  */
 function setupTool(tool: Tools) {
-  const store = getStore(tool);
-  if (store) {
-    return store.activateTool();
+  const useStore = ToolStoreMap[tool];
+  const store = useStore?.();
+  if (store?.activateTool) {
+    return store.activateTool?.();
   }
   return true;
 }
 
 function teardownTool(tool: Tools) {
-  const store = getStore(tool);
+  const useStore = ToolStoreMap[tool];
+  const store = useStore?.();
   if (store) {
-    store.deactivateTool();
+    store.deactivateTool?.();
   }
 }
 
@@ -67,19 +78,13 @@ export const useToolStore = defineStore('tool', {
     },
     serialize(state: StateFile) {
       const { tools } = state.manifest;
-      const rulerStore = useRulerStore();
-      const rectangleStore = useRectangleStore();
-      const polygonStore = usePolygonStore();
-      const crosshairsStore = useCrosshairsToolStore();
-      const paintStore = usePaintToolStore();
-      const cropStore = useCropStore();
 
-      rulerStore.serialize(state);
-      rectangleStore.serialize(state);
-      polygonStore.serialize(state);
-      crosshairsStore.serialize(state);
-      paintStore.serialize(state);
-      cropStore.serialize(state);
+      Object.values(ToolStoreMap)
+        .map((useStore) => useStore?.())
+        .filter((store): store is IToolStore => !!store)
+        .forEach((store) => {
+          store.serialize?.(state);
+        });
 
       tools.current = this.currentTool;
     },
@@ -89,19 +94,14 @@ export const useToolStore = defineStore('tool', {
       dataIDMap: Record<string, string>
     ) {
       const { tools } = manifest;
-      const rulerStore = useRulerStore();
-      const rectangleStore = useRectangleStore();
-      const polygonStore = usePolygonStore();
-      const crosshairsStore = useCrosshairsToolStore();
-      const paintStore = usePaintToolStore();
-      const cropStore = useCropStore();
 
-      rulerStore.deserialize(manifest, dataIDMap);
-      rectangleStore.deserialize(manifest, dataIDMap);
-      polygonStore.deserialize(manifest, dataIDMap);
-      crosshairsStore.deserialize(manifest);
-      paintStore.deserialize(manifest, labelmapIDMap);
-      cropStore.deserialize(manifest, dataIDMap);
+      Object.values(ToolStoreMap)
+        .map((useStore) => useStore?.())
+        .filter((store): store is IToolStore => !!store)
+        .forEach((store) => {
+          store.deserialize?.(manifest, dataIDMap);
+        });
+
       this.currentTool = tools.current;
     },
   },
diff --git a/src/store/tools/polygons.ts b/src/store/tools/polygons.ts
index 320618baa..57bab556c 100644
--- a/src/store/tools/polygons.ts
+++ b/src/store/tools/polygons.ts
@@ -1,9 +1,8 @@
-import { defineStore } from 'pinia';
 import type { Vector3 } from '@kitware/vtk.js/types';
 import { POLYGON_LABEL_DEFAULTS } from '@/src/config';
 import { Manifest, StateFile } from '@/src/io/state-file/schema';
 import { ToolID } from '@/src/types/annotation-tool';
-
+import { defineAnnotationToolStore } from '@/src/utils/defineAnnotationToolStore';
 import { useAnnotationTool } from './useAnnotationTool';
 
 const toolDefaults = () => ({
@@ -12,34 +11,30 @@ const toolDefaults = () => ({
   name: 'Polygon',
 });
 
-export const usePolygonStore = defineStore('polygon', () => {
-  type _This = ReturnType<typeof usePolygonStore>;
-
-  const {
-    serialize: serializeTool,
-    deserialize: deserializeTool,
-    ...toolStoreProps
-  } = useAnnotationTool({
+export const usePolygonStore = defineAnnotationToolStore('polygon', () => {
+  const toolAPI = useAnnotationTool({
     toolDefaults,
     initialLabels: POLYGON_LABEL_DEFAULTS,
   });
 
+  function getPoints(id: ToolID) {
+    const tool = toolAPI.toolByID.value[id];
+    return tool.points;
+  }
+
   // --- serialization --- //
 
   function serialize(state: StateFile) {
-    state.manifest.tools.polygons = serializeTool();
+    state.manifest.tools.polygons = toolAPI.serializeTools();
   }
 
-  function deserialize(
-    this: _This,
-    manifest: Manifest,
-    dataIDMap: Record<string, string>
-  ) {
-    deserializeTool.call(this, manifest.tools.polygons, dataIDMap);
+  function deserialize(manifest: Manifest, dataIDMap: Record<string, string>) {
+    toolAPI.deserializeTools(manifest.tools.polygons, dataIDMap);
   }
 
   return {
-    ...toolStoreProps,
+    ...toolAPI,
+    getPoints,
     serialize,
     deserialize,
   };
diff --git a/src/store/tools/rectangles.ts b/src/store/tools/rectangles.ts
index f043dbf8a..adbb98a9d 100644
--- a/src/store/tools/rectangles.ts
+++ b/src/store/tools/rectangles.ts
@@ -1,4 +1,4 @@
-import { defineStore } from 'pinia';
+import { defineAnnotationToolStore } from '@/src/utils/defineAnnotationToolStore';
 import type { Vector3 } from '@kitware/vtk.js/types';
 import { Manifest, StateFile } from '@/src/io/state-file/schema';
 import { RECTANGLE_LABEL_DEFAULTS } from '@/src/config';
@@ -18,35 +18,31 @@ const newLabelDefault = {
   fillColor: 'transparent',
 };
 
-export const useRectangleStore = defineStore('rectangles', () => {
-  type _This = ReturnType<typeof useRectangleStore>;
-
-  const {
-    serialize: serializeTool,
-    deserialize: deserializeTool,
-    ...toolStoreProps
-  } = useAnnotationTool({
+export const useRectangleStore = defineAnnotationToolStore('rectangles', () => {
+  const toolAPI = useAnnotationTool({
     toolDefaults: rectangleDefaults,
     initialLabels: RECTANGLE_LABEL_DEFAULTS,
     newLabelDefault,
   });
 
+  function getPoints(id: ToolID) {
+    const tool = toolAPI.toolByID.value[id];
+    return [tool.firstPoint, tool.secondPoint];
+  }
+
   // --- serialization --- //
 
   function serialize(state: StateFile) {
-    state.manifest.tools.rectangles = serializeTool();
+    state.manifest.tools.rectangles = toolAPI.serializeTools();
   }
 
-  function deserialize(
-    this: _This,
-    manifest: Manifest,
-    dataIDMap: Record<string, string>
-  ) {
-    deserializeTool.call(this, manifest.tools.rectangles, dataIDMap);
+  function deserialize(manifest: Manifest, dataIDMap: Record<string, string>) {
+    toolAPI.deserializeTools(manifest.tools.rectangles, dataIDMap);
   }
 
   return {
-    ...toolStoreProps,
+    ...toolAPI,
+    getPoints,
     serialize,
     deserialize,
   };
diff --git a/src/store/tools/rulers.ts b/src/store/tools/rulers.ts
index 7da2b78cd..f12a82cc4 100644
--- a/src/store/tools/rulers.ts
+++ b/src/store/tools/rulers.ts
@@ -1,7 +1,8 @@
 import { computed } from 'vue';
-import { defineStore } from 'pinia';
+import { defineAnnotationToolStore } from '@/src/utils/defineAnnotationToolStore';
 import type { Vector3 } from '@kitware/vtk.js/types';
 import { distance2BetweenPoints } from '@kitware/vtk.js/Common/Core/Math';
+import { ToolID } from '@/src/types/annotation-tool';
 
 import { RULER_LABEL_DEFAULTS } from '@/src/config';
 import { Manifest, StateFile } from '@/src/io/state-file/schema';
@@ -15,9 +16,7 @@ const rulerDefaults = () => ({
   name: 'Ruler',
 });
 
-export const useRulerStore = defineStore('ruler', () => {
-  type _This = ReturnType<typeof useRulerStore>;
-
+export const useRulerStore = defineAnnotationToolStore('ruler', () => {
   const annotationTool = useAnnotationTool({
     toolDefaults: rulerDefaults,
     initialLabels: RULER_LABEL_DEFAULTS,
@@ -32,8 +31,8 @@ export const useRulerStore = defineStore('ruler', () => {
     updateTool: updateRuler,
     removeTool: removeRuler,
     jumpToTool: jumpToRuler,
-    serialize: serializeTool,
-    deserialize: deserializeTool,
+    serializeTools,
+    deserializeTools,
   } = annotationTool;
 
   const lengthByID = computed<Record<string, number>>(() => {
@@ -46,18 +45,19 @@ export const useRulerStore = defineStore('ruler', () => {
     }, {});
   });
 
+  function getPoints(id: ToolID) {
+    const tool = annotationTool.toolByID.value[id];
+    return [tool.firstPoint, tool.secondPoint];
+  }
+
   // --- serialization --- //
 
   function serialize(state: StateFile) {
-    state.manifest.tools.rulers = serializeTool();
+    state.manifest.tools.rulers = serializeTools();
   }
 
-  function deserialize(
-    this: _This,
-    manifest: Manifest,
-    dataIDMap: Record<string, string>
-  ) {
-    deserializeTool.call(this, manifest.tools.rulers, dataIDMap);
+  function deserialize(manifest: Manifest, dataIDMap: Record<string, string>) {
+    deserializeTools(manifest.tools.rulers, dataIDMap);
   }
 
   return {
@@ -70,6 +70,7 @@ export const useRulerStore = defineStore('ruler', () => {
     updateRuler,
     removeRuler,
     jumpToRuler,
+    getPoints,
     serialize,
     deserialize,
   };
diff --git a/src/store/tools/toolSelection.ts b/src/store/tools/toolSelection.ts
new file mode 100644
index 000000000..761957f2c
--- /dev/null
+++ b/src/store/tools/toolSelection.ts
@@ -0,0 +1,62 @@
+import { AnnotationToolType } from '@/src/store/tools/types';
+import { ToolID } from '@/src/types/annotation-tool';
+import { defineStore, storeToRefs } from 'pinia';
+import { computed, ref, watch } from 'vue';
+import { useDatasetStore } from '@/src/store/datasets';
+
+export interface ToolSelection {
+  id: ToolID;
+  type: AnnotationToolType;
+}
+export const useToolSelectionStore = defineStore('tool-selection', () => {
+  type Selections = Record<ToolID, AnnotationToolType>;
+  const selectionMap = ref<Selections>(Object.create(null));
+
+  function addSelection(id: ToolID, type: AnnotationToolType) {
+    if (id in selectionMap.value) return;
+    selectionMap.value[id] = type;
+  }
+
+  function clearSelection() {
+    selectionMap.value = Object.create(null);
+  }
+
+  function removeSelection(id: ToolID) {
+    if (!(id in selectionMap.value)) return;
+    delete selectionMap.value[id];
+  }
+
+  function toggleSelection(id: ToolID, type: AnnotationToolType) {
+    if (id in selectionMap.value) {
+      removeSelection(id);
+    } else {
+      addSelection(id, type);
+    }
+  }
+
+  function isSelected(id: ToolID) {
+    return id in selectionMap.value;
+  }
+
+  const selection = computed<ToolSelection[]>(() => {
+    return Object.entries(selectionMap.value).map(([id, type]) => ({
+      id: id as ToolID,
+      type,
+    }));
+  });
+
+  const { primarySelection } = storeToRefs(useDatasetStore());
+
+  watch(primarySelection, () => {
+    clearSelection();
+  });
+
+  return {
+    addSelection,
+    clearSelection,
+    removeSelection,
+    toggleSelection,
+    isSelected,
+    selection,
+  };
+});
diff --git a/src/store/tools/types.ts b/src/store/tools/types.ts
index f73e6e8d3..b2db6a05d 100644
--- a/src/store/tools/types.ts
+++ b/src/store/tools/types.ts
@@ -1,12 +1,36 @@
+import type { Manifest, StateFile } from '@/src/io/state-file/schema';
+import { Store } from 'pinia';
+
+export enum AnnotationToolType {
+  Rectangle = 'Rectangle',
+  Ruler = 'Ruler',
+  Polygon = 'Polygon',
+}
+
 export enum Tools {
   WindowLevel = 'WindowLevel',
   Pan = 'Pan',
   Zoom = 'Zoom',
-  Ruler = 'Ruler',
+  Crop = 'Crop',
   Paint = 'Paint',
-  Rectangle = 'Rectangle',
+  Select = 'Select',
   Crosshairs = 'Crosshairs',
-  Crop = 'Crop',
+  Rectangle = 'Rectangle',
+  Ruler = 'Ruler',
   Polygon = 'Polygon',
-  Select = 'Select',
 }
+
+export interface IActivatableTool {
+  activateTool: () => boolean;
+  deactivateTool: () => void;
+}
+
+export interface ISerializableTool {
+  serialize: (state: StateFile) => void;
+  deserialize: (manifest: Manifest, dataIDMap: Record<string, string>) => void;
+}
+
+export interface IToolStore
+  extends Partial<IActivatableTool>,
+    Partial<ISerializableTool>,
+    Store {}
diff --git a/src/store/tools/useAnnotationTool.ts b/src/store/tools/useAnnotationTool.ts
index 84b66eb5f..56f858f57 100644
--- a/src/store/tools/useAnnotationTool.ts
+++ b/src/store/tools/useAnnotationTool.ts
@@ -1,7 +1,7 @@
 import { Ref, UnwrapNestedRefs, computed, ref, watch } from 'vue';
-import { Store, StoreActions, StoreGetters, StoreState } from 'pinia';
-
-import { Maybe, PartialWithRequired } from '@/src/types';
+import { StoreActions, StoreGetters, StoreState } from 'pinia';
+import type { Vector3 } from '@kitware/vtk.js/types';
+import type { Maybe, PartialWithRequired } from '@/src/types';
 import {
   STROKE_WIDTH_ANNOTATION_TOOL_DEFAULT,
   TOOL_COLORS,
@@ -15,6 +15,8 @@ import { LPSAxisDir } from '@/src/types/lps';
 import { AnnotationTool, ToolID } from '@/src/types/annotation-tool';
 import { findImageID, getDataID } from '@/src/store/datasets';
 import { useIdStore } from '@/src/store/id';
+import { useToolSelectionStore } from '@/src/store/tools/toolSelection';
+import type { IToolStore } from '@/src/store/tools/types';
 import useViewSliceStore from '../view-configs/slicing';
 import { useLabels, Labels } from './useLabels';
 
@@ -62,8 +64,9 @@ export const useAnnotationTool = <
     return toolIDs.value.map((id) => byID[id]);
   });
 
+  type FinishedTool = Tool & { placing: true };
   const finishedTools = computed(() =>
-    tools.value.filter((tool) => !tool.placing)
+    tools.value.filter((tool): tool is FinishedTool => !tool.placing)
   );
 
   const labels = useLabels({
@@ -82,7 +85,7 @@ export const useAnnotationTool = <
     return { labelName: '' };
   }
 
-  function addTool(this: Store, tool: ToolPatch): ToolID {
+  function addTool(tool: ToolPatch): ToolID {
     const id = useIdStore().nextId() as ToolID;
     if (id in toolByID.value) {
       throw new Error('Cannot add tool with conflicting ID');
@@ -107,12 +110,21 @@ export const useAnnotationTool = <
 
     removeFromArray(toolIDs.value, id);
     delete toolByID.value[id];
+
+    const selectionStore = useToolSelectionStore();
+    selectionStore.removeSelection(id);
   }
 
   function updateTool(id: ToolID, patch: ToolPatch) {
     if (!(id in toolByID.value)) return;
 
     toolByID.value[id] = { ...toolByID.value[id], ...patch, id };
+
+    // de-select whenever hiding a tool
+    if (patch.hidden) {
+      const selectionStore = useToolSelectionStore();
+      selectionStore.removeSelection(id);
+    }
   }
 
   // updates props controlled by labels
@@ -153,10 +165,7 @@ export const useAnnotationTool = <
     });
   }
 
-  const activateTool = () => true;
-  const deactivateTool = () => {};
-
-  const serialize = () => {
+  const serializeTools = () => {
     const toolsSerialized = toolIDs.value
       .map((toolID) => toolByID.value[toolID])
       .filter((tool) => !tool.placing)
@@ -176,8 +185,7 @@ export const useAnnotationTool = <
     tools: PartialWithRequired<Tool, 'imageID'>[];
     labels: Labels<Tool>;
   };
-  function deserialize(
-    this: Store,
+  function deserializeTools(
     serialized: Maybe<Serialized>,
     dataIDMap: Record<string, string>
   ) {
@@ -202,7 +210,7 @@ export const useAnnotationTool = <
             label: (label && labelIDMap[label]) || '',
           } as ToolPatch)
       )
-      .forEach((tool) => addTool.call(this, tool));
+      .forEach((tool) => addTool(tool));
   }
 
   return {
@@ -215,26 +223,25 @@ export const useAnnotationTool = <
     removeTool,
     updateTool,
     jumpToTool,
-    activateTool,
-    deactivateTool,
-    serialize,
-    deserialize,
+    serializeTools,
+    deserializeTools,
   };
 };
 
-type ToolFactory = (...args: any) => AnnotationTool;
-type UseAnnotationTool = ReturnType<
-  typeof useAnnotationTool<ToolFactory, unknown>
->;
-
-type UseAnnotationToolNoSerialize = Omit<
-  UseAnnotationTool,
-  'serialize' | 'deserialize'
->;
-
-export type AnnotationToolStore<
-  UseAnnotationToolWithID = UseAnnotationToolNoSerialize
-> = StoreState<UseAnnotationToolWithID> &
-  StoreActions<UseAnnotationToolWithID> &
-  UnwrapNestedRefs<StoreGetters<UseAnnotationToolWithID>> & // adds computed props like tools
-  Store; // adds Pinia plugins;
+type ToolFactory<T extends AnnotationTool> = (...args: any[]) => T;
+
+export type AnnotationToolAPI<T extends AnnotationTool> = ReturnType<
+  typeof useAnnotationTool<ToolFactory<T>, any>
+> & {
+  getPoints(id: ToolID): Vector3[];
+};
+
+type UseAnnotationToolBasedStore<T extends AnnotationTool> = StoreState<
+  AnnotationToolAPI<T>
+> &
+  StoreActions<AnnotationToolAPI<T>> &
+  UnwrapNestedRefs<StoreGetters<AnnotationToolAPI<T>>>;
+
+export interface AnnotationToolStore<T extends AnnotationTool = AnnotationTool>
+  extends UseAnnotationToolBasedStore<T>,
+    IToolStore {}
diff --git a/src/types/annotation-tool.ts b/src/types/annotation-tool.ts
index c905238cc..aad4e18e0 100644
--- a/src/types/annotation-tool.ts
+++ b/src/types/annotation-tool.ts
@@ -1,6 +1,4 @@
-import type { Vector2 } from '@kitware/vtk.js/types';
 import { FrameOfReference } from '../utils/frameOfReference';
-import { WidgetAction } from '../vtk/ToolWidgetUtils/utils';
 
 export type ToolID = string & { __type: 'ToolID' };
 
@@ -31,8 +29,3 @@ export type AnnotationTool = {
 
   hidden?: boolean;
 };
-
-export type ContextMenuEvent = {
-  displayXY: Vector2;
-  widgetActions: Array<WidgetAction>;
-};
diff --git a/src/utils/defineAnnotationToolStore.ts b/src/utils/defineAnnotationToolStore.ts
new file mode 100644
index 000000000..9eb45c8dc
--- /dev/null
+++ b/src/utils/defineAnnotationToolStore.ts
@@ -0,0 +1,18 @@
+import { AnnotationToolAPI } from '@/src/store/tools/useAnnotationTool';
+import { AnnotationTool } from '@/src/types/annotation-tool';
+import { defineStore } from 'pinia';
+
+/**
+ * Type helper for enforcing the typing for annotation tool stores.
+ *
+ * Requires setup store usage rather than template usage.
+ * @param name
+ * @param setup
+ * @returns
+ */
+export function defineAnnotationToolStore<
+  T extends AnnotationTool,
+  S extends AnnotationToolAPI<T>
+>(name: string, setup: () => S) {
+  return defineStore(name, setup);
+}
diff --git a/src/vtk/PolygonWidget/behavior.ts b/src/vtk/PolygonWidget/behavior.ts
index 8ed8ffe80..3591a2130 100644
--- a/src/vtk/PolygonWidget/behavior.ts
+++ b/src/vtk/PolygonWidget/behavior.ts
@@ -3,7 +3,7 @@ import macro from '@kitware/vtk.js/macros';
 import { Vector3 } from '@kitware/vtk.js/types';
 import vtkRenderer from '@kitware/vtk.js/Rendering/Core/Renderer';
 
-import { WidgetAction } from '../ToolWidgetUtils/utils';
+import { WidgetAction } from '@/src/vtk/ToolWidgetUtils/types';
 
 type Position3d = { x: number; y: number; z: number };
 type vtkMouseEvent = {
@@ -167,6 +167,10 @@ export default function widgetBehavior(publicAPI: any, model: any) {
       return macro.VOID;
     }
 
+    if (checkOverSegment()) {
+      return macro.VOID;
+    }
+
     const manipulator =
       model.activeState?.getManipulator?.() ?? model.manipulator;
     if (model.widgetState.getPlacing() && manipulator) {
@@ -193,21 +197,6 @@ export default function widgetBehavior(publicAPI: any, model: any) {
       return macro.EVENT_ABORT;
     }
 
-    if (checkOverSegment()) {
-      // insert point
-      const insertIndex = model.activeState.getIndex() + 1;
-      const newHandle = model.widgetState.addHandle({ insertIndex });
-      const coords = getWorldCoords(event);
-      if (!coords) throw new Error('No world coords');
-      newHandle.setOrigin(coords);
-      // enable dragging immediately
-      publicAPI.activateHandle({
-        selectedState: newHandle,
-        representation: model.representations[0].getActors()[0], // first actor is GlyphMapper for handles
-      });
-      overUnselectedHandle = true;
-    }
-
     if (model.activeState?.getActive() && model.pickable && model.dragable) {
       model._isDragging = true;
       model._apiSpecificRenderWindow.setCursor('grabbing');
@@ -361,14 +350,32 @@ export default function widgetBehavior(publicAPI: any, model: any) {
   // Right press: Remove last handle / Pop context menu
   // --------------------------------------------------------------------------
 
-  const makeWidgetActions = () => {
+  const makeWidgetActions = (eventData: any) => {
     const widgetActions: Array<WidgetAction> = [];
 
     const { activeState } = model;
 
     const overSegment = checkOverSegment();
-    // if hovering on handle and we will still have at least 2 points after removing handle
-    if (!overSegment && model.widgetState.getHandles().length > 2) {
+
+    if (overSegment) {
+      // Allow inserting ponts when over a segment
+      widgetActions.push({
+        name: 'Add Point',
+        func: () => {
+          const insertIndex = activeState.getIndex() + 1;
+          const newHandle = model.widgetState.addHandle({ insertIndex });
+          const coords = getWorldCoords(eventData);
+          if (!coords) throw new Error('No world coords');
+          newHandle.setOrigin(coords);
+          // enable dragging immediately
+          publicAPI.activateHandle({
+            selectedState: newHandle,
+            representation: model.representations[0].getActors()[0], // first actor is GlyphMapper for handles
+          });
+        },
+      });
+    } else if (!overSegment && model.widgetState.getHandles().length > 2) {
+      // if hovering on handle and we will still have at least 2 points after removing handle
       widgetActions.push({
         name: 'Delete Point',
         func: () => {
@@ -392,7 +399,7 @@ export default function widgetBehavior(publicAPI: any, model: any) {
 
     const eventWithWidgetAction = {
       ...eventData,
-      widgetActions: makeWidgetActions(),
+      widgetActions: makeWidgetActions(eventData),
     };
 
     publicAPI.invokeRightClickEvent(eventWithWidgetAction);
@@ -429,4 +436,8 @@ export default function widgetBehavior(publicAPI: any, model: any) {
     model.hasFocus = false;
     model._widgetManager.enablePicking();
   };
+
+  publicAPI.delete = macro.chain(() => {
+    publicAPI.resetInteractions();
+  }, publicAPI.delete);
 }
diff --git a/src/vtk/PolygonWidget/index.d.ts b/src/vtk/PolygonWidget/index.d.ts
index c22231ff8..e91832340 100644
--- a/src/vtk/PolygonWidget/index.d.ts
+++ b/src/vtk/PolygonWidget/index.d.ts
@@ -7,12 +7,14 @@ import { usePolygonStore } from '@/src/store/tools/polygons';
 import {
   vtkAnnotationToolWidget,
   vtkAnnotationWidgetPointState,
-} from '../ToolWidgetUtils/utils';
+  vtkAnnotationWidgetState,
+} from '@/src/vtk/ToolWidgetUtils/types';
+import { IAnnotationToolWidgetInitialValues } from '@/src/types/annotation-tool';
 
 export interface vtkPolygonWidgetPointState
   extends vtkAnnotationWidgetPointState {}
 
-export interface vtkPolygonWidgetState extends vtkWidgetState {
+export interface vtkPolygonWidgetState extends vtkAnnotationWidgetState {
   getMoveHandle(): any;
   clearHandles(): void;
   getPlacing(): boolean;
@@ -25,10 +27,8 @@ export interface vtkPolygonViewWidget extends vtkAnnotationToolWidget {
   getWidgetState(): vtkPolygonWidgetState;
 }
 
-export interface IPolygonWidgetInitialValues {
-  id: string;
-  store: ReturnType<typeof usePolygonStore>;
-}
+export interface IPolygonWidgetInitialValues
+  extends IAnnotationToolWidgetInitialValues {}
 
 export interface vtkPolygonWidget extends vtkAbstractWidgetFactory {
   getLength(): number;
diff --git a/src/vtk/PolygonWidget/state.ts b/src/vtk/PolygonWidget/state.ts
index a580fce10..57aa9a3f2 100644
--- a/src/vtk/PolygonWidget/state.ts
+++ b/src/vtk/PolygonWidget/state.ts
@@ -4,7 +4,9 @@ import bounds from '@kitware/vtk.js/Widgets/Core/StateBuilder/boundsMixin';
 import visibleMixin from '@kitware/vtk.js/Widgets/Core/StateBuilder/visibleMixin';
 import scale1Mixin from '@kitware/vtk.js/Widgets/Core/StateBuilder/scale1Mixin';
 import { Vector3 } from '@kitware/vtk.js/types';
-
+import vtkAnnotationWidgetState from '@/src/vtk/ToolWidgetUtils/annotationWidgetState';
+import { Polygon } from '@/src/types/polygon';
+import { AnnotationToolType } from '@/src/store/tools/types';
 import createPointState from '../ToolWidgetUtils/pointState';
 import { watchState } from '../ToolWidgetUtils/utils';
 
@@ -25,13 +27,13 @@ function vtkPolygonWidgetState(publicAPI: any, model: any) {
   model.classHierarchy.push('vtkPolygonWidgetState');
   model.moveHandle = createPointState({
     id: model.id,
-    store: model._store,
+    store: publicAPI.getStore(),
     key: 'movePoint',
     visible: true,
   });
   watchState(publicAPI, model.moveHandle, () => publicAPI.modified());
 
-  const getTool = () => model._store.toolByID[model.id];
+  const getTool = () => publicAPI.getStore().toolByID[model.id] as Polygon;
 
   model.handles = [];
 
@@ -121,6 +123,7 @@ function vtkPolygonWidgetState(publicAPI: any, model: any) {
 }
 
 const defaultValues = (initialValues: any) => ({
+  toolType: AnnotationToolType.Polygon,
   ...initialValues,
 });
 
@@ -130,12 +133,11 @@ function _createPolygonWidgetState(
   initialValues: any
 ) {
   Object.assign(model, defaultValues(initialValues));
-  vtkWidgetState.extend(publicAPI, model, initialValues);
+  vtkAnnotationWidgetState.extend(publicAPI, model, initialValues);
   bounds.extend(publicAPI, model);
 
-  macro.get(publicAPI, model, ['id', 'handles', 'moveHandle', 'finishable']);
+  macro.get(publicAPI, model, ['handles', 'moveHandle', 'finishable']);
   macro.setGet(publicAPI, model, ['finishable']);
-  macro.moveToProtected(publicAPI, model, ['store']);
 
   vtkPolygonWidgetState(publicAPI, model);
 }
diff --git a/src/vtk/RectangleWidget/index.d.ts b/src/vtk/RectangleWidget/index.d.ts
index 3b6f3fc79..4e4a59e2e 100644
--- a/src/vtk/RectangleWidget/index.d.ts
+++ b/src/vtk/RectangleWidget/index.d.ts
@@ -20,9 +20,7 @@ export interface vtkRectangleWidgetState extends vtkRulerWidgetState {}
 export interface vtkRectangleViewWidget extends vtkRulerViewWidget {}
 
 export interface IRectangleWidgetInitialValues
-  extends IRulerWidgetInitialValues {
-  store: ReturnType<typeof useRectangleStore>;
-}
+  extends IRulerWidgetInitialValues {}
 
 export interface vtkRectangleWidget extends vtkRulerWidget {}
 
diff --git a/src/vtk/RectangleWidget/index.js b/src/vtk/RectangleWidget/index.js
index 737ae6d5d..3ab57fc3e 100644
--- a/src/vtk/RectangleWidget/index.js
+++ b/src/vtk/RectangleWidget/index.js
@@ -1,5 +1,6 @@
 import macro from '@kitware/vtk.js/macro';
 
+import { AnnotationToolType } from '@/src/store/tools/types';
 import vtkRulerWidget from '../RulerWidget';
 import vtkRectangleLineRepresentation from './RectangleLineRepresentation';
 
@@ -34,15 +35,10 @@ const DEFAULT_VALUES = {};
 export function extend(publicAPI, model, initialValues = {}) {
   Object.assign(model, DEFAULT_VALUES, initialValues);
 
-  const { store: toolStore, ...rest } = initialValues;
-
-  const rulerStore = {
-    ...toolStore,
-    rulerByID: toolStore.toolByID,
-    updateRuler: toolStore.updateTool,
-  };
-
-  vtkRulerWidget.extend(publicAPI, model, { store: rulerStore, ...rest });
+  vtkRulerWidget.extend(publicAPI, model, {
+    ...initialValues,
+    toolType: AnnotationToolType.Rectangle,
+  });
 
   vtkRectangleWidget(publicAPI, model);
 }
diff --git a/src/vtk/RulerWidget/behavior.ts b/src/vtk/RulerWidget/behavior.ts
index 28392d9fa..d9404728d 100644
--- a/src/vtk/RulerWidget/behavior.ts
+++ b/src/vtk/RulerWidget/behavior.ts
@@ -218,4 +218,8 @@ export default function widgetBehavior(publicAPI: any, model: any) {
   publicAPI.loseFocus = () => {
     throw new Error('loseFocus is not implemented');
   };
+
+  publicAPI.delete = macro.chain(() => {
+    publicAPI.resetInteractions();
+  }, publicAPI.delete);
 }
diff --git a/src/vtk/RulerWidget/index.d.ts b/src/vtk/RulerWidget/index.d.ts
index 7d41ccd8b..7ecd171f5 100644
--- a/src/vtk/RulerWidget/index.d.ts
+++ b/src/vtk/RulerWidget/index.d.ts
@@ -6,16 +6,19 @@ import { InteractionState } from './behavior';
 import { useRulerStore } from '@/src/store/tools/rulers';
 import vtkWidgetState from '@kitware/vtk.js/Widgets/Core/WidgetState';
 import {
+  IAnnotationToolWidgetInitialValues,
   vtkAnnotationToolWidget,
   vtkAnnotationWidgetPointState,
-} from '../ToolWidgetUtils/utils';
+  vtkAnnotationWidgetState,
+} from '@/src/vtk/ToolWidgetUtils/types';
+import { AnnotationToolType } from '@/src/store/tools/types';
 
 export { InteractionState } from './behavior';
 
 export interface vtkRulerWidgetPointState
   extends vtkAnnotationWidgetPointState {}
 
-export interface vtkRulerWidgetState extends vtkWidgetState {
+export interface vtkRulerWidgetState extends vtkAnnotationWidgetState {
   setIsPlaced(isPlaced: boolean): boolean;
   getIsPlaced(): boolean;
   getFirstPoint(): vtkRulerWidgetPointState;
@@ -28,9 +31,8 @@ export interface vtkRulerViewWidget extends vtkAnnotationToolWidget {
   getWidgetState(): vtkRulerWidgetState;
 }
 
-export interface IRulerWidgetInitialValues {
-  id: string;
-  store: ReturnType<typeof useRulerStore>;
+export interface IRulerWidgetInitialValues
+  extends IAnnotationToolWidgetInitialValues {
   isPlaced: boolean;
 }
 
diff --git a/src/vtk/RulerWidget/state.ts b/src/vtk/RulerWidget/state.ts
index 6ecb2f44d..421d1c590 100644
--- a/src/vtk/RulerWidget/state.ts
+++ b/src/vtk/RulerWidget/state.ts
@@ -1,6 +1,7 @@
 import macro from '@kitware/vtk.js/macros';
-import vtkWidgetState from '@kitware/vtk.js/Widgets/Core/WidgetState';
 import bounds from '@kitware/vtk.js/Widgets/Core/StateBuilder/boundsMixin';
+import vtkAnnotationWidgetState from '@/src/vtk/ToolWidgetUtils/annotationWidgetState';
+import { AnnotationToolType } from '@/src/store/tools/types';
 
 import createPointState from '../ToolWidgetUtils/pointState';
 import { watchState } from '../ToolWidgetUtils/utils';
@@ -10,13 +11,13 @@ export const PointsLabel = 'points';
 function vtkRulerWidgetState(publicAPI: any, model: any) {
   const firstPoint = createPointState({
     id: model.id,
-    store: model._store,
+    store: publicAPI.getStore(),
     key: 'firstPoint',
     visible: true,
   });
   const secondPoint = createPointState({
     id: model.id,
-    store: model._store,
+    store: publicAPI.getStore(),
     key: 'secondPoint',
     visible: true,
   });
@@ -33,6 +34,7 @@ function vtkRulerWidgetState(publicAPI: any, model: any) {
 }
 
 const defaultValues = (initialValues: any) => ({
+  toolType: AnnotationToolType.Ruler,
   isPlaced: false,
   ...initialValues,
 });
@@ -43,12 +45,10 @@ function _createRulerWidgetState(
   initialValues: any
 ) {
   Object.assign(model, defaultValues(initialValues));
-  vtkWidgetState.extend(publicAPI, model, initialValues);
+  vtkAnnotationWidgetState.extend(publicAPI, model, initialValues);
   bounds.extend(publicAPI, model);
 
-  macro.get(publicAPI, model, ['id']);
   macro.setGet(publicAPI, model, ['isPlaced']);
-  macro.moveToProtected(publicAPI, model, ['store']);
 
   vtkRulerWidgetState(publicAPI, model);
 }
diff --git a/src/vtk/ToolWidgetUtils/annotationWidgetState.ts b/src/vtk/ToolWidgetUtils/annotationWidgetState.ts
new file mode 100644
index 000000000..19c10051b
--- /dev/null
+++ b/src/vtk/ToolWidgetUtils/annotationWidgetState.ts
@@ -0,0 +1,21 @@
+import { useAnnotationToolStore } from '@/src/store/tools';
+import { IAnnotationToolWidgetInitialValues } from '@/src/vtk/ToolWidgetUtils/types';
+import vtkWidgetState from '@kitware/vtk.js/Widgets/Core/WidgetState';
+import macro from '@kitware/vtk.js/macros';
+
+function extend(
+  publicAPI: any,
+  model: any,
+  initialValues: IAnnotationToolWidgetInitialValues
+) {
+  vtkWidgetState.extend(publicAPI, model, initialValues);
+  macro.get(publicAPI, model, ['id', 'toolType']);
+
+  publicAPI.getStore = () => useAnnotationToolStore(model.toolType);
+}
+
+export declare const vtkAnnotationWidgetState: {
+  extend: typeof extend;
+};
+
+export default { extend };
diff --git a/src/vtk/ToolWidgetUtils/types.ts b/src/vtk/ToolWidgetUtils/types.ts
new file mode 100644
index 000000000..6ff4b3e6b
--- /dev/null
+++ b/src/vtk/ToolWidgetUtils/types.ts
@@ -0,0 +1,42 @@
+import { VTKEventHandler } from '@/src/composables/onVTKEvent';
+import { AnnotationToolType } from '@/src/store/tools/types';
+import { ToolID } from '@/src/types/annotation-tool';
+import vtkAbstractWidget from '@kitware/vtk.js/Widgets/Core/AbstractWidget';
+import vtkWidgetState from '@kitware/vtk.js/Widgets/Core/WidgetState';
+import vtkPlaneManipulator from '@kitware/vtk.js/Widgets/Manipulators/PlaneManipulator';
+import { vtkSubscription } from '@kitware/vtk.js/interfaces';
+import { Vector2, Vector3 } from '@kitware/vtk.js/types';
+
+export type WidgetAction = {
+  name: string;
+  func: () => void;
+};
+
+export type ContextMenuEvent = {
+  displayXY: Vector2;
+  widgetActions: Array<WidgetAction>;
+};
+
+export interface vtkAnnotationWidgetPointState extends vtkWidgetState {
+  getVisible(): boolean;
+  getOrigin(): Vector3 | null;
+}
+
+export interface vtkAnnotationWidgetState extends vtkWidgetState {
+  getId(): ToolID;
+  getToolType(): AnnotationToolType;
+}
+
+export interface IAnnotationToolWidgetInitialValues {
+  id: ToolID;
+}
+
+export interface vtkAnnotationToolWidget extends vtkAbstractWidget {
+  setManipulator(manipulator: vtkPlaneManipulator): boolean;
+  getManipulator(): vtkPlaneManipulator;
+  onRightClickEvent(cb: VTKEventHandler): vtkSubscription;
+  onPlacedEvent(cb: VTKEventHandler): vtkSubscription;
+  onHoverEvent(cb: VTKEventHandler): vtkSubscription;
+  resetInteractions(): void;
+  getWidgetState(): vtkAnnotationWidgetState;
+}
diff --git a/src/vtk/ToolWidgetUtils/utils.ts b/src/vtk/ToolWidgetUtils/utils.ts
index 60fdc55f8..af41b2acf 100644
--- a/src/vtk/ToolWidgetUtils/utils.ts
+++ b/src/vtk/ToolWidgetUtils/utils.ts
@@ -1,9 +1,4 @@
 import { Maybe } from '@/src/types';
-import vtkAbstractWidget from '@kitware/vtk.js/Widgets/Core/AbstractWidget';
-import vtkWidgetState from '@kitware/vtk.js/Widgets/Core/WidgetState';
-import vtkPlaneManipulator from '@kitware/vtk.js/Widgets/Manipulators/PlaneManipulator';
-import { vtkSubscription } from '@kitware/vtk.js/interfaces';
-import { Vector3 } from '@kitware/vtk.js/types';
 import { Store } from 'pinia';
 
 export function watchStore<T>(
@@ -41,22 +36,3 @@ export function watchState(
     originalDelete();
   };
 }
-
-export type WidgetAction = {
-  name: string;
-  func: () => void;
-};
-
-export interface vtkAnnotationToolWidget extends vtkAbstractWidget {
-  setManipulator(manipulator: vtkPlaneManipulator): boolean;
-  getManipulator(): vtkPlaneManipulator;
-  onRightClickEvent(cb: (eventData: any) => void): vtkSubscription;
-  onPlacedEvent(cb: (eventData: any) => void): vtkSubscription;
-  onHoverEvent(cb: (eventData: any) => void): vtkSubscription;
-  resetInteractions(): void;
-}
-
-export interface vtkAnnotationWidgetPointState extends vtkWidgetState {
-  getVisible(): boolean;
-  getOrigin(): Vector3 | null;
-}